diff --git a/.ci/docker/Dockerfile b/.ci/docker/Dockerfile
new file mode 100644
index 00000000000..8aefbfe8f47
--- /dev/null
+++ b/.ci/docker/Dockerfile
@@ -0,0 +1,25 @@
+ARG BASE_IMAGE
+FROM ${BASE_IMAGE}
+
+ENV DEBIAN_FRONTEND noninteractive
+
+# Install common dependencies (so that this step can be cached separately)
+COPY ./common/install_base.sh install_base.sh
+RUN bash ./install_base.sh && rm install_base.sh
+
+# Setup user
+# TODO: figure out how to remove this part
+COPY ./common/install_user.sh install_user.sh
+RUN bash ./install_user.sh && rm install_user.sh
+
+COPY ./common/install_docs_reqs.sh install_docs_reqs.sh
+RUN bash ./install_docs_reqs.sh && rm install_docs_reqs.sh
+
+COPY ./common/install_pip_requirements.sh install_pip_requirements.sh
+COPY ./requirements.txt requirements.txt
+RUN bash ./install_pip_requirements.sh && rm install_pip_requirements.sh
+
+RUN ln -s /usr/bin/python3 /usr/bin/python
+
+USER ci-user
+CMD ["bash"]
diff --git a/.ci/docker/build.sh b/.ci/docker/build.sh
new file mode 100755
index 00000000000..f40c45fea3d
--- /dev/null
+++ b/.ci/docker/build.sh
@@ -0,0 +1,25 @@
+#!/bin/bash
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+set -exu
+
+IMAGE_NAME="$1"
+shift
+
+export UBUNTU_VERSION="22.04"
+export CUDA_VERSION="12.6.3"
+
+export BASE_IMAGE="nvidia/cuda:${CUDA_VERSION}-devel-ubuntu${UBUNTU_VERSION}"
+echo "Building ${IMAGE_NAME} Docker image"
+
+docker build \
+  --no-cache \
+  --progress=plain \
+  -f Dockerfile \
+  --build-arg BASE_IMAGE="${BASE_IMAGE}" \
+  "$@" \
+  .
diff --git a/.ci/docker/common/install_base.sh b/.ci/docker/common/install_base.sh
new file mode 100644
index 00000000000..3100b550a89
--- /dev/null
+++ b/.ci/docker/common/install_base.sh
@@ -0,0 +1,49 @@
+#!/bin/bash
+# Based off of https://github.com/pytorch/pytorch/tree/b52e0bf131a4e55cd987176f9c5a8d2ad6783b4f/.ci/docker
+
+set -ex
+
+install_ubuntu() {
+  # Install common dependencies
+  apt-get update
+  # TODO: Some of these may not be necessary
+  apt-get install -y --no-install-recommends \
+    build-essential \
+    ca-certificates \
+    cmake=3.22* \
+    curl \
+    git \
+    wget \
+    sudo \
+    vim \
+    jq \
+    vim \
+    unzip \
+    gdb \
+    rsync \
+    libssl-dev \
+    p7zip-full \
+    libglfw3 \
+    libglfw3-dev \
+    sox \
+    libsox-dev \
+    libsox-fmt-all \
+    python3-pip \
+    python3-dev
+
+  # Cleanup package manager
+  apt-get autoclean && apt-get clean
+  rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
+}
+
+# Install base packages depending on the base OS
+ID=$(grep -oP '(?<=^ID=).+' /etc/os-release | tr -d '"')
+case "$ID" in
+  ubuntu)
+    install_ubuntu
+    ;;
+  *)
+    echo "Unable to determine OS..."
+    exit 1
+    ;;
+esac
diff --git a/.ci/docker/common/install_docs_reqs.sh b/.ci/docker/common/install_docs_reqs.sh
new file mode 100644
index 00000000000..541c9976ad1
--- /dev/null
+++ b/.ci/docker/common/install_docs_reqs.sh
@@ -0,0 +1,21 @@
+#!/bin/bash
+# Based off of https://github.com/pytorch/pytorch/tree/b52e0bf131a4e55cd987176f9c5a8d2ad6783b4f/.ci/docker
+set -ex
+
+apt-get update
+apt-get install -y gpg-agent
+
+curl --retry 3 -sL https://deb.nodesource.com/setup_20.x | sudo -E bash -
+sudo apt-get install -y nodejs
+
+curl --retry 3 -sS https://dl.yarnpkg.com/debian/pubkey.gpg | sudo apt-key add -
+echo "deb https://dl.yarnpkg.com/debian/ stable main" | sudo tee /etc/apt/sources.list.d/yarn.list
+
+apt-get update
+apt-get install -y --no-install-recommends yarn
+yarn global add katex --prefix /usr/local
+
+sudo apt-get -y install doxygen
+
+apt-get autoclean && apt-get clean
+rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
diff --git a/.ci/docker/common/install_pip_requirements.sh b/.ci/docker/common/install_pip_requirements.sh
new file mode 100644
index 00000000000..a548d200462
--- /dev/null
+++ b/.ci/docker/common/install_pip_requirements.sh
@@ -0,0 +1,7 @@
+#!/bin/bash
+
+set -ex
+
+# Install pip packages
+pip install --upgrade pip
+pip install -r ./requirements.txt
diff --git a/.ci/docker/common/install_user.sh b/.ci/docker/common/install_user.sh
new file mode 100644
index 00000000000..6deb62086bc
--- /dev/null
+++ b/.ci/docker/common/install_user.sh
@@ -0,0 +1,26 @@
+#!/bin/bash
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+# Copied from https://github.com/pytorch/executorch/blob/6e431355a554e5f84c3a05dfa2b981ead90c2b48/.ci/docker/common/install_user.sh#L1
+
+set -ex
+
+# Same as ec2-user
+echo "ci-user:x:1000:1000::/var/lib/ci-user:" >> /etc/passwd
+echo "ci-user:x:1000:" >> /etc/group
+# Needed on Focal or newer
+echo "ci-user:*:19110:0:99999:7:::" >> /etc/shadow
+
+# Create $HOME
+mkdir -p /var/lib/ci-user
+chown ci-user:ci-user /var/lib/ci-user
+
+# Allow sudo
+echo 'ci-user ALL=(ALL) NOPASSWD:ALL' > /etc/sudoers.d/ci-user
+
+# Test that sudo works
+sudo -u ci-user sudo -v
diff --git a/.ci/docker/requirements.txt b/.ci/docker/requirements.txt
new file mode 100644
index 00000000000..964f9aad4ab
--- /dev/null
+++ b/.ci/docker/requirements.txt
@@ -0,0 +1,78 @@
+# --extra-index-url https://download.pytorch.org/whl/cu117/index.html # Use this to run/publish tutorials against the latest binaries during the RC stage. Comment out after the release. Each release verify the correct cuda version.
+# Refer to ./jenkins/build.sh for tutorial build instructions.
+
+# Sphinx dependencies
+sphinx==7.2.6
+sphinx-gallery==0.19.0
+sphinx-reredirects==0.1.4
+sphinx_design==0.6.1
+docutils>=0.18.1,<0.21
+sphinx-copybutton==0.5.2
+sphinx_sitemap==2.7.1
+sphinxcontrib-mermaid==1.0.0
+sphinxcontrib.katex==0.9.10
+pypandoc==1.15
+pandocfilters==1.5.1
+markdown==3.8.2
+
+# PyTorch Theme
+-e git+https://github.com/pytorch/pytorch_sphinx_theme.git@c2e38b37f3c432c610639f06d1d421c6df4c225c#egg=pytorch_sphinx_theme2
+
+# Tutorial dependencies
+tqdm==4.66.1
+numpy==1.24.4
+matplotlib
+librosa
+torch==2.8
+torchvision
+torchdata
+networkx
+PyHamcrest
+bs4
+awscliv2==2.1.1
+flask
+spacy==3.4.1
+ray[tune]==2.7.2
+tensorboard
+jinja2==3.1.3
+pytorch-lightning
+torchx
+torchrl==0.9.2
+tensordict==0.9.1
+# For ax_multiobjective_nas_tutorial.py
+ax-platform>=0.4.0,<0.5.0
+nbformat>=5.9.2
+datasets
+transformers
+onnx
+onnxscript>=0.2.2
+onnxruntime
+evaluate
+accelerate>=0.20.1
+
+importlib-metadata==6.8.0
+
+ipython
+
+sphinxcontrib.katex
+# to run examples
+boto3
+pandas
+requests
+scikit-image
+scipy==1.11.1
+numba==0.57.1
+pillow==10.2.0
+wget
+gym==0.26.2
+gym-super-mario-bros==7.4.0
+pyopengl
+gymnasium[mujoco]==0.27.0
+timm
+pygame==2.6.0
+pycocotools
+semilearn==0.3.2
+torchao==0.10.0
+segment_anything==1.0
+torchrec==1.2.0; platform_system == "Linux"
+fbgemm-gpu==1.2.0; platform_system == "Linux"
diff --git a/.circleci/config.yml b/.circleci/config.yml
deleted file mode 100644
index a84b1eef2e8..00000000000
--- a/.circleci/config.yml
+++ /dev/null
@@ -1,286 +0,0 @@
-install_official_git_client: &install_official_git_client
-  name: Install Official Git Client
-  no_output_timeout: "1h"
-  command: |
-    set -e
-    sudo apt-get -qq update
-    sudo apt-get -qq install openssh-client git
-
-# This system setup script is meant to run before the CI-related scripts, e.g.,
-# installing Git client, checking out code, setting up CI env, and
-# building/testing.
-setup_linux_system_environment: &setup_linux_system_environment
-  name: Set Up System Environment
-  no_output_timeout: "1h"
-  command: |
-    set -ex
-
-    # Set up CircleCI GPG keys for apt, if needed
-    curl -L https://packagecloud.io/circleci/trusty/gpgkey | sudo apt-key add -
-
-    # Stop background apt updates.  Hypothetically, the kill should not
-    # be necessary, because stop is supposed to send a kill signal to
-    # the process, but we've added it for good luck.  Also
-    # hypothetically, it's supposed to be unnecessary to wait for
-    # the process to block.  We also have that line for good luck.
-    # If you like, try deleting them and seeing if it works.
-    sudo systemctl stop apt-daily.service || true
-    sudo systemctl kill --kill-who=all apt-daily.service || true
-
-    sudo systemctl stop unattended-upgrades.service || true
-    sudo systemctl kill --kill-who=all unattended-upgrades.service || true
-
-    # wait until `apt-get update` has been killed
-    while systemctl is-active --quiet apt-daily.service
-    do
-      sleep 1;
-    done
-    while systemctl is-active --quiet unattended-upgrades.service
-    do
-      sleep 1;
-    done
-
-    # See if we actually were successful
-    systemctl list-units --all | cat
-
-    sudo apt-get purge -y unattended-upgrades
-
-    cat /etc/apt/sources.list
-
-    ps auxfww | grep [a]pt
-    ps auxfww | grep dpkg
-
-pytorch_tutorial_build_defaults: &pytorch_tutorial_build_defaults
-  machine:
-    image: ubuntu-1604:201903-01
-  steps:
-  - checkout
-  - run:
-      <<: *setup_linux_system_environment
-  - run:
-      name: Set Up CI Environment
-      no_output_timeout: "1h"
-      command: |
-        set -e
-
-        # Set up NVIDIA docker repo
-        curl -L https://nvidia.github.io/nvidia-docker/gpgkey | sudo apt-key add -
-        echo "deb https://nvidia.github.io/libnvidia-container/ubuntu16.04/amd64 /" | sudo tee -a /etc/apt/sources.list.d/nvidia-docker.list
-        echo "deb https://nvidia.github.io/nvidia-container-runtime/ubuntu16.04/amd64 /" | sudo tee -a /etc/apt/sources.list.d/nvidia-docker.list
-        echo "deb https://nvidia.github.io/nvidia-docker/ubuntu16.04/amd64 /" | sudo tee -a /etc/apt/sources.list.d/nvidia-docker.list
-
-        sudo apt-get -y update
-        sudo apt-get -y remove linux-image-generic linux-headers-generic linux-generic docker-ce
-        # WARNING: Docker version is hardcoded here; you must update the
-        # version number below for docker-ce and nvidia-docker2 to get newer
-        # versions of Docker.  We hardcode these numbers because we kept
-        # getting broken CI when Docker would update their docker version,
-        # and nvidia-docker2 would be out of date for a day until they
-        # released a newer version of their package.
-        #
-        # How to figure out what the correct versions of these packages are?
-        # My preferred method is to start a Docker instance of the correct
-        # Ubuntu version (e.g., docker run -it ubuntu:16.04) and then ask
-        # apt what the packages you need are.  Note that the CircleCI image
-        # comes with Docker.
-        sudo apt-get -y install \
-          linux-headers-$(uname -r) \
-          linux-image-generic \
-          moreutils \
-          docker-ce=5:18.09.4~3-0~ubuntu-xenial \
-          nvidia-container-runtime=2.0.0+docker18.09.4-1 \
-          nvidia-docker2=2.0.3+docker18.09.4-1 \
-          expect-dev
-
-        sudo pkill -SIGHUP dockerd
-
-        sudo pip -q install awscli==1.16.35
-
-        if [ -n "${CUDA_VERSION}" ]; then
-          DRIVER_FN="NVIDIA-Linux-x86_64-410.104.run"
-          wget "https://s3.amazonaws.com/ossci-linux/nvidia_driver/$DRIVER_FN"
-          sudo /bin/bash "$DRIVER_FN" -s --no-drm || (sudo cat /var/log/nvidia-installer.log && false)
-          nvidia-smi
-        fi
-
-        # This IAM user only allows read-write access to ECR
-        export AWS_ACCESS_KEY_ID=${CIRCLECI_AWS_ACCESS_KEY_FOR_ECR_READ_ONLY}
-        export AWS_SECRET_ACCESS_KEY=${CIRCLECI_AWS_SECRET_KEY_FOR_ECR_READ_ONLY}
-        eval $(aws ecr get-login --region us-east-1 --no-include-email)
-  - run:
-      name: Build
-      no_output_timeout: "20h"
-      command: |
-        set -e
-
-        export pyTorchDockerImageTag=291
-        echo "PyTorchDockerImageTag: "${pyTorchDockerImageTag}
-
-        cat >/home/circleci/project/ci_build_script.sh <<EOL
-        # =================== The following code will be executed inside Docker container ===================
-        set -ex
-
-        .jenkins/build.sh
-        # =================== The above code will be executed inside Docker container ===================
-        EOL
-        chmod +x /home/circleci/project/ci_build_script.sh
-
-        export DOCKER_IMAGE=${DOCKER_IMAGE}:${pyTorchDockerImageTag}
-        echo "DOCKER_IMAGE: "${DOCKER_IMAGE}
-        docker pull ${DOCKER_IMAGE} >/dev/null
-        if [ -n "${CUDA_VERSION}" ]; then
-          export id=$(docker run --runtime=nvidia -t -d -w /var/lib/jenkins ${DOCKER_IMAGE})
-        else
-          export id=$(docker run -t -d -w /var/lib/jenkins ${DOCKER_IMAGE})
-        fi
-
-        echo "declare -x JOB_BASE_NAME=${CIRCLE_JOB}" > /home/circleci/project/env
-        echo "declare -x COMMIT_ID=${CIRCLE_SHA1}" >> /home/circleci/project/env
-        echo "declare -x COMMIT_SOURCE=${CIRCLE_BRANCH}" >> /home/circleci/project/env
-        # DANGER! DO NOT REMOVE THE `set +x` SETTING HERE!
-        set +x
-        if [[ "$CIRCLE_BRANCH" == master ]]; then
-          if [ -z "${CIRCLECI_AWS_ACCESS_KEY_FOR_PYTORCH_TUTORIAL_BUILD_MASTER_S3_BUCKET}" ]; then exit 1; fi
-          if [ -z "${CIRCLECI_AWS_SECRET_KEY_FOR_PYTORCH_TUTORIAL_BUILD_MASTER_S3_BUCKET}" ]; then exit 1; fi
-          if [ -z "${GITHUB_PYTORCHBOT_USERNAME}" ]; then exit 1; fi
-          if [ -z "${GITHUB_PYTORCHBOT_TOKEN}" ]; then exit 1; fi
-
-          echo "declare -x AWS_ACCESS_KEY_ID=${CIRCLECI_AWS_ACCESS_KEY_FOR_PYTORCH_TUTORIAL_BUILD_MASTER_S3_BUCKET}" >> /home/circleci/project/env
-          echo "declare -x AWS_SECRET_ACCESS_KEY=${CIRCLECI_AWS_SECRET_KEY_FOR_PYTORCH_TUTORIAL_BUILD_MASTER_S3_BUCKET}" >> /home/circleci/project/env
-          echo "declare -x GITHUB_PYTORCHBOT_USERNAME=${GITHUB_PYTORCHBOT_USERNAME}" >> /home/circleci/project/env
-          echo "declare -x GITHUB_PYTORCHBOT_TOKEN=${GITHUB_PYTORCHBOT_TOKEN}" >> /home/circleci/project/env
-        else
-          echo "declare -x AWS_ACCESS_KEY_ID=${CIRCLECI_AWS_ACCESS_KEY_FOR_PYTORCH_TUTORIAL_BUILD_PR_S3_BUCKET}" >> /home/circleci/project/env
-          echo "declare -x AWS_SECRET_ACCESS_KEY=${CIRCLECI_AWS_SECRET_KEY_FOR_PYTORCH_TUTORIAL_BUILD_PR_S3_BUCKET}" >> /home/circleci/project/env
-        fi
-        set -x
-
-        docker cp /home/circleci/project/. "$id:/var/lib/jenkins/workspace"
-
-        export COMMAND='((echo "source ./workspace/env" && echo "sudo chown -R jenkins workspace && cd workspace && ./ci_build_script.sh") | docker exec -u jenkins -i "$id" bash) 2>&1'
-        echo ${COMMAND} > ./command.sh && unbuffer bash ./command.sh | ts
-
-pytorch_tutorial_build_worker_defaults: &pytorch_tutorial_build_worker_defaults
-  environment:
-    DOCKER_IMAGE: "308535385114.dkr.ecr.us-east-1.amazonaws.com/pytorch/pytorch-linux-xenial-cuda9-cudnn7-py3"
-    CUDA_VERSION: "9"
-  resource_class: gpu.medium
-  <<: *pytorch_tutorial_build_defaults
-
-pytorch_tutorial_build_manager_defaults: &pytorch_tutorial_build_manager_defaults
-  environment:
-    DOCKER_IMAGE: "308535385114.dkr.ecr.us-east-1.amazonaws.com/pytorch/pytorch-linux-xenial-cuda9-cudnn7-py3"
-  resource_class: medium
-  <<: *pytorch_tutorial_build_defaults
-
-version: 2
-jobs:
-  pytorch_tutorial_build_worker_0:
-    <<: *pytorch_tutorial_build_worker_defaults
-
-  pytorch_tutorial_build_worker_1:
-    <<: *pytorch_tutorial_build_worker_defaults
-
-  pytorch_tutorial_build_worker_2:
-    <<: *pytorch_tutorial_build_worker_defaults
-
-  pytorch_tutorial_build_worker_3:
-    <<: *pytorch_tutorial_build_worker_defaults
-
-  pytorch_tutorial_build_worker_4:
-    <<: *pytorch_tutorial_build_worker_defaults
-
-  pytorch_tutorial_build_worker_5:
-    <<: *pytorch_tutorial_build_worker_defaults
-
-  pytorch_tutorial_build_worker_6:
-    <<: *pytorch_tutorial_build_worker_defaults
-
-  pytorch_tutorial_build_worker_7:
-    <<: *pytorch_tutorial_build_worker_defaults
-
-  pytorch_tutorial_build_worker_8:
-    <<: *pytorch_tutorial_build_worker_defaults
-
-  pytorch_tutorial_build_worker_9:
-    <<: *pytorch_tutorial_build_worker_defaults
-
-  pytorch_tutorial_build_worker_10:
-    <<: *pytorch_tutorial_build_worker_defaults
-
-  pytorch_tutorial_build_worker_11:
-    <<: *pytorch_tutorial_build_worker_defaults
-
-  pytorch_tutorial_build_worker_12:
-    <<: *pytorch_tutorial_build_worker_defaults
-
-  pytorch_tutorial_build_worker_13:
-    <<: *pytorch_tutorial_build_worker_defaults
-
-  pytorch_tutorial_build_worker_14:
-    <<: *pytorch_tutorial_build_worker_defaults
-
-  pytorch_tutorial_build_worker_15:
-    <<: *pytorch_tutorial_build_worker_defaults
-
-  pytorch_tutorial_build_worker_16:
-    <<: *pytorch_tutorial_build_worker_defaults
-
-  pytorch_tutorial_build_worker_17:
-    <<: *pytorch_tutorial_build_worker_defaults
-
-  pytorch_tutorial_build_worker_18:
-    <<: *pytorch_tutorial_build_worker_defaults
-
-  pytorch_tutorial_build_worker_19:
-    <<: *pytorch_tutorial_build_worker_defaults
-
-  pytorch_tutorial_build_manager:
-    <<: *pytorch_tutorial_build_manager_defaults
-
-workflows:
-  version: 2
-  build:
-    jobs:
-      - pytorch_tutorial_build_worker_0:
-          context: org-member
-      - pytorch_tutorial_build_worker_1:
-          context: org-member
-      - pytorch_tutorial_build_worker_2:
-          context: org-member
-      - pytorch_tutorial_build_worker_3:
-          context: org-member
-      - pytorch_tutorial_build_worker_4:
-          context: org-member
-      - pytorch_tutorial_build_worker_5:
-          context: org-member
-      - pytorch_tutorial_build_worker_6:
-          context: org-member
-      - pytorch_tutorial_build_worker_7:
-          context: org-member
-      - pytorch_tutorial_build_worker_8:
-          context: org-member
-      - pytorch_tutorial_build_worker_9:
-          context: org-member
-      - pytorch_tutorial_build_worker_10:
-          context: org-member
-      - pytorch_tutorial_build_worker_11:
-          context: org-member
-      - pytorch_tutorial_build_worker_12:
-          context: org-member
-      - pytorch_tutorial_build_worker_13:
-          context: org-member
-      - pytorch_tutorial_build_worker_14:
-          context: org-member
-      - pytorch_tutorial_build_worker_15:
-          context: org-member
-      - pytorch_tutorial_build_worker_16:
-          context: org-member
-      - pytorch_tutorial_build_worker_17:
-          context: org-member
-      - pytorch_tutorial_build_worker_18:
-          context: org-member
-      - pytorch_tutorial_build_worker_19:
-          context: org-member
-      - pytorch_tutorial_build_manager:
-          context: org-member
diff --git a/.devcontainer/Dockerfile b/.devcontainer/Dockerfile
new file mode 100644
index 00000000000..4928e536acf
--- /dev/null
+++ b/.devcontainer/Dockerfile
@@ -0,0 +1,8 @@
+FROM mcr.microsoft.com/vscode/devcontainers/python:3.8
+
+COPY requirements.txt /tmp/pip-tmp/
+
+RUN apt-get update && export DEBIAN_FRONTEND=noninteractive \
+    && apt-get install git gcc unzip make -y \
+    && pip3 install --disable-pip-version-check --no-cache-dir -r /tmp/pip-tmp/requirements.txt \
+    && rm -rf /tmp/pip-tmp
diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json
new file mode 100644
index 00000000000..86fe20483c5
--- /dev/null
+++ b/.devcontainer/devcontainer.json
@@ -0,0 +1,18 @@
+{
+  "name": "PyTorch Tutorials",
+  "build": {
+    "context": "..",
+    "dockerfile": "Dockerfile",
+    "args": {}
+  },
+  "settings": {
+    "terminal.integrated.shell.linux": "/bin/bash",
+    "workbench.startupEditor": "none",
+    "files.autoSave": "afterDelay",
+    "python.dataScience.enabled": true,
+    "python.dataScience.alwaysTrustNotebooks": true,
+    "python.insidersChannel": "weekly",
+    "python.showStartPage": false
+  },
+  "extensions": ["ms-python.python", "lextudio.restructuredtext"]
+}
diff --git a/.devcontainer/requirements.txt b/.devcontainer/requirements.txt
new file mode 100644
index 00000000000..2be1df895be
--- /dev/null
+++ b/.devcontainer/requirements.txt
@@ -0,0 +1,31 @@
+# Refer to ./jenkins/build.sh for tutorial build instructions
+
+sphinx==1.8.2
+sphinx-gallery==0.3.1
+tqdm
+numpy
+matplotlib
+torch
+torchvision
+torchtext
+torchaudio
+PyHamcrest
+bs4
+awscli==1.16.35
+flask
+spacy
+ray[tune]
+
+# PyTorch Theme
+-e git+https://github.com/pytorch/pytorch_sphinx_theme.git#egg=pytorch_sphinx_theme
+
+ipython
+
+# to run examples
+pandas
+scikit-image
+pillow==10.3.0
+wget
+
+# for codespaces env
+pylint
diff --git a/.github/ISSUE_TEMPLATE/bug-report.yml b/.github/ISSUE_TEMPLATE/bug-report.yml
new file mode 100644
index 00000000000..937417f4999
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/bug-report.yml
@@ -0,0 +1,60 @@
+name: 🐛 Bug Report
+description: Create a tutorial bug report
+title: "[BUG] - <title>"
+labels: [
+  "bug"
+]
+
+body:
+- type: markdown
+  attributes:
+    value: >
+      #### Before submitting a bug, please make sure the issue hasn't been already addressed by searching through [the existing and past issues](https://github.com/pytorch/tutorials/issues?q=is%3Aissue+sort%3Acreated-desc+).
+- type: textarea
+  attributes:
+    label: Add Link
+    description: |
+      **Add the link to the tutorial***
+    placeholder: |
+      Link to the tutorial on the website:
+  validations:
+    required: true
+- type: textarea
+  attributes:
+    label: Describe the bug
+    description: |
+      **Add the bug description**
+    placeholder: |
+      Provide a detailed description of the issue with code samples if relevant
+      ```python
+
+      # Sample code to reproduce the problem if relevant
+      ```
+
+      **Expected Result:** (Describe what you were expecting to see)
+
+
+      **Actual Result:** (Describe the result)
+
+      ```
+      The error message you got, with the full traceback.
+      ```
+
+  validations:
+    required: true
+- type: textarea
+  attributes:
+    label: Describe your environment
+    description: |
+      **Describe the environment you encountered the bug in:**
+    placeholder: |
+      * Platform (i.e macOS, Linux, Google Colab):
+      * CUDA (yes/no, version?):
+      * PyTorch version (run `python -c "import torch; print(torch.__version__)"`):
+
+  validations:
+    required: true
+- type: markdown
+  attributes:
+    value: >
+      Thanks for contributing 🎉!
diff --git a/.github/ISSUE_TEMPLATE/feature-request.yml b/.github/ISSUE_TEMPLATE/feature-request.yml
new file mode 100644
index 00000000000..c1c449c29fe
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/feature-request.yml
@@ -0,0 +1,37 @@
+name: 🚀 Feature request
+description: Submit a proposal for a new PyTorch tutorial or improvement of an existing tutorial
+title: "💡 [REQUEST] - <title>"
+labels: [
+  "feature"
+]
+
+body:
+- type: textarea
+  attributes:
+    label: 🚀 Describe the improvement or the new tutorial
+    description: |
+      **Describe the improvement**
+    placeholder: |
+      Explain why this improvement or new tutorial is important. For example, *"This tutorial will help users to better understand feature X of PyTorch."* If there is a tutorial that you propose to replace, add here. If this is related to another GitHub issue, add a link here.
+  validations:
+    required: true
+- type: textarea
+  attributes:
+    label: Existing tutorials on this topic
+    description: |
+      **Add a list of existing tutorials on the same topic.**
+    placeholder: |
+      List tutorials that already explain this functionality if exist. On pytorch.org or elsewhere.
+      * Link
+      * Link
+- type: textarea
+  attributes:
+    label: Additional context
+    description: |
+      **Add additional context**
+    placeholder: |
+      Add any other context or screenshots about the feature request.
+- type: markdown
+  attributes:
+    value: >
+      Thanks for contributing 🎉!
diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md
new file mode 100644
index 00000000000..8c3604b99fb
--- /dev/null
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@@ -0,0 +1,11 @@
+Fixes #ISSUE_NUMBER
+
+## Description
+<!--- Describe your changes in detail -->
+
+## Checklist
+<!--- Make sure to add `x` to all items in the following checklist: -->
+- [ ] The issue that is being fixed is referred in the description (see above "Fixes #ISSUE_NUMBER")
+- [ ] Only one issue is addressed in this pull request
+- [ ] Labels from the issue that this PR is fixing are added to this pull request
+- [ ] No unnecessary issues are included into this pull request.
diff --git a/.github/pytorch-probot.yml b/.github/pytorch-probot.yml
new file mode 100644
index 00000000000..6d0e8803efb
--- /dev/null
+++ b/.github/pytorch-probot.yml
@@ -0,0 +1 @@
+tracking_issue: 1896
diff --git a/.github/scripts/check_redirects.sh b/.github/scripts/check_redirects.sh
new file mode 100755
index 00000000000..6aa31819820
--- /dev/null
+++ b/.github/scripts/check_redirects.sh
@@ -0,0 +1,46 @@
+#!/bin/bash
+
+if [ "$CURRENT_BRANCH" == "$BASE_BRANCH" ]; then
+  echo "Running on $BASE_BRANCH branch. Skipping check."
+  exit 0
+fi
+
+
+# Get list of deleted or renamed files in this branch compared to base
+DELETED_FILES=$(git diff --name-status $BASE_BRANCH $CURRENT_BRANCH --diff-filter=DR | awk '{print $2}' | grep -E '\.(rst|py|md)$' | grep -v 'redirects.py')
+# Check if any deleted or renamed files were found
+if [ -z "$DELETED_FILES" ]; then
+  echo "No deleted or renamed files found. Skipping check."
+  exit 0
+fi
+
+echo "Deleted or renamed files:"
+echo "$DELETED_FILES"
+
+# Check if redirects.py has been updated
+REDIRECTS_UPDATED=$(git diff --name-status $BASE_BRANCH $CURRENT_BRANCH --diff-filter=AM | grep 'redirects.py' && echo "yes" || echo "no")
+
+if [ "$REDIRECTS_UPDATED" == "no" ]; then
+  echo "ERROR: Files were deleted or renamed but redirects.py was not updated. Please update .github/scripts/redirects.py to redirect these files."
+  exit 1
+fi
+
+# Check if each deleted file has a redirect entry
+MISSING_REDIRECTS=0
+for FILE in $DELETED_FILES; do
+  # Convert file path to URL path format (remove extension and adjust path)
+  REDIRECT_PATH=$(echo $FILE | sed -E 's/(.+)_source\/(.+)\.(py|rst|md)$/\1\/\2.html/')
+
+  # Check if this path exists in redirects.py as a key. We don't check for values.
+  if ! grep -q "\"$REDIRECT_PATH\":" redirects.py; then
+    echo "ERROR: Missing redirect for deleted file: $FILE (should have entry for \"$REDIRECT_PATH\")"
+    MISSING_REDIRECTS=1
+  fi
+done
+
+if [ $MISSING_REDIRECTS -eq 1 ]; then
+  echo "ERROR: Please add redirects for all deleted/renamed files to redirects.py"
+  exit 1
+fi
+
+echo "All deleted/renamed files have proper redirects. Check passed!"
diff --git a/.github/scripts/docathon-label-sync.py b/.github/scripts/docathon-label-sync.py
new file mode 100644
index 00000000000..7241e1370ce
--- /dev/null
+++ b/.github/scripts/docathon-label-sync.py
@@ -0,0 +1,46 @@
+import os
+from github import Github
+import sys
+import re
+
+def main():
+    token = os.environ.get('GITHUB_TOKEN')
+
+    repo_owner = "pytorch"
+    repo_name = "tutorials"
+    pull_request_number = int(sys.argv[1])
+
+    g = Github(token)
+    repo = g.get_repo(f'{repo_owner}/{repo_name}')
+    pull_request = repo.get_pull(pull_request_number)
+    pull_request_body = pull_request.body
+    # PR without description
+    if pull_request_body is None:
+        return
+
+    # get issue number from the PR body
+    if not re.search(r'#\d{1,5}', pull_request_body):
+        print("The pull request does not mention an issue.")
+        return
+    issue_number = int(re.findall(r'#(\d{1,5})', pull_request_body)[0])
+    issue = repo.get_issue(issue_number)
+    issue_labels = issue.labels
+    docathon_label_present = any(label.name == 'docathon-h1-2025' for label in issue_labels)
+
+    # if the issue has a docathon label, add all labels from the issue to the PR.
+    if not docathon_label_present:
+        print("The 'docathon-h1-2025' label is not present in the issue.")
+        return
+    pull_request_labels = pull_request.get_labels()
+    issue_label_names = [label.name for label in issue_labels]
+    labels_to_add = [label for label in issue_label_names if label not in pull_request_labels]
+    if not labels_to_add:
+        print("The pull request already has the same labels.")
+        return
+    pull_request.add_to_labels(*labels_to_add)
+    print("Labels added to the pull request!")
+
+
+
+if __name__  == "__main__":
+    main()
diff --git a/.github/workflows/MonthlyLinkCheck.yml b/.github/workflows/MonthlyLinkCheck.yml
new file mode 100644
index 00000000000..aaddcda926f
--- /dev/null
+++ b/.github/workflows/MonthlyLinkCheck.yml
@@ -0,0 +1,44 @@
+#Runs once a month and checks links in the repo to ensure they are valid
+#If action fails, it creates an issue with the failing links and an "incorrect link" label
+#If link is valid but failing, it can be added to the .lycheeignore file
+#Action can also be run manually as needed.
+
+
+name: Monthly Link Check
+on:
+  schedule:
+    - cron: '0 0 1 * *'  # Runs at midnight on the first day of every month
+  workflow_dispatch:  # Allows manual triggering of the workflow
+jobs:
+  linkChecker:
+    runs-on: ubuntu-latest
+    permissions:
+      issues: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+      - name: Check Links
+        id: lychee
+        uses: lycheeverse/lychee-action@v2
+        with:
+          args: --accept=200,403,429 --base . --verbose --no-progress './**/*.md' './**/*.html' './**/*.rst'
+          token: ${{ secrets.CUSTOM_TOKEN }}
+          fail: true
+
+      - name: Create Issue From File
+        if: failure() && (github.event_name == 'schedule' || github.event_name == 'workflow_dispatch')
+        uses: peter-evans/create-issue-from-file@v5
+        with:
+          title: Broken links detected in docs 🔗
+          content-filepath: ./lychee/out.md
+          labels: 'incorrect link'
+          #token: ${{ secrets.CUSTOM_TOKEN }}
+
+
+      - 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/.github/workflows/StalePRs.yml b/.github/workflows/StalePRs.yml
new file mode 100644
index 00000000000..e7393948518
--- /dev/null
+++ b/.github/workflows/StalePRs.yml
@@ -0,0 +1,156 @@
+# A workflow copied from the pytorch/pytorch repo stale PRs that implements similar logic to actions/stale.
+#
+# Compared to actions/stale, it is implemented to make API requests proportional
+# to the number of stale PRs, not the total number of issues in the repo. This
+# is because PyTorch has a lot of issues/PRs, so the actions/stale runs into
+# rate limits way too quickly.
+#
+# The behavior is:
+# - If a PR is not labeled stale, after 60 days inactivity label the PR as stale and comment about it.
+# - If a PR is labeled stale, after 30 days inactivity close the PR.
+# - `high priority` and `no-stale` PRs are exempt.
+
+name: Close stale pull requests
+
+on:
+  schedule:
+    # Run at midnight UTC.
+    - cron: '0 0 * * *'
+  workflow_dispatch:
+
+jobs:
+  stale:
+    if: ${{ github.repository == 'pytorch/tutorials' }}
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      pull-requests: write
+
+    steps:
+      - uses: actions/github-script@v6
+        with:
+          script: |
+            // Do some dumb retries on requests.
+            const retries = 7;
+            const baseBackoff = 100;
+            const sleep = timeout => new Promise(resolve => setTimeout(resolve, timeout));
+            github.hook.wrap('request', async (request, options) => {
+              for (let attempt = 1; attempt <= retries; attempt++) {
+                try {
+                  return await request(options);
+                } catch (err) {
+                  if (attempt < retries) {
+                    core.warning(`Request getting retried. Attempt: ${attempt}`);
+                    await sleep(baseBackoff * Math.pow(2, attempt));
+                    continue;
+                  }
+                  throw err;
+                }
+              }
+            });
+
+            const MAX_API_REQUESTS = 100;
+
+            // If a PRs not labeled stale, label them stale after no update for 60 days.
+            const STALE_LABEL_THRESHOLD_MS = 1000 * 60 * 60 * 24 * 60;
+            // For PRs already labeled stale, close after not update for 30 days.
+            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>" +
+              "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>";
+
+            let numAPIRequests = 0;
+            let numProcessed = 0;
+
+            async function processPull(pull) {
+              core.info(`[${pull.number}] URL: ${pull.html_url}`);
+              numProcessed += 1;
+              const labels = pull.labels.map((label) => label.name);
+
+              // Skip if certain labels are present.
+              if (labels.includes("no-stale") || labels.includes("high priority")) {
+                core.info(`[${pull.number}] Skipping because PR has an exempting label.`);
+                return false;
+              }
+
+              // Check if the PR is stale, according to our configured thresholds.
+              let staleThresholdMillis;
+              if (labels.includes("stale")) {
+                core.info(`[${pull.number}] PR is labeled stale, checking whether we should close it.`);
+                staleThresholdMillis = STALE_CLOSE_THRESHOLD_MS;
+              } else {
+                core.info(`[${pull.number}] Checking whether to label PR as stale.`);
+                staleThresholdMillis = STALE_LABEL_THRESHOLD_MS;
+              }
+
+              const millisSinceLastUpdated =
+                new Date().getTime() - new Date(pull.updated_at).getTime();
+
+              if (millisSinceLastUpdated < staleThresholdMillis) {
+                core.info(`[${pull.number}] Skipping because PR was updated recently`);
+                return false;
+              }
+
+              // At this point, we know we should do something.
+              // For PRs already labeled stale, close them.
+              if (labels.includes("stale")) {
+                core.info(`[${pull.number}] Closing PR.`);
+                numAPIRequests += 1;
+                await github.rest.issues.update({
+                  owner: "pytorch",
+                  repo: "tutorials",
+                  issue_number: pull.number,
+                  state: "closed",
+                });
+              } else {
+                // For PRs not labeled stale, label them stale.
+                core.info(`[${pull.number}] Labeling PR as stale.`);
+
+                numAPIRequests += 1;
+                await github.rest.issues.createComment({
+                  owner: "pytorch",
+                  repo: "tutorials",
+                  issue_number: pull.number,
+                  body: STALE_MESSAGE,
+                });
+
+                numAPIRequests += 1;
+                await github.rest.issues.addLabels({
+                  owner: "pytorch",
+                  repo: "tutorials",
+                  issue_number: pull.number,
+                  labels: ["stale"],
+                });
+              }
+            }
+
+            for await (const response of github.paginate.iterator(
+              github.rest.pulls.list,
+              {
+                owner: "pytorch",
+                repo: "tutorials",
+                state: "open",
+                sort: "created",
+                direction: "asc",
+                per_page: 100,
+              }
+            )) {
+              numAPIRequests += 1;
+              const pulls = response.data;
+              // Awaiting in a loop is intentional here. We want to serialize execution so
+              // that log groups are printed correctl
+              for (const pull of pulls) {
+                if (numAPIRequests > MAX_API_REQUESTS) {
+                  core.warning("Max API requests exceeded, exiting.");
+                  process.exit(0);
+                }
+                await core.group(`Processing PR #${pull.number}`, async () => {
+                  await processPull(pull);
+                });
+              }
+            }
+            core.info(`Processed ${numProcessed} PRs total.`);
diff --git a/.github/workflows/build-tutorials.yml b/.github/workflows/build-tutorials.yml
new file mode 100644
index 00000000000..94cfd5843a0
--- /dev/null
+++ b/.github/workflows/build-tutorials.yml
@@ -0,0 +1,183 @@
+name: Build tutorials
+
+on:
+  pull_request:
+  push:
+    branches:
+      - main
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.sha }}-${{ github.event_name == 'workflow_dispatch' }}-${{ github.event_name == 'schedule' }}
+  cancel-in-progress: true
+
+jobs:
+  worker:
+    name: pytorch_tutorial_build_worker
+    strategy:
+      matrix:
+        include:
+          - { shard: 1, num_shards: 15, runner: "linux.g5.12xlarge.nvidia.gpu" }
+          - { shard: 2, num_shards: 15, runner: "linux.g5.4xlarge.nvidia.gpu" }
+          - { shard: 3, num_shards: 15, runner: "linux.g5.4xlarge.nvidia.gpu" }
+          - { shard: 4, num_shards: 15, runner: "linux.g5.4xlarge.nvidia.gpu" }
+          - { shard: 5, num_shards: 15, runner: "linux.g5.4xlarge.nvidia.gpu" }
+          - { shard: 6, num_shards: 15, runner: "linux.g5.4xlarge.nvidia.gpu" }
+          - { shard: 7, num_shards: 15, runner: "linux.g5.4xlarge.nvidia.gpu" }
+          - { shard: 8, num_shards: 15, runner: "linux.g5.4xlarge.nvidia.gpu" }
+          - { shard: 9, num_shards: 15, runner: "linux.g5.4xlarge.nvidia.gpu" }
+          - { shard: 10, num_shards: 15, runner: "linux.g5.4xlarge.nvidia.gpu" }
+          - { shard: 11, num_shards: 15, runner: "linux.g5.4xlarge.nvidia.gpu" }
+          - { shard: 12, num_shards: 15, runner: "linux.g5.4xlarge.nvidia.gpu" }
+          - { shard: 13, num_shards: 15, runner: "linux.g5.4xlarge.nvidia.gpu" }
+          - { shard: 14, num_shards: 15, runner: "linux.g5.4xlarge.nvidia.gpu" }
+          - { shard: 15, num_shards: 15, runner: "linux.g5.4xlarge.nvidia.gpu" }
+      fail-fast: false
+    runs-on: ${{ matrix.runner }}
+    steps:
+      - name: Setup SSH (Click me for login details)
+        uses: pytorch/test-infra/.github/actions/setup-ssh@main
+        with:
+          github-secret: ${{ secrets.GITHUB_TOKEN }}
+          instructions: |
+            All testing is done inside the container, to start an interactive session run:
+              docker exec -it $(docker container ps --format '{{.ID}}') bash
+
+      - name: Checkout Tutorials
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      - name: Setup Linux
+        uses: pytorch/pytorch/.github/actions/setup-linux@main
+
+      - name: Install nvidia driver, nvidia-docker runtime, set GPU_FLAG
+        uses: pytorch/test-infra/.github/actions/setup-nvidia@main
+
+      - name: Calculate/build docker image
+        id: calculate-docker-image
+        uses: pytorch/test-infra/.github/actions/calculate-docker-image@main
+        with:
+          docker-image-name: tutorials
+
+      - name: Pull docker image
+        uses: pytorch/test-infra/.github/actions/pull-docker-image@main
+        with:
+          docker-image: ${{ steps.calculate-docker-image.outputs.docker-image }}
+
+      - name: Build
+        shell: bash
+        env:
+          DOCKER_IMAGE: ${{ steps.calculate-docker-image.outputs.docker-image }}
+          NUM_WORKERS: ${{ matrix.num_shards }}
+          WORKER_ID: ${{ matrix.shard }}
+          COMMIT_ID: ${{ github.sha }}
+          JOB_TYPE: worker
+          COMMIT_SOURCE: ${{ github.ref }}
+        run: |
+          set -ex
+
+          chmod +x ".jenkins/build.sh"
+
+          container_name=$(docker run \
+            ${GPU_FLAG:-} \
+            -e WORKER_ID \
+            -e NUM_WORKERS \
+            -e COMMIT_ID \
+            -e JOB_TYPE \
+            -e COMMIT_SOURCE \
+            --env-file="/tmp/github_env_${GITHUB_RUN_ID}" \
+            --tty \
+            --detach \
+            --shm-size=2gb \
+            --name="${container_name}" \
+            -v "${GITHUB_WORKSPACE}:/var/lib/workspace" \
+            -w /var/lib/workspace \
+            "${DOCKER_IMAGE}"
+          )
+
+          docker exec -u ci-user -t "${container_name}" sh -c ".jenkins/build.sh"
+
+      - name: Teardown Linux
+        uses: pytorch/test-infra/.github/actions/teardown-linux@main
+        if: always()
+
+  manager:
+    name: pytorch_tutorial_build_manager
+    needs: worker
+    runs-on: [self-hosted, linux.2xlarge]
+    environment: ${{ github.ref == 'refs/heads/main' && 'pytorchbot-env' || '' }}
+    steps:
+      - name: Setup SSH (Click me for login details)
+        uses: pytorch/test-infra/.github/actions/setup-ssh@main
+        with:
+          github-secret: ${{ secrets.GITHUB_TOKEN }}
+          instructions: |
+            All testing is done inside the container, to start an interactive session run:
+              docker exec -it $(docker container ps --format '{{.ID}}') bash
+
+      - name: Checkout Tutorials
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      - name: Setup Linux
+        uses: pytorch/pytorch/.github/actions/setup-linux@main
+
+      - name: Calculate/build docker image
+        id: calculate-docker-image
+        uses: pytorch/test-infra/.github/actions/calculate-docker-image@main
+        with:
+          docker-image-name: tutorials
+
+      - name: Pull docker image
+        uses: pytorch/test-infra/.github/actions/pull-docker-image@main
+        with:
+          docker-image: ${{ steps.calculate-docker-image.outputs.docker-image }}
+
+      - name: Build
+        shell: bash
+        env:
+          DOCKER_IMAGE: ${{ steps.calculate-docker-image.outputs.docker-image }}
+          NUM_WORKERS: 15
+          WORKER_ID: ${{ matrix.shard }}
+          COMMIT_ID: ${{ github.sha }}
+          JOB_TYPE: manager
+          COMMIT_SOURCE: ${{ github.ref }}
+          GITHUB_PYTORCHBOT_TOKEN: ${{ secrets.PYTORCHBOT_TOKEN }}
+        run: |
+          set -ex
+
+          chmod +x ".jenkins/build.sh"
+
+          container_name=$(docker run \
+            ${GPU_FLAG:-} \
+            -e WORKER_ID \
+            -e NUM_WORKERS \
+            -e COMMIT_ID \
+            -e JOB_TYPE \
+            -e COMMIT_SOURCE \
+            -e GITHUB_PYTORCHBOT_TOKEN \
+            --env-file="/tmp/github_env_${GITHUB_RUN_ID}" \
+            --tty \
+            --detach \
+            --name="${container_name}" \
+            -v "${GITHUB_WORKSPACE}:/var/lib/workspace" \
+            -w /var/lib/workspace \
+            "${DOCKER_IMAGE}"
+          )
+
+          docker exec -u ci-user -t "${container_name}" sh -c ".jenkins/build.sh"
+
+      - name: Upload docs preview
+        uses: seemethere/upload-artifact-s3@v5
+        if: ${{ github.event_name == 'pull_request' }}
+        with:
+          retention-days: 14
+          s3-bucket: doc-previews
+          if-no-files-found: error
+          path: docs
+          s3-prefix: pytorch/tutorials/${{ github.event.pull_request.number }}
+
+      - name: Teardown Linux
+        uses: pytorch/test-infra/.github/actions/teardown-linux@main
+        if: always()
diff --git a/.github/workflows/check-redirects.yml b/.github/workflows/check-redirects.yml
new file mode 100644
index 00000000000..380e3989bf4
--- /dev/null
+++ b/.github/workflows/check-redirects.yml
@@ -0,0 +1,25 @@
+name: Check Redirects for Deleted or Renamed Files
+
+on:
+  pull_request:
+    paths:
+     - '*/**/*.rst'
+     - '*/**/*.py'
+     - '*/**/*.md'
+
+jobs:
+  check-redirects:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Run redirect check script
+        run: |
+            chmod +x ./.github/scripts/check_redirects.sh
+            ./.github/scripts/check_redirects.sh
+        env:
+          BASE_BRANCH: ${{ github.base_ref }}
+          CURRENT_BRANCH: ${{ github.head_ref }}
diff --git a/.github/workflows/docathon-assign.yml b/.github/workflows/docathon-assign.yml
new file mode 100644
index 00000000000..8eef2b2fc88
--- /dev/null
+++ b/.github/workflows/docathon-assign.yml
@@ -0,0 +1,60 @@
+name: Assign User on Comment
+
+on:
+  workflow_dispatch:
+  issue_comment:
+    types: [created]
+
+jobs:
+  assign:
+    runs-on: ubuntu-latest
+    permissions:
+      issues: write
+    steps:
+      - name: Check for "/assigntome" in comment
+        uses: actions/github-script@v6
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          script: |
+            const issueComment = context.payload.comment.body;
+            const assignRegex = /\/assigntome/i;
+            if (assignRegex.test(issueComment)) {
+              const assignee = context.payload.comment.user.login;
+              const issueNumber = context.payload.issue.number;
+              try {
+                const { data: issue } = await github.rest.issues.get({
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  issue_number: issueNumber
+                });
+              const hasLabel = issue.labels.some(label => label.name === 'docathon-h1-2025');
+              if (hasLabel) {
+                if (issue.assignee !== null) {
+                  await github.rest.issues.createComment({
+                    owner: context.repo.owner,
+                    repo: context.repo.repo,
+                    issue_number: issueNumber,
+                    body: "The issue is already assigned. Please pick an opened and unnasigned issue with the [docathon-h1-2025 label](https://github.com/pytorch/pytorch/issues?q=is%3Aopen+is%3Aissue+label%3Adocathon-h1-2025)."
+                  });
+                } else {
+                  await github.rest.issues.addAssignees({
+                    owner: context.repo.owner,
+                    repo: context.repo.repo,
+                    issue_number: issueNumber,
+                    assignees: [assignee]
+                  });
+                }
+              } else {
+                const commmentMessage = "This issue does not have the correct label. Please pick an opened and unnasigned issue with the [docathon-h1-2025 label](https://github.com/pytorch/pytorch/issues?q=is%3Aopen+is%3Aissue+label%3Adocathon-h1-2025)."
+                await github.rest.issues.createComment({
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  issue_number: issueNumber,
+                  body: commmentMessage
+                });
+               }
+              } catch (error) {
+                console.error(error);
+              }
+            }
diff --git a/.github/workflows/docathon-label-sync.yml b/.github/workflows/docathon-label-sync.yml
new file mode 100644
index 00000000000..1b33bebaac2
--- /dev/null
+++ b/.github/workflows/docathon-label-sync.yml
@@ -0,0 +1,29 @@
+name: Docathon Labels Sync
+
+on:
+  pull_request_target:
+    types: [opened, synchronize, edited]
+
+jobs:
+  check-labels:
+    runs-on: ubuntu-latest
+    permissions:
+      issues: write
+      pull-requests: write
+    steps:
+      - name: Check if PR mentions an issue and get labels
+        uses: actions/checkout@v2
+        with:
+          fetch-depth: 1
+      - name: Set up Python
+        uses: actions/setup-python@v2
+        with:
+          python-version: 3.x
+      - name: Install dependencies
+        run: |
+          pip install requests
+          pip install PyGithub
+      - name: Run Python script
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: python ./.github/scripts/docathon-label-sync.py ${{ github.event.pull_request.number }}
diff --git a/.github/workflows/docker-build.yml b/.github/workflows/docker-build.yml
new file mode 100644
index 00000000000..6d75d1fc929
--- /dev/null
+++ b/.github/workflows/docker-build.yml
@@ -0,0 +1,59 @@
+name: Docker Build
+
+on:
+  workflow_dispatch:
+  pull_request:
+    paths:
+      - .ci/docker/**
+      - .github/workflows/docker-builds.yml
+  push:
+    branches:
+      - main
+    paths:
+      - .ci/docker/**
+      - .github/workflows/docker-builds.yml
+
+jobs:
+  docker-build:
+    runs-on: [self-hosted, linux.2xlarge]
+    timeout-minutes: 240
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - docker-image-name: tutorials
+    env:
+      DOCKER_IMAGE: 308535385114.dkr.ecr.us-east-1.amazonaws.com/tutorials/${{ matrix.docker-image-name }}
+    steps:
+      - name: Clean workspace
+        shell: bash
+        run: |
+          echo "${GITHUB_WORKSPACE}"
+          sudo rm -rf "${GITHUB_WORKSPACE}"
+          mkdir "${GITHUB_WORKSPACE}"
+
+      - name: Setup SSH (Click me for login details)
+        uses: pytorch/test-infra/.github/actions/setup-ssh@main
+        with:
+          github-secret: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Checkout
+        uses: actions/checkout@v3
+
+      - name: Setup Linux
+        uses: pytorch/test-infra/.github/actions/setup-linux@main
+
+      - name: Build docker image
+        id: build-docker-image
+        uses: pytorch/test-infra/.github/actions/calculate-docker-image@main
+        with:
+          docker-image-name: ${{ matrix.docker-image-name }}
+          push: true
+
+      - name: Teardown Linux
+        uses: pytorch/test-infra/.github/actions/teardown-linux@main
+        if: always()
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.sha }}-${{ github.event_name == 'workflow_dispatch' }}
+  cancel-in-progress: true
diff --git a/.github/workflows/link_checkPR.yml b/.github/workflows/link_checkPR.yml
new file mode 100644
index 00000000000..830e470c1c0
--- /dev/null
+++ b/.github/workflows/link_checkPR.yml
@@ -0,0 +1,57 @@
+#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@d6e91a2266cdb9d62096cebf1e8546899c6aa18f # v45.0.6
+
+      - 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."
+
+      # Per tj-actions, a delete file is not a changed file so this ensures lint checking does not occur on deleted files
+      - name: No Files to Check
+        if: steps.skip-label.outputs.result == 'false' && steps.changed-files.outputs.any_changed == 'true'
+        run: echo "No relevant files were changed in this PR that require link checking."
+
+      - 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/.github/workflows/lintrunner.yml b/.github/workflows/lintrunner.yml
new file mode 100644
index 00000000000..e1a6889eb28
--- /dev/null
+++ b/.github/workflows/lintrunner.yml
@@ -0,0 +1,38 @@
+name: Lintrunner
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.sha }}-${{ github.event_name == 'workflow_dispatch' }}
+  cancel-in-progress: true
+
+jobs:
+  lintrunner:
+    name: lintrunner
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout tutorials
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+
+      - name: Setup Python
+        uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5.6.0
+        with:
+          python-version: '3.12'
+
+      - name: Install Lintrunner
+        run: |
+          pip install lintrunner==0.12.5
+          lintrunner init
+
+      - name: Run lintrunner on all files - Linux
+        run: |
+          set +e
+          if ! lintrunner -v --force-color --all-files --tee-json=lint.json; then
+              echo ""
+              echo -e "\e[1m\e[36mYou can reproduce these results locally by using \`lintrunner -m main\`.\e[0m"
+              exit 1
+          fi
diff --git a/.github/workflows/spelling.yml b/.github/workflows/spelling.yml
new file mode 100644
index 00000000000..e1cba836c96
--- /dev/null
+++ b/.github/workflows/spelling.yml
@@ -0,0 +1,153 @@
+name: Check spelling
+
+on:
+  pull_request:
+  push:
+    branches:
+      - main
+
+jobs:
+  pyspelling:
+    runs-on: ubuntu-20.04
+    steps:
+      - name: Check for skip label and get changed files
+        id: check-files
+        uses: actions/github-script@v6
+        with:
+          script: |
+            let skipCheck = false;
+            let changedFiles = [];
+
+            if (context.eventName === 'pull_request') {
+              // Check for skip label
+              const { data: labels } = await github.rest.issues.listLabelsOnIssue({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: context.issue.number
+              });
+              skipCheck = labels.some(label => label.name === 'skip-spell-check');
+
+              if (!skipCheck) {
+                // Get changed files in PR
+                const { data: files } = await github.rest.pulls.listFiles({
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  pull_number: context.issue.number
+                });
+
+                changedFiles = files
+                  .filter(file => file.filename.match(/\.(py|rst|md)$/))
+                  .map(file => file.filename);
+              }
+            } else {
+              // For push events, we'll still need to use git diff
+              // We'll handle this after checkout
+            }
+
+            core.setOutput('skip', skipCheck.toString());
+            core.setOutput('files', changedFiles.join('\n'));
+            core.setOutput('is-pr', (context.eventName === 'pull_request').toString());
+
+      - uses: actions/checkout@v4
+        if: steps.check-files.outputs.skip != 'true'
+        with:
+          fetch-depth: 0
+
+      - name: Get changed files for push event
+        if: |
+          steps.check-files.outputs.skip != 'true' &&
+          steps.check-files.outputs.is-pr != 'true'
+        id: push-files
+        run: |
+          CHANGED_FILES=$(git diff --name-only HEAD^..HEAD -- '*.py' '*.rst' '*.md')
+          echo "files<<EOF" >> $GITHUB_OUTPUT
+          echo "$CHANGED_FILES" >> $GITHUB_OUTPUT
+          echo "EOF" >> $GITHUB_OUTPUT
+
+      - name: Check if relevant files changed
+        if: steps.check-files.outputs.skip != 'true'
+        id: check
+        run: |
+          if [ "${{ steps.check-files.outputs.is-pr }}" == "true" ]; then
+            FILES="${{ steps.check-files.outputs.files }}"
+          else
+            FILES="${{ steps.push-files.outputs.files }}"
+          fi
+
+          if [ -z "$FILES" ]; then
+            echo "skip=true" >> $GITHUB_OUTPUT
+            echo "No relevant files changed (*.py, *.rst, *.md), skipping spell check"
+          else
+            echo "skip=false" >> $GITHUB_OUTPUT
+            echo "Found changed files to check:"
+            echo "$FILES"
+          fi
+
+      - uses: actions/setup-python@v4
+        if: |
+          steps.check-files.outputs.skip != 'true' &&
+          steps.check.outputs.skip != 'true'
+        with:
+          python-version: '3.9'
+          cache: 'pip'
+
+      - name: Install dependencies
+        if: |
+          steps.check-files.outputs.skip != 'true' &&
+          steps.check.outputs.skip != 'true'
+        run: |
+          pip install pyspelling
+          sudo apt-get install aspell aspell-en
+
+      - name: Run spell check on each file
+        id: spellcheck
+        if: |
+          steps.check-files.outputs.skip != 'true' &&
+          steps.check.outputs.skip != 'true'
+        run: |
+          if [ "${{ steps.check-files.outputs.is-pr }}" == "true" ]; then
+            mapfile -t FILES <<< "${{ steps.check-files.outputs.files }}"
+          else
+            mapfile -t FILES <<< "${{ steps.push-files.outputs.files }}"
+          fi
+
+          # Check each file individually
+          FINAL_EXIT_CODE=0
+          SPELLCHECK_LOG=""
+          for file in "${FILES[@]}"; do
+            if [ -n "$file" ]; then
+              echo "Checking spelling in $file"
+              python3 -c "import yaml; config = yaml.safe_load(open('.pyspelling.yml')); new_matrix = [matrix.copy() for matrix in config['matrix'] if (('python' in matrix['name'].lower() and '$file'.endswith('.py')) or ('rest' in matrix['name'].lower() and '$file'.endswith('.rst')) or ('markdown' in matrix['name'].lower() and '$file'.endswith('.md'))) and not matrix.update({'sources': ['$file']})]; config['matrix'] = new_matrix; yaml.dump(config, open('temp_config.yml', 'w'))"
+
+              if OUTPUT=$(pyspelling -c temp_config.yml 2>&1); then
+                echo "No spelling errors found in $file"
+              else
+                FINAL_EXIT_CODE=1
+                echo "Spelling errors found in $file:"
+                echo "$OUTPUT"
+                SPELLCHECK_LOG+="### $file\n$OUTPUT\n\n"
+              fi
+            fi
+          done
+
+          # Save the results to GITHUB_OUTPUT
+          echo "spell_failed=$FINAL_EXIT_CODE" >> $GITHUB_OUTPUT
+          echo "spell_log<<SPELLEOF" >> $GITHUB_OUTPUT
+          echo "$SPELLCHECK_LOG" >> $GITHUB_OUTPUT
+          echo "SPELLEOF" >> $GITHUB_OUTPUT
+
+          if [ $FINAL_EXIT_CODE -ne 0 ]; then
+            echo "Spell check failed! See above for details."
+            echo
+            echo "Here are a few tips:"
+            echo "- All PyTorch API objects must be in double backticks or use an intersphinx directive."
+            echo "  Example: ``torch.nn``, :func:"
+            echo "- Consult en-wordlist.txt for spellings of some of the words."
+            echo "  You can add a word to en-wordlist.txt if:"
+            echo "  1) It's a common abbreviation, like RNN."
+            echo "  2) It's a word widely accepted in the industry."
+            echo "- Please do not add words like 'dtype', 'torch.nn.Transformer' to pass spellcheck."
+            echo "  Instead wrap it in double backticks or use an intersphinx directive."
+            echo
+            exit 1
+          fi
diff --git a/.gitignore b/.gitignore
index 3fb316b581f..3f1f927ee33 100644
--- a/.gitignore
+++ b/.gitignore
@@ -3,17 +3,24 @@ beginner
 intermediate
 advanced
 pytorch_basics
+/recipes
+prototype
+/unstable
+sg_execution_times.rst
 
 #data things
 _data/
-beginner_source/hymenoptera_data
-beginner_source/blitz/data
-beginner_source/faces
-beginner_source/hybrid_frontend/data
-intermediate_source/data/
 advanced_source/images/
-*data.zip
-faces.zip
+advanced_source/data/
+beginner_source/.data/
+beginner_source/data/
+beginner_source/blitz/data/
+beginner_source/faces/
+beginner_source/hybrid_frontend/data/
+beginner_source/hymenoptera_data/
+intermediate_source/data/
+*.zip
+MNIST/
 
 #builds
 _build/
@@ -28,6 +35,7 @@ __pycache__/
 *.so
 
 # Distribution / packaging
+src/
 .Python
 env/
 build/
@@ -94,7 +102,7 @@ target/
 .python-version
 
 # celery beat schedule file
-celerybeat-schedule 
+celerybeat-schedule
 # dotenv
 .env
 
@@ -112,3 +120,15 @@ ENV/
 .DS_Store
 cleanup.sh
 *.swp
+
+# PyTorch things
+*.pt
+
+# VSCode
+*.vscode
+
+# pyspelling
+dictionary.dic
+
+# linters
+/.lintbin
diff --git a/.gitmodules b/.gitmodules
index 3a3c564c8fa..e69de29bb2d 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,3 +0,0 @@
-[submodule "src/pytorch-sphinx-theme"]
-	path = src/pytorch-sphinx-theme
-	url = https://github.com/pytorch/pytorch_sphinx_theme
diff --git a/.jenkins/build.sh b/.jenkins/build.sh
index eaed1d00057..0187f6ba84c 100755
--- a/.jenkins/build.sh
+++ b/.jenkins/build.sh
@@ -1,150 +1,135 @@
+#!/bin/bash
+
 set -ex
 
-if [[ "$COMMIT_SOURCE" == master ]]; then
-  export BUCKET_NAME=pytorch-tutorial-build-master
-else
-  export BUCKET_NAME=pytorch-tutorial-build-pull-request
-fi
+export BUCKET_NAME=pytorch-tutorial-build-pull-request
+
+# set locale for click dependency in spacy
+export LC_ALL=C.UTF-8
+export LANG=C.UTF-8
 
 DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null && pwd )"
 
-sudo apt-get update
-sudo apt-get install -y --no-install-recommends unzip p7zip-full sox libsox-dev libsox-fmt-all rsync
+# Update root certificates by installing new libgnutls30
 
-export PATH=/opt/conda/bin:$PATH
-rm -rf src
-pip install -r $DIR/../requirements.txt
+# Install pandoc (does not install from pypi)
+sudo apt-get update
+sudo apt-get install -y pandoc
 
-export PATH=/opt/conda/bin:$PATH
-conda install -y sphinx==1.8.2 pandas
-# PyTorch Theme
-rm -rf src
-pip install -e git+git://github.com/pytorch/pytorch_sphinx_theme.git#egg=pytorch_sphinx_theme
-# pillow >= 4.2 will throw error when trying to write mode RGBA as JPEG,
-# this is a workaround to the issue.
-pip install sphinx-gallery tqdm matplotlib ipython pillow==4.1.1
+# NS: Path to python runtime should already be part of docker container
+# export PATH=/opt/conda/bin:$PATH
 
-# Install torchaudio from source
-git clone https://github.com/pytorch/audio --quiet
-pushd audio
-python setup.py install
-popd
+#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).
+# sudo pip uninstall -y fbgemm-gpu torchrec
+# sudo pip uninstall -y torch torchvision torchaudio torchtext torchdata torchrl tensordict
+# sudo pip3 install fbgemm-gpu==1.1.0 torchrec==1.0.0 --no-cache-dir --index-url https://download.pytorch.org/whl/test/cu124
+# pip3 install torch==2.7.0 torchvision torchaudio --no-cache-dir --index-url https://download.pytorch.org/whl/test/cu126
+# Install two language tokenizers for Translation with TorchText tutorial
+python -m spacy download en_core_web_sm
+python -m spacy download de_core_news_sm
 
-aws configure set default.s3.multipart_threshold 5120MB
+awsv2 -i
+awsv2 configure set default.s3.multipart_threshold 5120MB
 
 # Decide whether to parallelize tutorial builds, based on $JOB_BASE_NAME
-export NUM_WORKERS=20
-if [[ "${JOB_BASE_NAME}" == *worker_* ]]; then
+if [[ "${JOB_TYPE}" == "worker" ]]; then
   # Step 1: Remove runnable code from tutorials that are not supposed to be run
-  python $DIR/remove_runnable_code.py beginner_source/aws_distributed_training_tutorial.py beginner_source/aws_distributed_training_tutorial.py
+  python $DIR/remove_runnable_code.py beginner_source/aws_distributed_training_tutorial.py beginner_source/aws_distributed_training_tutorial.py || true
+  # Temp remove for mnist download issue. (Re-enabled for 1.8.1)
+  # python $DIR/remove_runnable_code.py beginner_source/fgsm_tutorial.py beginner_source/fgsm_tutorial.py || true
+  # python $DIR/remove_runnable_code.py intermediate_source/spatial_transformer_tutorial.py intermediate_source/spatial_transformer_tutorial.py || true
+  # Temp remove for 1.10 release.
+  # python $DIR/remove_runnable_code.py advanced_source/neural_style_tutorial.py advanced_source/neural_style_tutorial.py || true
+
   # TODO: Fix bugs in these tutorials to make them runnable again
-  python $DIR/remove_runnable_code.py beginner_source/audio_classifier_tutorial.py beginner_source/audio_classifier_tutorial.py
+  # python $DIR/remove_runnable_code.py beginner_source/audio_classifier_tutorial.py beginner_source/audio_classifier_tutorial.py || true
+
+  # Remove runnable code from tensorboard_profiler_tutorial.py as it frequently crashes, see https://github.com/pytorch/pytorch/issues/74139
+  # python $DIR/remove_runnable_code.py intermediate_source/tensorboard_profiler_tutorial.py intermediate_source/tensorboard_profiler_tutorial.py || true
 
   # Step 2: Keep certain tutorials based on file count, and remove runnable code in all other tutorials
   # IMPORTANT NOTE: We assume that each tutorial has a UNIQUE filename.
-  export WORKER_ID=$(echo "${JOB_BASE_NAME}" | tr -dc '0-9')
-  count=0
-  FILES_TO_RUN=()
-  for filename in $(find beginner_source/ -name '*.py' -not -path '*/data/*'); do
-    if [ $(($count % $NUM_WORKERS)) != $WORKER_ID ]; then
-      echo "Removing runnable code from "$filename
-      python $DIR/remove_runnable_code.py $filename $filename
-    else
-      echo "Keeping "$filename
-      FILES_TO_RUN+=($(basename $filename .py))
-    fi
-    count=$((count+1))
-  done
-  for filename in $(find intermediate_source/ -name '*.py' -not -path '*/data/*'); do
-    if [ $(($count % $NUM_WORKERS)) != $WORKER_ID ]; then
-      echo "Removing runnable code from "$filename
-      python $DIR/remove_runnable_code.py $filename $filename
-    else
-      echo "Keeping "$filename
-      FILES_TO_RUN+=($(basename $filename .py))
-    fi
-    count=$((count+1))
-  done
-  for filename in $(find advanced_source/ -name '*.py' -not -path '*/data/*'); do
-    if [ $(($count % $NUM_WORKERS)) != $WORKER_ID ]; then
-      echo "Removing runnable code from "$filename
-      python $DIR/remove_runnable_code.py $filename $filename
-    else
-      echo "Keeping "$filename
-      FILES_TO_RUN+=($(basename $filename .py))
-    fi
-    count=$((count+1))
-  done
-  echo "FILES_TO_RUN: " ${FILES_TO_RUN[@]}
+  FILES_TO_RUN=$(python .jenkins/get_files_to_run.py)
+  echo "FILES_TO_RUN: " ${FILES_TO_RUN}
+  # Files to run must be accessible to subprocessed (at least to `download_data.py`)
+  export FILES_TO_RUN
 
-  # Step 3: Run `make docs` to generate HTML files and static files for these tutorials
+  # Step 3: Run `make docs` to generate HTML files and static files for these tutorialis
+  pip3 install -e git+https://github.com/pytorch/pytorch_sphinx_theme.git#egg=pytorch_sphinx_theme
   make docs
 
+  # Step 3.1: Run the post-processing script:
+  python .jenkins/post_process_notebooks.py
+
   # Step 4: If any of the generated files are not related the tutorial files we want to run,
   # then we remove them
-  for filename in $(find docs/beginner docs/intermediate docs/advanced -name '*.html'); do
+  set +x
+  for filename in $(find docs/beginner docs/intermediate docs/advanced docs/recipes docs/prototype -name '*.html'); do
     file_basename=$(basename $filename .html)
-    if [[ ! " ${FILES_TO_RUN[@]} " =~ " ${file_basename} " ]]; then
+    if [[ ! " ${FILES_TO_RUN} " =~ " ${file_basename} " ]]; then
+      echo "removing $filename"
       rm $filename
     fi
   done
-  for filename in $(find docs/beginner docs/intermediate docs/advanced -name '*.rst'); do
+  for filename in $(find docs/beginner docs/intermediate docs/advanced docs/recipes docs/prototype -name '*.rst'); do
     file_basename=$(basename $filename .rst)
-    if [[ ! " ${FILES_TO_RUN[@]} " =~ " ${file_basename} " ]]; then
+    if [[ ! " ${FILES_TO_RUN} " =~ " ${file_basename} " ]]; then
+      echo "removing $filename"
       rm $filename
     fi
   done
   for filename in $(find docs/_downloads -name '*.py'); do
     file_basename=$(basename $filename .py)
-    if [[ ! " ${FILES_TO_RUN[@]} " =~ " ${file_basename} " ]]; then
+    if [[ ! " ${FILES_TO_RUN} " =~ " ${file_basename} " ]]; then
+      echo "removing $filename"
       rm $filename
     fi
   done
   for filename in $(find docs/_downloads -name '*.ipynb'); do
     file_basename=$(basename $filename .ipynb)
-    if [[ ! " ${FILES_TO_RUN[@]} " =~ " ${file_basename} " ]]; then
+    if [[ ! " ${FILES_TO_RUN} " =~ " ${file_basename} " ]]; then
+      echo "removing $filename"
       rm $filename
     fi
   done
-  for filename in $(find docs/_sources/beginner docs/_sources/intermediate docs/_sources/advanced -name '*.rst.txt'); do
+  for filename in $(find docs/_sources/beginner docs/_sources/intermediate docs/_sources/advanced docs/_sources/recipes -name '*.rst.txt'); do
     file_basename=$(basename $filename .rst.txt)
-    if [[ ! " ${FILES_TO_RUN[@]} " =~ " ${file_basename} " ]]; then
+    if [[ ! " ${FILES_TO_RUN} " =~ " ${file_basename} " ]]; then
+      echo "removing $filename"
       rm $filename
     fi
   done
-  for filename in $(find docs/.doctrees/beginner docs/.doctrees/intermediate docs/.doctrees/advanced -name '*.doctree'); do
+  for filename in $(find docs/.doctrees/beginner docs/.doctrees/intermediate docs/.doctrees/advanced docs/.doctrees/recipes docs/.doctrees/prototype -name '*.doctree'); do
     file_basename=$(basename $filename .doctree)
-    if [[ ! " ${FILES_TO_RUN[@]} " =~ " ${file_basename} " ]]; then
+    if [[ ! " ${FILES_TO_RUN} " =~ " ${file_basename} " ]]; then
+      echo "removing $filename"
       rm $filename
     fi
   done
+  set -x
 
   # Step 5: Remove INVISIBLE_CODE_BLOCK from .html/.rst.txt/.ipynb/.py files
   bash $DIR/remove_invisible_code_block_batch.sh docs
+  python .jenkins/validate_tutorials_built.py
 
   # Step 6: Copy generated files to S3, tag with commit ID
   7z a worker_${WORKER_ID}.7z docs
-  aws s3 cp worker_${WORKER_ID}.7z s3://${BUCKET_NAME}/${COMMIT_ID}/worker_${WORKER_ID}.7z --acl public-read
-elif [[ "${JOB_BASE_NAME}" == *manager ]]; then
+  awsv2 s3 cp worker_${WORKER_ID}.7z s3://${BUCKET_NAME}/${COMMIT_ID}/worker_${WORKER_ID}.7z
+elif [[ "${JOB_TYPE}" == "manager" ]]; then
   # Step 1: Generate no-plot HTML pages for all tutorials
+  pip3 install -e git+https://github.com/pytorch/pytorch_sphinx_theme.git#egg=pytorch_sphinx_theme
   make html-noplot
   cp -r _build/html docs
 
   # Step 2: Wait for all workers to finish
-  set +e
-  for ((worker_id=0;worker_id<NUM_WORKERS;worker_id++)); do
-    until aws s3api head-object --bucket ${BUCKET_NAME} --key ${COMMIT_ID}/worker_$worker_id.7z
-    do
-      echo "Waiting for worker $worker_id to finish..."
-      sleep 5
-    done
-  done
-  set -e
+  # Don't actually need to do this because gha will wait
 
   # Step 3: Download generated with-plot HTML files and static files from S3, merge into one folder
   mkdir -p docs_with_plot/docs
-  for ((worker_id=0;worker_id<NUM_WORKERS;worker_id++)); do
-    aws s3 cp s3://${BUCKET_NAME}/${COMMIT_ID}/worker_$worker_id.7z worker_$worker_id.7z
+  for ((worker_id=1;worker_id<NUM_WORKERS+1;worker_id++)); do
+    awsv2 s3 cp s3://${BUCKET_NAME}/${COMMIT_ID}/worker_$worker_id.7z worker_$worker_id.7z
     7z x worker_$worker_id.7z -oworker_$worker_id
     yes | cp -R worker_$worker_id/docs/* docs_with_plot/docs
   done
@@ -154,19 +139,29 @@ elif [[ "${JOB_BASE_NAME}" == *manager ]]; then
 
   # Step 5: Remove INVISIBLE_CODE_BLOCK from .html/.rst.txt/.ipynb/.py files
   bash $DIR/remove_invisible_code_block_batch.sh docs
+  python .jenkins/validate_tutorials_built.py
+
+  # Step 5.1: Run post-processing script on .ipynb files:
+  python .jenkins/post_process_notebooks.py
 
   # Step 6: Copy generated HTML files and static files to S3
   7z a manager.7z docs
-  aws s3 cp manager.7z s3://${BUCKET_NAME}/${COMMIT_ID}/manager.7z --acl public-read
+  awsv2 s3 cp manager.7z s3://${BUCKET_NAME}/${COMMIT_ID}/manager.7z
 
   # Step 7: push new HTML files and static files to gh-pages
-  if [[ "$COMMIT_SOURCE" == master ]]; then
+  if [[ "$COMMIT_SOURCE" == "refs/heads/master" || "$COMMIT_SOURCE" == "refs/heads/main" ]]; then
     git clone https://github.com/pytorch/tutorials.git -b gh-pages gh-pages
+    # Clean up directories that contain tutorials
+
+    for dir in beginner intermediate prototype recipes advanced distributed vision text audio; do
+      rm -rf "gh-pages/$dir"
+    done
+
     cp -r docs/* gh-pages/
     pushd gh-pages
     # DANGER! DO NOT REMOVE THE `set +x` SETTING HERE!
     set +x
-    git remote set-url origin https://${GITHUB_PYTORCHBOT_USERNAME}:${GITHUB_PYTORCHBOT_TOKEN}@github.com/pytorch/tutorials.git
+    git remote set-url origin https://pytorchbot:${GITHUB_PYTORCHBOT_TOKEN}@github.com/pytorch/tutorials.git
     set -x
     git add -f -A || true
     git config user.email "soumith+bot@pytorch.org"
@@ -178,6 +173,3 @@ elif [[ "${JOB_BASE_NAME}" == *manager ]]; then
 else
   make docs
 fi
-
-rm -rf vision
-rm -rf audio
diff --git a/.jenkins/custom_pandoc_filter.py b/.jenkins/custom_pandoc_filter.py
new file mode 100644
index 00000000000..f4ceb0df11e
--- /dev/null
+++ b/.jenkins/custom_pandoc_filter.py
@@ -0,0 +1,139 @@
+from pandocfilters import toJSONFilter, Div, RawBlock, Para, Str, Space, Link, Code, CodeBlock
+import markdown
+import html
+
+def to_markdown(item, skip_octicon=False):
+    # A handler function to process strings, links, code, and code
+    # blocks
+    if item['t'] == 'Str':
+        return item['c']
+    elif item['t'] == 'Space':
+        return ' '
+    elif item['t'] == 'Link':
+        link_text = ''.join(to_markdown(i, skip_octicon) for i in item['c'][1])
+        return f'<a href="{item["c"][2][0]}">{link_text}</a>'
+    elif item['t'] == 'Code':
+        # Need to remove icticon as they don't render in .ipynb
+        if any(value == 'octicon' for key, value in item['c'][0][2]):
+            return ''
+        else:
+            # Escape the code and wrap it in <code> tags
+            return f'<code>{html.escape(item["c"][1])}</code>'
+    elif item['t'] == 'CodeBlock':
+        # Escape the code block and wrap it in <pre><code> tags
+        return f'<pre><code>{html.escape(item["c"][1])}</code></pre>'
+    else:
+        return ''
+
+
+def process_admonitions(key, value, format, meta):
+    # Replace admonitions with proper HTML.
+    if key == 'Div':
+        [[ident, classes, keyvals], contents] = value
+        if 'note' in classes:
+            color = '#54c7ec'
+            label = 'NOTE:'
+        elif 'tip' in classes:
+            color = '#6bcebb'
+            label = 'TIP:'
+        elif 'warning' in classes:
+            color = '#e94f3b'
+            label = 'WARNING:'
+        else:
+            return
+
+        note_content = []
+        for block in contents:
+            if block.get('t') == 'Para':
+                for item in block['c']:
+                    if item['t'] == 'Str':
+                        note_content.append(Str(item['c']))
+                    elif item['t'] == 'Space':
+                        note_content.append(Space())
+                    elif item['t'] == 'Link':
+                        note_content.append(Link(*item['c']))
+                    elif item['t'] == 'Code':
+                        note_content.append(Code(*item['c']))
+            elif block.get('t') == 'CodeBlock':
+                note_content.append(CodeBlock(*block['c']))
+
+        note_content_md = ''.join(to_markdown(item) for item in note_content)
+        html_content = markdown.markdown(note_content_md)
+
+        return [{'t': 'RawBlock', 'c': ['html', f'<div style="background-color: {color}; color: #fff; font-weight: 700; padding-left: 10px; padding-top: 5px; padding-bottom: 5px"><strong>{label}</strong></div>']}, {'t': 'RawBlock', 'c': ['html', '<div style="background-color: #f3f4f7; padding-left: 10px; padding-top: 10px; padding-bottom: 10px; padding-right: 10px">']}, {'t': 'RawBlock', 'c': ['html', html_content]}, {'t': 'RawBlock', 'c': ['html', '</div>']}]
+    elif key == 'RawBlock':
+    # this is needed for the cells that have embedded video.
+    # We add a special tag to those: ``` {python, .jupyter-code-cell}
+    # The post-processing script then finds those and genrates separate
+    # code cells that can load video.
+        [format, content] = value
+        if format == 'html' and 'iframe' in content:
+            # Extract the video URL
+            video_url = content.split('src="')[1].split('"')[0]
+            # Create the Python code to display the video
+            python_code = f"""
+from IPython.display import display, HTML
+html_code = \"""
+{content}
+\"""
+display(HTML(html_code))
+"""
+
+            return {'t': 'CodeBlock', 'c': [['', ['python', 'jupyter-code-cell'], []], python_code]}
+
+
+def process_images(key, value, format, meta):
+    # Add https://pytorch.org/tutorials/ to images so that they
+    # load correctly in the notebook.
+    if key != 'Image':
+        return None
+    [ident, classes, keyvals], caption, [src, title] = value
+    if not src.startswith('http'):
+        while src.startswith('../'):
+            src = src[3:]
+        if src.startswith('/_static'):
+            src = src[1:]
+        src = 'https://pytorch.org/tutorials/' + src
+
+    return {'t': 'Image', 'c': [[ident, classes, keyvals], caption, [src, title]]}
+
+
+def process_grids(key, value, format, meta):
+    # Generate side by side grid cards. Only for the two-cards layout
+    # that we use in the tutorial template.
+    if key == 'Div':
+        [[ident, classes, keyvals], contents] = value
+        if 'grid' in classes:
+            columns = ['<div style="width: 45%; float: left; padding: 20px;">',
+                       '<div style="width: 45%; float: right; padding: 20px;">']
+            column_num = 0
+            for block in contents:
+                if 't' in block and block['t'] == 'Div' and 'grid-item-card' in block['c'][0][1]:
+                    item_html = ''
+                    for item in block['c'][1]:
+                        if item['t'] == 'Para':
+                            item_html += '<h2>' + ''.join(to_markdown(i) for i in item['c']) + '</h2>'
+                        elif item['t'] == 'BulletList':
+                            item_html += '<ul>'
+                            for list_item in item['c']:
+                                item_html += '<li>' + ''.join(to_markdown(i) for i in list_item[0]['c']) + '</li>'
+                            item_html += '</ul>'
+                    columns[column_num] += item_html
+                    column_num = (column_num + 1) % 2
+            columns = [column + '</div>' for column in columns]
+            return {'t': 'RawBlock', 'c': ['html', ''.join(columns)]}
+
+def is_code_block(item):
+    return item['t'] == 'Code' and 'octicon' in item['c'][1]
+
+
+def process_all(key, value, format, meta):
+    for transform in [process_admonitions, process_images, process_grids]:
+        new_value = transform(key, value, format, meta)
+        if new_value is not None:
+            break
+    return new_value
+
+
+if __name__ == "__main__":
+    toJSONFilter(process_all)
diff --git a/.jenkins/download_data.py b/.jenkins/download_data.py
new file mode 100644
index 00000000000..939e63fc7a8
--- /dev/null
+++ b/.jenkins/download_data.py
@@ -0,0 +1,136 @@
+#!/usr/bin/env python3
+import hashlib
+import os
+
+from typing import Optional
+from urllib.request import urlopen, Request
+from pathlib import Path
+from zipfile import ZipFile
+
+REPO_BASE_DIR = Path(__file__).absolute().parent.parent
+DATA_DIR = REPO_BASE_DIR / "_data"
+BEGINNER_DATA_DIR = REPO_BASE_DIR / "beginner_source" / "data"
+INTERMEDIATE_DATA_DIR = REPO_BASE_DIR / "intermediate_source" / "data"
+ADVANCED_DATA_DIR = REPO_BASE_DIR / "advanced_source" / "data"
+PROTOTYPE_DATA_DIR = REPO_BASE_DIR / "unstable_source" / "data"
+FILES_TO_RUN = os.getenv("FILES_TO_RUN")
+
+
+def size_fmt(nbytes: int) -> str:
+    """Returns a formatted file size string"""
+    KB = 1024
+    MB = 1024 * KB
+    GB = 1024 * MB
+    if abs(nbytes) >= GB:
+        return f"{nbytes * 1.0 / GB:.2f} Gb"
+    elif abs(nbytes) >= MB:
+        return f"{nbytes * 1.0 / MB:.2f} Mb"
+    elif abs(nbytes) >= KB:
+        return f"{nbytes * 1.0 / KB:.2f} Kb"
+    return str(nbytes) + " bytes"
+
+
+def download_url_to_file(url: str,
+                         dst: Optional[str] = None,
+                         prefix: Optional[Path] = None,
+                         sha256: Optional[str] = None) -> Path:
+    dst = dst if dst is not None else Path(url).name
+    dst = dst if prefix is None else str(prefix / dst)
+    if Path(dst).exists():
+        print(f"Skip downloading {url} as {dst} already exists")
+        return Path(dst)
+    file_size = None
+    u = urlopen(Request(url, headers={"User-Agent": "tutorials.downloader"}))
+    meta = u.info()
+    if hasattr(meta, 'getheaders'):
+        content_length = meta.getheaders("Content-Length")
+    else:
+        content_length = meta.get_all("Content-Length")
+    if content_length is not None and len(content_length) > 0:
+        file_size = int(content_length[0])
+    sha256_sum = hashlib.sha256()
+    with open(dst, "wb") as f:
+        while True:
+            buffer = u.read(32768)
+            if len(buffer) == 0:
+                break
+            sha256_sum.update(buffer)
+            f.write(buffer)
+    digest = sha256_sum.hexdigest()
+    if sha256 is not None and sha256 != digest:
+        Path(dst).unlink()
+        raise RuntimeError(f"Downloaded {url} has unexpected sha256sum {digest} should be {sha256}")
+    print(f"Downloaded {url} sha256sum={digest} size={size_fmt(file_size)}")
+    return Path(dst)
+
+
+def unzip(archive: Path, tgt_dir: Path) -> None:
+    with ZipFile(str(archive), "r") as zip_ref:
+        zip_ref.extractall(str(tgt_dir))
+
+
+def download_hymenoptera_data():
+    # transfer learning tutorial data
+    z = download_url_to_file("https://download.pytorch.org/tutorial/hymenoptera_data.zip",
+                             prefix=DATA_DIR,
+                             sha256="fbc41b31d544714d18dd1230b1e2b455e1557766e13e67f9f5a7a23af7c02209",
+                             )
+    unzip(z, BEGINNER_DATA_DIR)
+
+
+def download_nlp_data() -> None:
+    # nlp tutorial data
+    z = download_url_to_file("https://download.pytorch.org/tutorial/data.zip",
+                             prefix=DATA_DIR,
+                             sha256="fb317e80248faeb62dc25ef3390ae24ca34b94e276bbc5141fd8862c2200bff5",
+                             )
+    # This will unzip all files in data.zip to intermediate_source/data/ folder
+    unzip(z, INTERMEDIATE_DATA_DIR.parent)
+
+
+def download_dcgan_data() -> None:
+    # Download dataset for beginner_source/dcgan_faces_tutorial.py
+    z = download_url_to_file("https://s3.amazonaws.com/pytorch-tutorial-assets/img_align_celeba.zip",
+                             prefix=DATA_DIR,
+                             sha256="46fb89443c578308acf364d7d379fe1b9efb793042c0af734b6112e4fd3a8c74",
+                             )
+    unzip(z, BEGINNER_DATA_DIR / "celeba")
+
+
+def download_lenet_mnist() -> None:
+    # Download model for beginner_source/fgsm_tutorial.py
+    download_url_to_file("https://docs.google.com/uc?export=download&id=1HJV2nUHJqclXQ8flKvcWmjZ-OU5DGatl",
+                         prefix=BEGINNER_DATA_DIR,
+                         dst="lenet_mnist_model.pth",
+                         sha256="cb5f8e578aef96d5c1a2cc5695e1aa9bbf4d0fe00d25760eeebaaac6ebc2edcb",
+                         )
+
+def download_gpu_quantization_torchao() -> None:
+    # Download SAM model checkpoint unstable_source/gpu_quantization_torchao_tutorial.py
+    download_url_to_file("https://dl.fbaipublicfiles.com/segment_anything/sam_vit_h_4b8939.pth",
+                         prefix=PROTOTYPE_DATA_DIR,
+                         dst="sam_vit_h_4b8939.pth",
+                         sha256="a7bf3b02f3ebf1267aba913ff637d9a2d5c33d3173bb679e46d9f338c26f262e",
+                         )
+
+def main() -> None:
+    DATA_DIR.mkdir(exist_ok=True)
+    BEGINNER_DATA_DIR.mkdir(exist_ok=True)
+    ADVANCED_DATA_DIR.mkdir(exist_ok=True)
+    INTERMEDIATE_DATA_DIR.mkdir(exist_ok=True)
+    PROTOTYPE_DATA_DIR.mkdir(exist_ok=True)
+
+    if FILES_TO_RUN is None or "transfer_learning_tutorial" in FILES_TO_RUN:
+        download_hymenoptera_data()
+    nlp_tutorials = ["seq2seq_translation_tutorial", "char_rnn_classification_tutorial", "char_rnn_generation_tutorial"]
+    if FILES_TO_RUN is None or any(x in FILES_TO_RUN for x in nlp_tutorials):
+        download_nlp_data()
+    if FILES_TO_RUN is None or "dcgan_faces_tutorial" in FILES_TO_RUN:
+        download_dcgan_data()
+    if FILES_TO_RUN is None or "fgsm_tutorial" in FILES_TO_RUN:
+        download_lenet_mnist()
+    if FILES_TO_RUN is None or "gpu_quantization_torchao_tutorial" in FILES_TO_RUN:
+        download_gpu_quantization_torchao()
+
+if __name__ == "__main__":
+    main()
diff --git a/.jenkins/get_docker_tag.py b/.jenkins/get_docker_tag.py
new file mode 100644
index 00000000000..21c4a8f7089
--- /dev/null
+++ b/.jenkins/get_docker_tag.py
@@ -0,0 +1,18 @@
+import requests
+
+REQUEST_HEADERS = {
+    "Accept": "application/vnd.github.v3+json",
+}
+
+if __name__ == "__main__":
+    url = "https://api.github.com/repos/pytorch/pytorch/contents/.ci"
+
+    response = requests.get(url, headers=REQUEST_HEADERS)
+    docker_sha = None
+    for finfo in response.json():
+        if finfo["name"] == "docker":
+            docker_sha = finfo["sha"]
+            break
+    if docker_sha is None:
+        raise RuntimeError("Can't find sha sum of docker folder")
+    print(docker_sha)
diff --git a/.jenkins/get_files_to_run.py b/.jenkins/get_files_to_run.py
new file mode 100644
index 00000000000..bdf4562a827
--- /dev/null
+++ b/.jenkins/get_files_to_run.py
@@ -0,0 +1,106 @@
+from typing import Any, Dict, List, Optional, Tuple
+import json
+import os
+from pathlib import Path
+from remove_runnable_code import remove_runnable_code
+
+
+# Calculate repo base dir
+REPO_BASE_DIR = Path(__file__).absolute().parent.parent
+
+
+def get_all_files() -> List[str]:
+    sources = [x.relative_to(REPO_BASE_DIR) for x in REPO_BASE_DIR.glob("*_source/**/*.py") if 'data' not in x.parts]
+    return sorted([str(x) for x in sources])
+
+
+def read_metadata() -> Dict[str, Any]:
+    with (REPO_BASE_DIR / ".jenkins" / "metadata.json").open() as fp:
+        return json.load(fp)
+
+
+def calculate_shards(all_files: List[str], num_shards: int = 20) -> List[List[str]]:
+    sharded_files: List[Tuple[float, List[str]]] = [(0.0, []) for _ in range(num_shards)]
+    metadata = read_metadata()
+
+    def get_duration(file: str) -> int:
+        # tutorials not listed in the metadata.json file usually take
+        # <3min to run, so we'll default to 1min if it's not listed
+        return metadata.get(file, {}).get("duration", 60)
+
+    def get_needs_machine(file: str) -> Optional[str]:
+        return metadata.get(file, {}).get("needs", None)
+
+    def add_to_shard(i, filename):
+        shard_time, shard_jobs = sharded_files[i]
+        shard_jobs.append(filename)
+        sharded_files[i] = (
+            shard_time + get_duration(filename),
+            shard_jobs,
+        )
+
+    all_other_files = all_files.copy()
+    needs_multigpu = list(
+        filter(lambda x: get_needs_machine(x) == "linux.16xlarge.nvidia.gpu", all_files,)
+    )
+    needs_a10g = list(
+        filter(lambda x: get_needs_machine(x) == "linux.g5.4xlarge.nvidia.gpu", all_files,)
+    )
+    for filename in needs_multigpu:
+        # currently, the only job that has multigpu is the 0th worker,
+        # so we'll add all the jobs that need this machine to the 0th worker
+        add_to_shard(0, filename)
+        all_other_files.remove(filename)
+    for filename in needs_a10g:
+        # currently, workers 1-5 use linux.g5.4xlarge.nvidia.gpu (sm86, A10G),
+        # so we'll add all the jobs that need this machine to the 1st worker
+        add_to_shard(1, filename)
+        all_other_files.remove(filename)
+    sorted_files = sorted(all_other_files, key=get_duration, reverse=True,)
+
+    for filename in sorted_files:
+        min_shard_index = sorted(range(1, num_shards), key=lambda i: sharded_files[i][0])[
+            0
+        ]
+        add_to_shard(min_shard_index, filename)
+    return [x[1] for x in sharded_files]
+
+
+def compute_files_to_keep(files_to_run: List[str]) -> List[str]:
+    metadata = read_metadata()
+    files_to_keep = list(files_to_run)
+    for file in files_to_run:
+        extra_files = metadata.get(file, {}).get("extra_files", [])
+        files_to_keep.extend(extra_files)
+    return files_to_keep
+
+
+def remove_other_files(all_files, files_to_keep) -> None:
+
+    for file in all_files:
+        if file not in files_to_keep:
+            remove_runnable_code(file, file)
+
+
+def parse_args() -> Any:
+    from argparse import ArgumentParser
+    parser = ArgumentParser("Select files to run")
+    parser.add_argument("--dry-run", action="store_true")
+    parser.add_argument("--num-shards", type=int, default=int(os.environ.get("NUM_WORKERS", "20")))
+    parser.add_argument("--shard-num", type=int, default=int(os.environ.get("WORKER_ID", "1")))
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+
+    all_files = get_all_files()
+    files_to_run = calculate_shards(all_files, num_shards=args.num_shards)[args.shard_num - 1]
+    if not args.dry_run:
+        remove_other_files(all_files, compute_files_to_keep(files_to_run))
+    stripped_file_names = [Path(x).stem for x in files_to_run]
+    print(" ".join(stripped_file_names))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/.jenkins/get_sphinx_filenames.py b/.jenkins/get_sphinx_filenames.py
new file mode 100644
index 00000000000..b84267b48a3
--- /dev/null
+++ b/.jenkins/get_sphinx_filenames.py
@@ -0,0 +1,13 @@
+from pathlib import Path
+from typing import List
+
+from get_files_to_run import get_all_files
+from validate_tutorials_built import NOT_RUN
+
+
+def get_files_for_sphinx() -> List[str]:
+    all_py_files = get_all_files()
+    return [x for x in all_py_files if all(y not in x for y in NOT_RUN)]
+
+
+SPHINX_SHOULD_RUN = "|".join(get_files_for_sphinx())
diff --git a/.jenkins/insert_last_verified.py b/.jenkins/insert_last_verified.py
new file mode 100644
index 00000000000..b43ef8de8e8
--- /dev/null
+++ b/.jenkins/insert_last_verified.py
@@ -0,0 +1,160 @@
+import json
+import os
+import subprocess
+import sys
+from datetime import datetime
+
+from bs4 import BeautifulSoup
+
+
+json_file_path = "tutorials-review-data.json"
+
+# paths to skip from the post-processing script
+paths_to_skip = [
+    "beginner/examples_autograd/two_layer_net_custom_function",  # not present in the repo
+    "beginner/examples_nn/two_layer_net_module",  # not present in the repo
+    "beginner/examples_tensor/two_layer_net_numpy",  # not present in the repo
+    "beginner/examples_tensor/two_layer_net_tensor",  # not present in the repo
+    "beginner/examples_autograd/two_layer_net_autograd",  # not present in the repo
+    "beginner/examples_nn/two_layer_net_optim",  # not present in the repo
+    "beginner/examples_nn/two_layer_net_nn",  # not present in the repo
+    "intermediate/coding_ddpg",  # not present in the repo - will delete the carryover
+]
+# Mapping of source directories to build directories
+source_to_build_mapping = {
+    "beginner": "beginner_source",
+    "recipes": "recipes_source",
+    "distributed": "distributed",
+    "intermediate": "intermediate_source",
+    "prototype": "prototype_source",
+    "advanced": "advanced_source",
+    "": "",  # root dir for index.rst
+}
+
+def get_git_log_date(file_path, git_log_args):
+    try:
+        result = subprocess.run(
+            ["git", "log"] + git_log_args + ["--", file_path],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        if result.stdout:
+            date_str = result.stdout.splitlines()[0]
+            return datetime.strptime(date_str, "%a, %d %b %Y %H:%M:%S %z")
+    except subprocess.CalledProcessError:
+        pass
+    raise ValueError(f"Could not find date for {file_path}")
+
+def get_creation_date(file_path):
+    return get_git_log_date(file_path, ["--diff-filter=A", "--format=%aD"]).strftime("%b %d, %Y")
+
+
+def get_last_updated_date(file_path):
+    return get_git_log_date(file_path, ["-1", "--format=%aD"]).strftime("%b %d, %Y")
+
+# Try to find the source file with the given base path and the extensions .rst and .py
+def find_source_file(base_path):
+    for ext in [".rst", ".py"]:
+        source_file_path = base_path + ext
+        if os.path.exists(source_file_path):
+            return source_file_path
+    return None
+
+
+# Function to process a JSON file and insert the "Last Verified" information into the HTML files
+def process_json_file(build_dir , json_file_path):
+    with open(json_file_path, "r", encoding="utf-8") as json_file:
+        json_data = json.load(json_file)
+
+    for entry in json_data:
+        path = entry["Path"]
+        last_verified = entry["Last Verified"]
+        status = entry.get("Status", "")
+        if path in paths_to_skip:
+            print(f"Skipping path: {path}")
+            continue
+        if status in ["needs update", "not verified"]:
+            formatted_last_verified = "Not Verified"
+        elif last_verified:
+            try:
+                last_verified_date = datetime.strptime(last_verified, "%Y-%m-%d")
+                formatted_last_verified = last_verified_date.strftime("%b %d, %Y")
+            except ValueError:
+                formatted_last_verified = "Unknown"
+        else:
+            formatted_last_verified = "Not Verified"
+        if status == "deprecated":
+            formatted_last_verified += "Deprecated"
+
+        for build_subdir, source_subdir in source_to_build_mapping.items():
+            if path.startswith(build_subdir):
+                html_file_path = os.path.join(build_dir, path + ".html")
+                base_source_path = os.path.join(
+                    source_subdir, path[len(build_subdir) + 1 :]
+                )
+                source_file_path = find_source_file(base_source_path)
+                break
+        else:
+            print(f"Warning: No mapping found for path {path}")
+            continue
+
+        if not os.path.exists(html_file_path):
+            print(
+                f"Warning: HTML file not found for path {html_file_path}."
+                "If this is a new tutorial, please add it to the audit JSON file and set the Verified status and todays's date."
+            )
+            continue
+
+        if not source_file_path:
+            print(f"Warning: Source file not found for path {base_source_path}.")
+            continue
+
+        created_on = get_creation_date(source_file_path)
+        last_updated = get_last_updated_date(source_file_path)
+
+        with open(html_file_path, "r", encoding="utf-8") as file:
+            soup = BeautifulSoup(file, "html.parser")
+        # Check if the <p> tag with class "date-info-last-verified" already exists
+        existing_date_info = soup.find("p", {"class": "date-info-last-verified"})
+        if existing_date_info:
+            print(
+                f"Warning: <p> tag with class 'date-info-last-verified' already exists in {html_file_path}"
+            )
+            continue
+
+        h1_tag = soup.find("h1")  # Find the h1 tag to insert the dates
+        if h1_tag:
+            date_info_tag = soup.new_tag("p", **{"class": "date-info-last-verified"})
+            date_info_tag["style"] = "color: #6c6c6d; font-size: small;"
+            # Add the "Created On", "Last Updated", and "Last Verified" information
+            date_info_tag.string = (
+                f"Created On: {created_on} | "
+                f"Last Updated: {last_updated} | "
+                f"Last Verified: {formatted_last_verified}"
+            )
+            # Insert the new tag after the <h1> tag
+            h1_tag.insert_after(date_info_tag)
+            # Save back to the HTML.
+            with open(html_file_path, "w", encoding="utf-8") as file:
+                file.write(str(soup))
+        else:
+            print(f"Warning: <h1> tag not found in {html_file_path}")
+
+
+def main():
+    if len(sys.argv) < 2:
+        print("Error: Build directory not provided. Exiting.")
+        exit(1)
+    build_dir = sys.argv[1]
+    print(f"Build directory: {build_dir}")
+    process_json_file(build_dir , json_file_path)
+    print(
+        "Finished processing JSON file. Please check the output for any warnings. "
+        "Pages like `nlp/index.html` are generated only during the full `make docs` "
+        "or `make html` build. Warnings about these files when you run `make html-noplot` "
+        "can be ignored."
+    )
+
+if __name__ == "__main__":
+    main()
diff --git a/.jenkins/metadata.json b/.jenkins/metadata.json
new file mode 100644
index 00000000000..6e82d054b4e
--- /dev/null
+++ b/.jenkins/metadata.json
@@ -0,0 +1,76 @@
+{
+  "intermediate_source/ax_multiobjective_nas_tutorial.py": {
+    "extra_files": ["intermediate_source/mnist_train_nas.py"],
+    "duration": 2000
+  },
+  "beginner_source/dcgan_faces_tutorial.py": {
+    "duration": 2000
+  },
+  "intermediate_source/seq2seq_translation_tutorial.py": {
+    "duration": 1200
+  },
+  "beginner_source/hyperparameter_tuning_tutorial.py": {
+    "duration": 0
+  },
+  "advanced_source/dynamic_quantization_tutorial.py": {
+    "duration": 380
+  },
+  "beginner_source/chatbot_tutorial.py": {
+    "duration": 330
+  },
+  "intermediate_source/pipeline_tutorial.py": {
+    "duration": 320,
+    "needs": "linux.16xlarge.nvidia.gpu"
+  },
+  "beginner_source/blitz/data_parallel_tutorial.py": {
+    "needs": "linux.16xlarge.nvidia.gpu"
+  },
+  "intermediate_source/model_parallel_tutorial.py": {
+    "needs": "linux.16xlarge.nvidia.gpu"
+  },
+  "intermediate_source/torchrec_intro_tutorial.py": {
+    "needs": "linux.g5.4xlarge.nvidia.gpu"
+  },
+  "recipes_source/torch_export_aoti_python.py": {
+    "needs": "linux.g5.4xlarge.nvidia.gpu"
+  },
+  "advanced_source/pendulum.py": {
+    "needs": "linux.g5.4xlarge.nvidia.gpu",
+    "_comment": "need to be here for the compiling_optimizer_lr_scheduler.py to run."
+  },
+  "intermediate_source/torchvision_tutorial.py": {
+    "needs": "linux.g5.4xlarge.nvidia.gpu",
+    "_comment": "does not require a5g but needs to run before gpu_quantization_torchao_tutorial.py."
+  },
+  "advanced_source/coding_ddpg.py": {
+     "needs": "linux.g5.4xlarge.nvidia.gpu",
+     "_comment": "does not require a5g but needs to run before gpu_quantization_torchao_tutorial.py."
+  },
+  "recipes_source/compiling_optimizer_lr_scheduler.py": {
+     "needs": "linux.g5.4xlarge.nvidia.gpu"
+  },
+  "intermediate_source/torch_compile_tutorial.py": {
+    "needs": "linux.g5.4xlarge.nvidia.gpu"
+  },
+  "intermediate_source/torch_export_tutorial.py": {
+    "needs": "linux.g5.4xlarge.nvidia.gpu"
+  },
+  "intermediate_source/scaled_dot_product_attention_tutorial.py": {
+    "needs": "linux.g5.4xlarge.nvidia.gpu"
+  },
+  "intermediate_source/transformer_building_blocks.py": {
+    "needs": "linux.g5.4xlarge.nvidia.gpu"
+  },
+  "recipes_source/torch_compile_user_defined_triton_kernel_tutorial.py": {
+    "needs": "linux.g5.4xlarge.nvidia.gpu"
+  },
+  "recipes_source/regional_compilation.py": {
+    "needs": "linux.g5.4xlarge.nvidia.gpu"
+  },
+  "advanced_source/semi_structured_sparse.py": {
+    "needs": "linux.g5.4xlarge.nvidia.gpu"
+  },
+  "prototype_source/gpu_quantization_torchao_tutorial.py": {
+    "needs": "linux.g5.4xlarge.nvidia.gpu"
+  }
+}
diff --git a/.jenkins/post_process_notebooks.py b/.jenkins/post_process_notebooks.py
new file mode 100644
index 00000000000..d10eb5a1bcc
--- /dev/null
+++ b/.jenkins/post_process_notebooks.py
@@ -0,0 +1,97 @@
+import nbformat as nbf
+import os
+import re
+
+"""
+This post-processing script needs to run after the .ipynb files are
+generated. The script removes extraneous ```{=html} syntax from the
+admonitions and splits the cells that have video iframe into a
+separate code cell that can be run to load the video directly
+in the notebook. This script is included in build.sh.
+"""
+
+
+# Pattern to search ``` {.python .jupyter-code-cell}
+pattern = re.compile(r'(.*?)``` {\.python \.jupyter-code-cell}\n(.*?from IPython\.display import display, HTML.*?display\(HTML\(html_code\)\))\n```(.*)', re.DOTALL)
+
+
+def process_video_cell(notebook_path):
+    """
+    This function finds the code blocks with the
+    "``` {.python .jupyter-code-cell}" code bocks and slices them
+    into a separe code cell (instead of markdown) which allows to
+    load the video in the notebook. The rest of the content is placed
+    in a new markdown cell.
+    """
+    print(f'Processing file: {notebook_path}')
+    notebook = nbf.read(notebook_path, as_version=4)
+
+    # Iterate over markdown cells
+    for i, cell in enumerate(notebook.cells):
+        if cell.cell_type == 'markdown':
+            match = pattern.search(cell.source)
+            if match:
+                print(f'Match found in cell {i}: {match.group(0)[:100]}...')
+                # Extract the parts before and after the video code block
+                before_html_block = match.group(1)
+                code_block = match.group(2)
+
+                # Add a comment to run the cell to display the video
+                code_block = "# Run this cell to load the video\n" + code_block
+                # Create a new code cell
+                new_code_cell = nbf.v4.new_code_cell(source=code_block)
+
+                # Replace the original markdown cell with the part before the code block
+                cell.source = before_html_block
+
+                # Insert the new code cell after the current one
+                notebook.cells.insert(i+1, new_code_cell)
+                print(f'New code cell created with source: {new_code_cell.source}')
+
+                # If there is content after the HTML code block, create a new markdown cell
+                if len(match.group(3).strip()) > 0:
+                    after_html_block = match.group(3)
+                    new_markdown_cell = nbf.v4.new_markdown_cell(source=after_html_block)
+                    # Create a new markdown cell and add the content after code block there
+                    notebook.cells.insert(i+2, new_markdown_cell)
+
+            else:
+                # Remove ```{=html} from the code block
+                cell.source = remove_html_tag(cell.source)
+
+    nbf.write(notebook, notebook_path)
+
+
+def remove_html_tag(content):
+    """
+    Pandoc adds an extraneous ```{=html} ``` to raw HTML blocks which
+    prevents it from rendering correctly. This function removes
+    ```{=html} that we don't need.
+    """
+    content = re.sub(r'```{=html}\n<div', '<div', content)
+    content = re.sub(r'">\n```', '">', content)
+    content = re.sub(r'<\/div>\n```', '</div>\n', content)
+    content = re.sub(r'```{=html}\n</div>\n```', '</div>\n', content)
+    content = re.sub(r'```{=html}', '', content)
+    content = re.sub(r'</p>\n```', '</p>', content)
+    return content
+
+
+def walk_dir(downloads_dir):
+    """
+    Walk the dir and process all notebook files in
+    the _downloads directory and its subdirectories.
+    """
+    for root, dirs, files in os.walk(downloads_dir):
+        for filename in files:
+            if filename.endswith('.ipynb'):
+                process_video_cell(os.path.join(root, filename))
+
+
+def main():
+    downloads_dir = './docs/_downloads'
+    walk_dir(downloads_dir)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/.jenkins/remove_invisible_code_block_from_html.py b/.jenkins/remove_invisible_code_block_from_html.py
index 921894e90e2..827b9802d91 100644
--- a/.jenkins/remove_invisible_code_block_from_html.py
+++ b/.jenkins/remove_invisible_code_block_from_html.py
@@ -8,7 +8,7 @@
     html = html_file.read()
 html_soup = BeautifulSoup(html, 'html.parser')
 
-elems = html_soup.find_all("div", {"class": "highlight-python"})
+elems = html_soup.find_all("div", {"class": "highlight-default"})
 for elem in elems:
     if "%%%%%%INVISIBLE_CODE_BLOCK%%%%%%" in str(elem):
         elem.decompose()
diff --git a/.jenkins/remove_invisible_code_block_from_rst_txt.py b/.jenkins/remove_invisible_code_block_from_rst_txt.py
index b7452f81e85..e6eb648e754 100644
--- a/.jenkins/remove_invisible_code_block_from_rst_txt.py
+++ b/.jenkins/remove_invisible_code_block_from_rst_txt.py
@@ -7,7 +7,7 @@
 with open(rst_txt_file_path, 'r', encoding='utf-8') as rst_txt_file:
     rst_txt = rst_txt_file.read()
 
-splits = rst_txt.split('.. code-block:: python\n\n\n    # %%%%%%INVISIBLE_CODE_BLOCK%%%%%%\n')
+splits = rst_txt.split('.. code-block:: default\n\n\n    # %%%%%%INVISIBLE_CODE_BLOCK%%%%%%\n')
 if len(splits) == 2:
     code_before_invisible_block = splits[0]
     code_after_invisible_block = splits[1].split('    # %%%%%%INVISIBLE_CODE_BLOCK%%%%%%\n')[1]
diff --git a/.jenkins/remove_runnable_code.py b/.jenkins/remove_runnable_code.py
index 6a61cb656bc..037017d8d76 100644
--- a/.jenkins/remove_runnable_code.py
+++ b/.jenkins/remove_runnable_code.py
@@ -4,44 +4,55 @@
 STATE_IN_MULTILINE_COMMENT_BLOCK_SINGLE_QUOTE = "STATE_IN_MULTILINE_COMMENT_BLOCK_SINGLE_QUOTE"
 STATE_NORMAL = "STATE_NORMAL"
 
-python_file_path = sys.argv[1]
-output_file_path = sys.argv[2]
 
-with open(python_file_path, 'r', encoding='utf-8') as file:
-    lines = file.readlines()
-    ret_lines = []
-    state = STATE_NORMAL
-    for line in lines:
-        if state == STATE_NORMAL:
-            if line.startswith('#'):
-                ret_lines.append(line)
-                state = STATE_NORMAL
-            elif line.startswith('"""') or line.startswith('r"""'):
-                ret_lines.append(line)
-                state = STATE_IN_MULTILINE_COMMENT_BLOCK_DOUBLE_QUOTE
-            elif line.startswith("'''") or line.startswith("r'''"):
-                ret_lines.append(line)
-                state = STATE_IN_MULTILINE_COMMENT_BLOCK_SINGLE_QUOTE
-            else:
-                ret_lines.append("\n")
-                state = STATE_NORMAL
-        elif state == STATE_IN_MULTILINE_COMMENT_BLOCK_DOUBLE_QUOTE:
-            if line.startswith('"""'):
-                ret_lines.append(line)
-                state = STATE_NORMAL
-            else:
-                ret_lines.append(line)
-                state = STATE_IN_MULTILINE_COMMENT_BLOCK_DOUBLE_QUOTE
-        elif state == STATE_IN_MULTILINE_COMMENT_BLOCK_SINGLE_QUOTE:
-            if line.startswith("'''"):
-                ret_lines.append(line)
-                state = STATE_NORMAL
-            else:
-                ret_lines.append(line)
-                state = STATE_IN_MULTILINE_COMMENT_BLOCK_SINGLE_QUOTE
+def remove_runnable_code(python_file_path, output_file_path):
+    with open(python_file_path, 'r', encoding='utf-8') as file:
+        lines = file.readlines()
+        ret_lines = []
+        state = STATE_NORMAL
+        for line in lines:
+            if state == STATE_NORMAL:
+                if line.startswith('#'):
+                    ret_lines.append(line)
+                    state = STATE_NORMAL
+                elif ((line.startswith('"""') or line.startswith('r"""')) and
+                        line.endswith('"""')):
+                    ret_lines.append(line)
+                    state = STATE_NORMAL
+                elif line.startswith('"""') or line.startswith('r"""'):
+                    ret_lines.append(line)
+                    state = STATE_IN_MULTILINE_COMMENT_BLOCK_DOUBLE_QUOTE
+                elif ((line.startswith("'''") or line.startswith("r'''")) and
+                        line.endswith("'''")):
+                    ret_lines.append(line)
+                    state = STATE_NORMAL
+                elif line.startswith("'''") or line.startswith("r'''"):
+                    ret_lines.append(line)
+                    state = STATE_IN_MULTILINE_COMMENT_BLOCK_SINGLE_QUOTE
+                else:
+                    ret_lines.append("\n")
+                    state = STATE_NORMAL
+            elif state == STATE_IN_MULTILINE_COMMENT_BLOCK_DOUBLE_QUOTE:
+                if line.startswith('"""'):
+                    ret_lines.append(line)
+                    state = STATE_NORMAL
+                else:
+                    ret_lines.append(line)
+                    state = STATE_IN_MULTILINE_COMMENT_BLOCK_DOUBLE_QUOTE
+            elif state == STATE_IN_MULTILINE_COMMENT_BLOCK_SINGLE_QUOTE:
+                if line.startswith("'''"):
+                    ret_lines.append(line)
+                    state = STATE_NORMAL
+                else:
+                    ret_lines.append(line)
+                    state = STATE_IN_MULTILINE_COMMENT_BLOCK_SINGLE_QUOTE
 
-ret_lines.append("\n# %%%%%%RUNNABLE_CODE_REMOVED%%%%%%")
+    ret_lines.append("\n# %%%%%%RUNNABLE_CODE_REMOVED%%%%%%")
 
-with open(output_file_path, 'w', encoding='utf-8') as file:
-    for line in ret_lines:
-        file.write(line)
+    with open(output_file_path, 'w', encoding='utf-8') as file:
+        for line in ret_lines:
+            file.write(line)
+
+
+if __name__ == "__main__":
+    remove_runnable_code(sys.argv[1], sys.argv[2])
diff --git a/.jenkins/test_files_to_run.py b/.jenkins/test_files_to_run.py
new file mode 100644
index 00000000000..b4842a7dd75
--- /dev/null
+++ b/.jenkins/test_files_to_run.py
@@ -0,0 +1,20 @@
+#!/usr/bin/env python
+from get_files_to_run import get_all_files, calculate_shards
+from unittest import TestCase, main
+from functools import reduce
+
+class TestSharding(TestCase):
+    def test_no_sharding(self):
+        all_files=get_all_files()
+        sharded_files = calculate_shards(all_files, 1)
+        self.assertSetEqual(set(all_files), set(sharded_files[0]))
+
+    def test_sharding(self, num_shards=20):
+        all_files=get_all_files()
+        sharded_files = map(set, calculate_shards(all_files, num_shards))
+        self.assertSetEqual(set(all_files), reduce(lambda x,y: x.union(y), sharded_files, set()))
+
+
+
+if __name__ == "__main__":
+    main()
diff --git a/.jenkins/validate_tutorials_built.py b/.jenkins/validate_tutorials_built.py
new file mode 100644
index 00000000000..75dd51dd789
--- /dev/null
+++ b/.jenkins/validate_tutorials_built.py
@@ -0,0 +1,84 @@
+from pathlib import Path
+from typing import List
+
+from bs4 import BeautifulSoup
+
+REPO_ROOT = Path(__file__).parent.parent
+
+# For every tutorial on this list, we should determine if it is ok to not run the tutorial (add a comment after
+# the file name to explain why, like intro.html), or fix the tutorial and remove it from this list).
+
+NOT_RUN = [
+    "beginner_source/basics/intro",  # no code
+    "beginner_source/introyt/introyt_index", # no code
+    "beginner_source/onnx/intro_onnx",
+    "beginner_source/profiler",
+    "beginner_source/saving_loading_models",
+    "beginner_source/introyt/captumyt",
+    "beginner_source/examples_nn/polynomial_module",
+    "beginner_source/examples_nn/dynamic_net",
+    "beginner_source/examples_nn/polynomial_optim",
+    "beginner_source/examples_autograd/polynomial_autograd",
+    "beginner_source/examples_autograd/polynomial_custom_function",
+    "intermediate_source/dqn_with_rnn_tutorial", #not working on 2.8 release reenable after 3514
+    "intermediate_source/mnist_train_nas",  # used by ax_multiobjective_nas_tutorial.py
+    "intermediate_source/torch_compile_conv_bn_fuser",
+    "intermediate_source/_torch_export_nightly_tutorial",  # does not work on release
+    "advanced_source/usb_semisup_learn", # fails with CUDA OOM error, should try on a different worker
+    "unstable_source/gpu_direct_storage", # requires specific filesystem + GPUDirect Storage to be set up
+    "recipes_source/recipes/tensorboard_with_pytorch",
+    "recipes_source/recipes/what_is_state_dict",
+    "recipes_source/recipes/profiler_recipe",
+    "recipes_source/recipes/warmstarting_model_using_parameters_from_a_different_model",
+    "recipes_source/recipes/benchmark",
+    "recipes_source/recipes/tuning_guide",
+    "recipes_source/recipes/zeroing_out_gradients",
+    "recipes_source/recipes/defining_a_neural_network",
+    "recipes_source/recipes/timer_quick_start",
+    "recipes_source/recipes/amp_recipe",
+    "recipes_source/recipes/Captum_Recipe",
+    "intermediate_source/tensorboard_profiler_tutorial", # reenable after 2.0 release.
+    "advanced_source/semi_structured_sparse", # reenable after 3303 is fixed.
+    "intermediate_source/torchrec_intro_tutorial.py", #failing with 2.8 reenable after 3498
+]
+
+def tutorial_source_dirs() -> List[Path]:
+    return [
+        p.relative_to(REPO_ROOT).with_name(p.stem[:-7])
+        for p in REPO_ROOT.glob("*_source")
+    ]
+
+
+def main() -> None:
+    docs_dir = REPO_ROOT / "docs"
+    html_file_paths = []
+    for tutorial_source_dir in tutorial_source_dirs():
+        glob_path = f"{tutorial_source_dir}/**/*.html"
+        html_file_paths += docs_dir.glob(glob_path)
+
+    should_not_run = [f'{x.replace("_source", "")}.html' for x in NOT_RUN]
+    did_not_run = []
+    for html_file_path in html_file_paths:
+        with open(html_file_path, "r", encoding="utf-8") as html_file:
+            html = html_file.read()
+        html_soup = BeautifulSoup(html, "html.parser")
+        elems = html_soup.find_all("p", {"class": "sphx-glr-timing"})
+        for elem in elems:
+            if (
+                "Total running time of the script: ( 0 minutes  0.000 seconds)"
+                in elem.text
+                and not any(html_file_path.match(file) for file in should_not_run)
+            ):
+                did_not_run.append(html_file_path.as_posix())
+
+    if len(did_not_run) != 0:
+        raise RuntimeError(
+            "The following file(s) are not known bad but ran in 0.000 sec, meaning that any "
+            + "python code in this tutorial probably didn't run:\n{}".format(
+                "\n".join(did_not_run)
+            )
+        )
+
+
+if __name__ == "__main__":
+    main()
diff --git a/.lintrunner.toml b/.lintrunner.toml
new file mode 100644
index 00000000000..d3a1cbd9885
--- /dev/null
+++ b/.lintrunner.toml
@@ -0,0 +1,225 @@
+merge_base_with = "origin/main"
+
+# 4805a6ead6f1e7f32351056e2602be4e908f69b7 is from pytorch/pytorch main branch 2025-07-16
+
+[[linter]]
+code = 'SPACES'
+include_patterns = ['**']
+exclude_patterns = [
+    "_static/**/*",  # Contains some files that should usually not be linted
+    # All files below this should be checked and either removed from the
+    # exclusion list by fixing them or have a reason to be excluded.
+    "advanced_source/coding_ddpg.py",
+    "advanced_source/cpp_autograd.rst",
+    "advanced_source/cpp_custom_ops.rst",
+    "advanced_source/generic_join.rst",
+    "advanced_source/neural_style_tutorial.py",
+    "advanced_source/pendulum.py",
+    "advanced_source/privateuseone.rst",
+    "advanced_source/semi_structured_sparse.py",
+    "advanced_source/sharding.rst",
+    "advanced_source/torch_script_custom_classes/custom_class_project/custom_test.py",
+    "advanced_source/transformer__timeseries_cpp_tutorial/transformer_timeseries.cpp",
+    "advanced_source/usb_semisup_learn.py",
+    "beginner_source/blitz/README.txt",
+    "beginner_source/blitz/neural_networks_tutorial.py",
+    "beginner_source/dcgan_faces_tutorial.py",
+    "beginner_source/ddp_series_fault_tolerance.rst",
+    "beginner_source/ddp_series_theory.rst",
+    "beginner_source/examples_nn/polynomial_module.py",
+    "beginner_source/examples_nn/polynomial_nn.py",
+    "beginner_source/hta_intro_tutorial.rst",
+    "beginner_source/hta_trace_diff_tutorial.rst",
+    "beginner_source/hybrid_frontend/README.txt",
+    "beginner_source/hybrid_frontend_tutorial.rst",
+    "beginner_source/hyperparameter_tuning_tutorial.py",
+    "beginner_source/introyt/README.txt",
+    "beginner_source/introyt/autogradyt_tutorial.py",
+    "beginner_source/introyt/captumyt.py",
+    "beginner_source/introyt/introyt1_tutorial.py",
+    "beginner_source/introyt/modelsyt_tutorial.py",
+    "beginner_source/introyt/tensorboardyt_tutorial.py",
+    "beginner_source/introyt/tensors_deeper_tutorial.py",
+    "beginner_source/introyt/trainingyt.py",
+    "beginner_source/knowledge_distillation_tutorial.py",
+    "beginner_source/nlp/sequence_models_tutorial.py",
+    "beginner_source/onnx/export_control_flow_model_to_onnx_tutorial.py",
+    "beginner_source/onnx/onnx_registry_tutorial.py",
+    "beginner_source/pytorch_with_examples.rst",
+    "beginner_source/saving_loading_models.py",
+    "beginner_source/template_tutorial.py",
+    "beginner_source/transfer_learning_tutorial.py",
+    "intermediate_source/TCPStore_libuv_backend.rst",
+    "intermediate_source/ax_multiobjective_nas_tutorial.py",
+    "intermediate_source/compiled_autograd_tutorial.rst",
+    "intermediate_source/ddp_series_multinode.rst",
+    "intermediate_source/dqn_with_rnn_tutorial.py",
+    "intermediate_source/fx_profiling_tutorial.py",
+    "intermediate_source/inductor_debug_cpu.py",
+    "intermediate_source/jacobians_hessians.py",
+    "intermediate_source/optimizer_step_in_backward_tutorial.py",
+    "intermediate_source/per_sample_grads.py",
+    "intermediate_source/pruning_tutorial.py",
+    "intermediate_source/reinforcement_q_learning.py",
+    "intermediate_source/tensorboard_profiler_tutorial.py",
+    "intermediate_source/torch_compile_tutorial.py",
+    "intermediate_source/transformer_building_blocks.py",
+    "unstable_source/README.md",
+    "unstable_source/README.txt",
+    "unstable_source/gpu_direct_storage.py",
+    "unstable_source/inductor_cpp_wrapper_tutorial.rst",
+    "unstable_source/inductor_windows.rst",
+    "unstable_source/maskedtensor_advanced_semantics.py",
+    "unstable_source/max_autotune_on_CPU_tutorial.rst",
+    "unstable_source/vmap_recipe.py",
+    "recipes_source/README.txt",
+    "recipes_source/compiling_optimizer.rst",
+    "recipes_source/compiling_optimizer_lr_scheduler.py",
+    "recipes_source/distributed_optim_torchscript.rst",
+    "recipes_source/foreach_map.py",
+    "recipes_source/profile_with_itt.rst",
+    "recipes_source/recipes/Captum_Recipe.py",
+    "recipes_source/recipes/benchmark.py",
+    "recipes_source/recipes/changing_default_device.py",
+    "recipes_source/recipes/defining_a_neural_network.py",
+    "recipes_source/recipes/tensorboard_with_pytorch.py",
+    "recipes_source/recipes/timer_quick_start.py",
+    "recipes_source/recipes/tuning_guide.py",
+    "recipes_source/recipes/warmstarting_model_using_parameters_from_a_different_model.py",
+    "recipes_source/recipes/what_is_state_dict.py",
+    "recipes_source/torch_compile_caching_tutorial.rst",
+    "recipes_source/torch_compile_torch_function_modes.py",
+    "recipes_source/torch_compile_user_defined_triton_kernel_tutorial.py",
+    "recipes_source/torch_compiler_set_stance_tutorial.py",
+    "recipes_source/torch_export_aoti_python.py",
+    "recipes_source/xeon_run_cpu.rst",
+    "advanced_source/cpp_export.rst",
+    "advanced_source/torch-script-parallelism.rst",
+    "advanced_source/torch_script_custom_classes.rst",
+    "advanced_source/torch_script_custom_ops.rst",
+    "recipes_source/torchscript_inference.rst",
+]
+init_command = [
+    'python3',
+    'tools/linter/adapters/run_from_link.py',
+    '--lint-name=grep_linter.py',
+    '--lint-link=https://raw.githubusercontent.com/pytorch/pytorch/4805a6ead6f1e7f32351056e2602be4e908f69b7/tools/linter/adapters/grep_linter.py',
+    '--',
+    '--dry-run={{DRYRUN}}',
+]
+command = [
+    'python3',
+    'tools/linter/adapters/run_from_link.py',
+    '--run-lint',
+    '--lint-name=grep_linter.py',
+    '--',
+    '--pattern=[[:blank:]]$',
+    '--linter-name=SPACES',
+    '--error-name=trailing spaces',
+    '--replace-pattern=s/[[:blank:]]+$//',
+    """--error-description=\
+        This line has trailing spaces; please remove them.\
+    """,
+    '--',
+    '@{{PATHSFILE}}'
+]
+
+[[linter]]
+code = 'TABS'
+include_patterns = ['**']
+exclude_patterns = [
+    "_static/**/*",  # Contains some files that should usually not be linted
+    ".lintrunner.toml",  # Ironically needs to contain the tab character to find in other files
+    "Makefile",  # Wants tabs for indentationo
+    # All files below this should be checked and either removed from the
+    # exclusion list by fixing them or have a reason to be excluded.
+    "advanced_source/README.txt",
+    "advanced_source/cpp_frontend.rst",
+    "advanced_source/torch_script_custom_ops.rst",
+    "beginner_source/README.txt",
+    "beginner_source/basics/tensorqs_tutorial.py",
+    "beginner_source/blitz/README.txt",
+    "beginner_source/blitz/tensor_tutorial.py",
+    "beginner_source/hybrid_frontend/README.txt",
+    "beginner_source/nlp/README.txt",
+    "beginner_source/nlp/pytorch_tutorial.py",
+    "intermediate_source/README.txt",
+    "intermediate_source/TP_tutorial.rst",
+    "intermediate_source/inductor_debug_cpu.py",
+    "unstable_source/README.txt",
+    "recipes_source/README.txt",
+    "recipes_source/recipes/README.txt",
+    "recipes_source/xeon_run_cpu.rst",
+]
+init_command = [
+    'python3',
+    'tools/linter/adapters/run_from_link.py',
+    '--lint-name=grep_linter.py',
+    '--lint-link=https://raw.githubusercontent.com/pytorch/pytorch/4805a6ead6f1e7f32351056e2602be4e908f69b7/tools/linter/adapters/grep_linter.py',
+    '--',
+    '--dry-run={{DRYRUN}}',
+]
+command = [
+    'python3',
+    'tools/linter/adapters/run_from_link.py',
+    '--run-lint',
+    '--lint-name=grep_linter.py',
+    '--',
+    # @lint-ignore TXT2
+    '--pattern=	',
+    '--linter-name=TABS',
+    '--error-name=saw some tabs',
+    '--replace-pattern=s/\t/    /',
+    """--error-description=\
+        This line has tabs; please replace them with spaces.\
+    """,
+    '--',
+    '@{{PATHSFILE}}'
+]
+
+[[linter]]
+code = 'NEWLINE'
+include_patterns=['**']
+exclude_patterns=[
+    "_static/**/*",  # Contains some files that should usually not be linted
+    # All files below this should be checked and either removed from the
+    # exclusion list by fixing them or have a reason to be excluded.
+    "advanced_source/extend_dispatcher.rst",
+    "advanced_source/neural_style_tutorial.py",
+    "advanced_source/sharding.rst",
+    "advanced_source/torch_script_custom_classes/custom_class_project/custom_test.py",
+    "advanced_source/transformer__timeseries_cpp_tutorial/transformer_timeseries.cpp",
+    "beginner_source/blitz/README.txt",
+    "beginner_source/dcgan_faces_tutorial.py",
+    "beginner_source/hta_trace_diff_tutorial.rst",
+    "beginner_source/hybrid_frontend/README.txt",
+    "beginner_source/nlp/pytorch_tutorial.py",
+    "beginner_source/template_tutorial.py",
+    "beginner_source/transfer_learning_tutorial.py",
+    "intermediate_source/custom_function_conv_bn_tutorial.py",
+    "intermediate_source/custom_function_double_backward_tutorial.rst",
+    "intermediate_source/forced_alignment_with_torchaudio_tutorial.rst",
+    "intermediate_source/nlp_from_scratch_index.rst",
+    "intermediate_source/pipeline_tutorial.rst",
+    "recipes_source/README.txt",
+    "recipes_source/script_optimized.rst",
+    "recipes_source/torch_compile_caching_configuration_tutorial.rst",
+    "recipes_source/torch_compile_caching_tutorial.rst",
+]
+init_command = [
+    'python3',
+    'tools/linter/adapters/run_from_link.py',
+    '--lint-name=newlines_linter.py',
+    '--lint-link=https://raw.githubusercontent.com/pytorch/pytorch/4805a6ead6f1e7f32351056e2602be4e908f69b7/tools/linter/adapters/newlines_linter.py',
+    '--',
+    '--dry-run={{DRYRUN}}',
+]
+command = [
+    'python3',
+    'tools/linter/adapters/run_from_link.py',
+    '--run-lint',
+    '--lint-name=newlines_linter.py',
+    '--',
+    '@{{PATHSFILE}}',
+]
+is_formatter = true
diff --git a/.lycheeignore b/.lycheeignore
new file mode 100644
index 00000000000..fc1e3f1fa85
--- /dev/null
+++ b/.lycheeignore
@@ -0,0 +1,17 @@
+# 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
+
+# Ignore local host link from intermediate_source/tensorboard_tutorial.rst
+http://localhost:6006
+
+# Ignore local host link from advanced_source/cpp_frontend.rst
+https://www.uber.com/blog/deep-neuroevolution/
diff --git a/.pyspelling.yml b/.pyspelling.yml
new file mode 100644
index 00000000000..bce797e6559
--- /dev/null
+++ b/.pyspelling.yml
@@ -0,0 +1,163 @@
+spellchecker: aspell
+matrix:
+- name: python
+  sources:
+  - "**/*.py"
+  dictionary:
+    wordlists:
+      - en-wordlist.txt
+  pipeline:
+  - pyspelling.filters.python:
+      group_comments: true
+  - pyspelling.filters.context:
+      context_visible_first: true
+      delimiters:
+        # Exclude figure rST tags
+        - open: '\.\.\s+(figure|literalinclude|math|image|grid)::'
+          close: '\n'
+        # Exclude roles:
+        - open: ':(?:(class|py:mod|mod|func|meth|obj)):`'
+          content: '[^`]*'
+          close: '`'
+        # Exclude reStructuredText hyperlinks
+        - open: '\s'
+          content: '\w*'
+          close: '_'
+        # Exclude raw directive
+        - open: '\.\. (raw)::.*$\n*'
+          close: '\n'
+        # Exclude Python coding directives
+        - open: '-\*- coding:'
+          close: '\n'
+        # Exclude Authors:
+        - open: 'Author(|s):'
+          close: '\n'
+        # Exclude .rst directives:
+        - open: ':math:`.*`'
+          close: ' '
+        # Ignore multiline content in codeblock
+        - open: '(?s)^::\n\n  '
+          close: '^\n'
+        # Ignore reStructuredText block directives
+        - open: '\.\. (code-block|math)::.*$\n*'
+          content: '(?P<first>(^(?P<indent>[ ]+).*$\n))(?P<other>(^([ \t]+.*|[ \t]*)$\n)*)'
+          close: '(^(?![ \t]+.*$))'
+        # Ignore references like "[1] Author: Title"
+        - open: '\[\d\]'
+          close: '\n'
+  - pyspelling.filters.markdown:
+  - pyspelling.filters.html:
+      ignores:
+        - code
+        - pre
+  - pyspelling.filters.url:
+- name: reST
+  sources:
+  - "**/*.rst"
+  dictionary:
+    wordlists:
+      - en-wordlist.txt
+  pipeline:
+  - pyspelling.filters.text:
+  - pyspelling.filters.context:
+      context_visible_first: true
+      delimiters:
+      # Ignore text between inline back ticks
+      - open: '(div style|iframe).*'
+        close: '\n'
+      - open: '(- )?(?P<open>`+)'
+        close: '(?P=open)'
+      - open: ':figure:.*'
+        close: '\n'
+      # Ignore reStructuredText roles
+      - open: ':(?:(class|file|func|math|ref|octicon|meth|obj)):`'
+        content: '[^`]*'
+        close: '`'
+      - open: ':width:'
+        close: '$'
+      # Exclude raw directive
+      - open: '\.\. (raw|grid-item-card|galleryitem|includenodoc)::.*$\n*'
+        close: '\n'
+      # Ignore reStructuredText literals
+      - open: '::$'
+        close: '(?P<literal>(?:((?P<indent>[ ]+).*$)|(\n))+)'
+      # Ignore reStructuredText hyperlinks
+      - open: '\s'
+        content: '\w*'
+        close: '_'
+      # Ignore hyperlink in the DDP tutorials
+      - open: '`.*'
+        close: '`__'
+      # Ignore reStructuredText header ---
+      - open: '^'
+        content: '--*'
+        close: '$'
+      # Ignore reStructuredText header '''
+      - open: '^'
+        content: '''''*'
+        close: '$'
+      # Ignore reStructuredText block directives
+      - open: '\.\. (code-block|math|table)::.*$\n*'
+        content: '(?P<first>(^(?P<indent>[ ]+).*$\n))(?P<other>(^([ \t]+.*|[ \t]*)$\n)*)'
+        close: '(^(?![ \t]+.*$))'
+      - open: '\.\. (raw)::.*$\n*'
+        close: '^\s*$'
+      # Ignore reStructuredText substitution definitions
+      - open: '^\.\. \|[^|]+\|'
+        close: '$'
+      # Ignore reStructuredText substitutions
+      - open: '\|'
+        content: '[^|]*'
+        close: '\|_?'
+      # Ignore reStructuredText toctree
+      - open: '\.\.\s+toctree::'
+        close: '(?P<toctree>(?:((?P<indent>[ ]+).*$)|(\n))+)'
+      # Ignore directives
+      - open: '\.\.\s+(image|include|only)::'
+        close: '$'
+  - pyspelling.filters.url:
+- name: markdown
+  sources:
+  - '**/*.md'
+  dictionary:
+    wordlists:
+      - en-wordlist.txt
+  pipeline:
+  - pyspelling.filters.markdown:
+      markdown_extensions:
+        - markdown.extensions.extra:
+        - markdown.extensions.admonition:
+        - markdown.extensions.codehilite:
+        - markdown.extensions.meta:
+        - markdown.extensions.tables:
+        - markdown.extensions.toc:
+  - pyspelling.filters.html:
+      comments: false
+      ignores:
+        - code
+        - pre
+        - tt
+        - img
+        - a
+        - table
+        - thead
+        - tbody
+        - th
+        - tr
+        - td
+  - pyspelling.filters.context:
+      context_visible_first: true
+      delimiters:
+        # Ignore code blocks
+        - open: '```[a-z]*\n'
+          close: '```\n'
+        # Ignore inline code
+        - open: '`'
+          close: '`'
+        # Ignore links
+        - open: '\[([^]]*)\]'
+          close: '\([^)]*\)'
+        # Ignore HTML comments
+        - open: '<!--'
+          close: '-->'
+  - pyspelling.filters.url:
diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md
new file mode 100644
index 00000000000..b91e23b17c0
--- /dev/null
+++ b/CODE_OF_CONDUCT.md
@@ -0,0 +1,76 @@
+# Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to make participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, sex characteristics, gender identity and expression,
+level of experience, education, socio-economic status, nationality, personal
+appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies within all project spaces, and it also applies when
+an individual is representing the project or its community in public spaces.
+Examples of representing a project or community include using an official
+project e-mail address, posting via an official social media account, or acting
+as an appointed representative at an online or offline event. Representation of
+a project may be further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at <conduct@pytorch.org>. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see
+https://www.contributor-covenant.org/faq
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
new file mode 100644
index 00000000000..9c52182e85a
--- /dev/null
+++ b/CONTRIBUTING.md
@@ -0,0 +1,367 @@
+# Contributing to tutorials
+
+We want to make contributing to this project as easy and transparent as
+possible. This file covers information on flagging issues, contributing
+updates to existing tutorials--and also submitting new tutorials.
+
+NOTE: This guide assumes that you have your GitHub account properly
+configured, such as having an SSH key. If this is your first time
+contributing on GitHub, see the [GitHub
+Documentation](https://docs.github.com/en/get-started/quickstart/contributing-to-projects)
+on contributing to projects.
+
+
+# Issues
+
+We use [GitHub Issues](https://github.com/pytorch/tutorials/issues) to
+track public bugs. Please ensure your description is clear and has
+sufficient instructions to be able to reproduce the issue.
+
+
+# Security Bugs
+
+Facebook has a [bounty program](https://www.facebook.com/whitehat/) for
+the safe disclosure of security bugs. For these types of issues, please
+go through the process outlined on that page and do not file a public
+issue.
+
+# Contributor License Agreement ("CLA")
+
+In order to accept a pull request, you need to submit a CLA. You only
+need to do this once and you will be able to work on all of Facebook's
+open source projects, not just PyTorch.
+
+Complete your CLA here: <https://code.facebook.com/cla>
+
+
+# License
+
+By contributing to the tutorials, you agree that your contributions will
+be licensed as described in the `LICENSE` file in the root directory of
+this source tree.
+
+
+# Updates to existing tutorials
+
+We welcome your pull requests (PR) for updates and fixes.
+
+1. If you haven't already, complete the Contributor License Agreement
+   ("CLA").
+1. Fork the repo and create a branch from
+   [`main`](https://github.com/pytorch/tutorials).
+1. Test your code.
+1. Lint your code with a tool such as
+   [Pylint](https://pylint.pycqa.org/en/latest/).
+1. Submit your PR for review.
+
+
+# New Tutorials
+
+There are three types of tutorial content that we host on
+[`pytorch.org/tutorials`](https://github.com/pytorch/tutorials):
+
+* **Interactive tutorials** are authored and submitted as Python files.
+  The build system  converts these into Jupyter notebooks and HTML. The
+  code in these tutorials is run every time they are built. To keep
+  these tutorials up and running all their package dependencies need to
+  be resolved--which makes it more challenging to maintain this type of
+  tutorial.
+
+* **Non-interactive tutorials** are authored and submitted as
+  reStructuredText files. The build system only converts them into HTML;
+  the code in them does not run on build. These tutorials are easier to
+  create and maintain but they do not provide an interactive experience.
+
+
+* **Recipes** are tutorials that provide bite-sized, actionable
+  examples of how to use specific features, which differentiates them
+  from full-length tutorials. Recipes can be interactive or
+  non-interactive.
+
+
+# Managing data that is used by your tutorial
+
+Your tutorial might depend on external data, such as pre-trained models,
+training data, or test data. We recommend storing this data in a
+commonly-used storage service, such as Amazon S3, and instructing your
+users to download the data at the beginning of your tutorial.
+
+To download your data add a function to the [download.py](https://github.com/pytorch/tutorials/blob/main/.jenkins/download_data.py)
+script. Follow the same pattern as other download functions.
+Please do not add download logic to `Makefile` as it will incur download overhead for all CI shards.
+
+# Python packages used by your tutorial
+
+If your tutorial has dependencies that are not already defined in
+`requirements.txt`, you should add them to that file. We recommend that
+you use only mature, well-supported packages in your tutorial. Packages
+that are obscure or not well-maintained may break as a result of, for
+example, updates to Python or PyTorch or other packages. If your
+tutorial fails to build in our Continuous Integration (CI) system, we
+might contact you in order to resolve the issue.
+
+
+# Deprecation of tutorials
+
+Under some circumstances, we might deprecate--and subsequently
+archive--a tutorial removing it from the site. For example, if the
+tutorial breaks in our CI and we are not able to resolve the issue and
+are also not able to reach you, we might archive the tutorial. In these
+situations, resolving the breaking issue would normally be sufficient to
+make the tutorial available again.
+
+Another situation in which a tutorial might be deprecated is if it
+consistently receives low ratings--or low usage--by the community. Again,
+if this occurs, we will attempt to contact you.
+
+If we identify, or suspect, that your tutorial--or a package that your
+tutorial uses--has a **security or privacy** issue, we will immediately
+take the tutorial off the site.
+
+
+# Guidance for authoring tutorials and recipes
+
+In this section, we describe the process for creating tutorials and
+recipes for Pytorch.
+
+The first step is to decide which type of tutorial you want to create,
+taking into account how much support you can provide to keep the
+tutorial up-to-date. Ideally, your tutorial should demonstrate PyTorch
+functionality that is not duplicated in other tutorials.
+
+As described earlier, tutorials are resources that provide a holistic
+end-to-end understanding of how to use PyTorch. Recipes are scoped
+examples of how to use specific features; the goal of a recipe is to
+teach readers how to easily leverage features of PyTorch for their
+needs. Tutorials and recipes are always _actionable_. If the material is
+purely informative, consider adding it to the API docs instead.
+
+View our current [full-length tutorials](https://pytorch.org/tutorials/).
+
+To create actionable tutorials, start by identifying _learning
+objectives_, which are the end goals. Working backwards from these
+objectives will help to eliminate extraneous information.
+
+
+## Learning objectives ##
+
+To create the learning objectives, focus on what the user will
+implement. Set expectations by explicitly stating what the recipe will
+cover and what users will implement by the end. Here are some examples:
+
+- Create a custom dataset
+- Integrate a dataset using a library
+- Iterate over samples in the dataset
+- Apply a transform to the dataset
+
+
+## Voice and writing style ##
+
+Write for a global audience with an instructive and directive voice.
+
+- PyTorch has a global audience; use clear, easy to understand
+  language. Avoid idioms or other figures of speech.
+- To keep your instructions concise, use
+  [active voice](https://writing.wisc.edu/handbook/style/ccs_activevoice/) as much as possible.
+- For a short guide on the essentials of writing style,
+  [The Elements of Style](https://www.gutenberg.org/files/37134/37134-h/37134-h.htm)
+  is invaluable.
+- For extensive guidance on technical-writing style, the Google developer documentation
+  [google style](https://developers.google.com/style)
+  is a great resource.
+- Think of the process as similar to creating a (really practical)
+  Medium post.
+
+
+## Structure ##
+
+We recommend that tutorials use the following structure which guides users through the learning experience and provides appropriate context:
+
+1. Introduction
+1. Motivation: Why is this topic important?
+1. Link to relevant research papers or other background material.
+1. Learning objectives: Clearly state what the tutorial covers and what
+   users will implement by the end. For example: Provide a summary of
+   how the Integrated Gradients feature works and how to implement it
+   using Captum. The
+   [TensorBoard](https://pytorch.org/tutorials/intermediate/tensorboard_tutorial.html)
+   tutorial provides a good example of how to specify learning
+   objectives.
+1. Setup and requirements. Call out any required setup or data
+   downloads.
+1. Step-by-step instructions. Ideally, the steps in the tutorial should
+   map back to the learning objectives. Consider adding comments in the
+   code that correspond to these steps and that help to clarify what
+   each section of the code is doing.
+1. Link to relevant [PyTorch
+   documentation](https://pytorch.org/docs/stable/index.html). This
+   helps readers have context for the tutorial source code and better
+   understand how and why it implements the technique you’re
+   demonstrating.
+1. Recap/Conclusion: Summarize the steps and concepts covered. Highlight
+   key takeaways.
+1. (Optional) Additional practice exercises for users to test their
+   knowledge. An example is [NLP From Scratch: Generating Names with a
+   Character-Level RNN tutorial](https://pytorch.org/tutorials/intermediate/char_rnn_generation_tutorial.html#exercises).
+1. Additional resources for more learning, such as documentation, other
+   tutorials, or relevant research.
+
+
+## Example Tutorials ##
+
+The following tutorials do a good job of demonstrating the ideas
+described in the preceding sections:
+
+- [Chatbot Tutorial](https://pytorch.org/tutorials/beginner/chatbot_tutorial.html)
+- [Tensorboard Tutorial](https://pytorch.org/tutorials/intermediate/tensorboard_tutorial.html)
+- [NLP From Scratch: Generating Names with a Character-Level RNN
+Tutorial](https://pytorch.org/tutorials/intermediate/char_rnn_generation_tutorial.html)
+
+If you are creating a recipe, [this is a good
+example.](https://github.com/pytorch/tutorials/blob/main/recipes_source/recipes/what_is_state_dict.py)
+
+
+# Submission Process #
+
+Submit your tutorial as either a Python (`.py`) file or a
+reStructuredText (`.rst`) file. For Python files, the filename for your
+tutorial should end in "`_tutorial.py`"; for example,
+"`cool_pytorch_feature_tutorial.py`".
+
+Do not submit a Jupyter notebook. If you develop your tutorial in
+Jupyter, you'll need to convert it to Python. This
+[script](https://gist.github.com/chsasank/7218ca16f8d022e02a9c0deb94a310fe)
+is one option for performing this conversion.
+
+For Python files, our CI system runs your code during each build.
+
+
+## Add Your Tutorial Code ##
+
+1. [Fork and
+   clone](https://docs.github.com/en/get-started/quickstart/contributing-to-projects)
+   the repo:
+   [https://github.com/pytorch/tutorials](https://github.com/pytorch/tutorials)
+
+1. Put the tutorial in one of the
+   [`beginner_source`](https://github.com/pytorch/tutorials/tree/main/beginner_source),
+   [`intermediate_source`](https://github.com/pytorch/tutorials/tree/main/intermediate_source),
+   [`advanced_source`](https://github.com/pytorch/tutorials/tree/main/advanced_source)
+   based on the technical level of the content. For recipes, put the
+   recipe in
+   [`recipes_source`](https://github.com/pytorch/tutorials/tree/main/recipes_source).
+   In addition, for recipes, add the recipe in the recipes
+   [README.txt](https://github.com/pytorch/tutorials/blob/main/recipes_source/recipes/README.txt)
+   file.
+
+
+## Include Your Tutorial in `index.rst`#
+
+In order for your tutorial to appear on the website, and through tag
+search, you need to include it in `index.rst`, or for recipes, in
+`recipes_index.rst`.
+
+1. Open the relevant file
+   [`index.rst`](https://github.com/pytorch/tutorials/blob/main/index.rst)
+   or
+   [`recipes_index.rst`](https://github.com/pytorch/tutorials/blob/main/recipes_index.rst)
+1. Add a _card_ in reStructuredText format similar to the following:
+
+```
+.. customcarditem::
+   :header: Learn the Basics # Tutorial title
+   :card_description: A step-by-step guide to building a complete ML workflow with PyTorch.  # Short description
+   :image: _static/img/thumbnails/cropped/60-min-blitz.png  # Image that appears with the card
+   :link: beginner/basics/intro.html
+   :tags: Getting-Started
+```
+
+
+### Link ###
+
+The `link` should be the path to your tutorial in the source tree. For
+example, if the tutorial is in `beginner_source`, the link will be
+`beginner_source/rest/of/the/path.html`
+
+
+### Tags ###
+
+Choose tags from the existing tags in the file. Reach out to a project
+maintainer to create a new tag. The list of tags should not have any
+white space between the words. Multi-word tags, such as “Getting
+Started”, should be hyphenated: Getting-Started. Otherwise, the tutorial
+might fail to build, and the cards will not display properly.
+
+
+### Image ###
+
+Add a thumbnail to the
+[`_static/img/thumbnails/cropped`](https://github.com/pytorch/tutorials/tree/main/_static/img/thumbnails/cropped)
+directory. Images that render the best are square--that is, they have
+equal `x` and `y` dimensions--and also have high resolution. [Here is an
+example](https://github.com/pytorch/tutorials/blob/main/_static/img/thumbnails/cropped/loading-data.PNG).
+
+## `toctree` ##
+
+1. Add your tutorial under the corresponding toctree (also in
+   `index.rst`). For example, if you are adding a tutorial that
+   demonstrates the PyTorch ability to process images or video, add it
+   under `Image and Video`:
+
+```
+.. toctree::
+   :maxdepth: 2
+   :includehidden:
+   :hidden:
+   :caption: Image and Video
+
+   intermediate/torchvision_tutorial
+   beginner/my-new-tutorial
+```
+
+
+## Test Your Tutorial Locally ##
+
+The following command builds an HTML version of the tutorial website.
+
+```
+make html-noplot
+```
+
+This command does not run your tutorial code. To build the tutorial in a
+way that executes the code, use `make docs`. However, unless you have a
+GPU-powered machine and a proper PyTorch CUDA setup, running this `make`
+command locally won't work. The continuous integration (CI) system will
+test your tutorial when you submit your PR.
+
+
+## Submit the PR ##
+
+NOTE: Please do not use [ghstack](https://github.com/ezyang/ghstack). We
+do not support ghstack in the [`pytorch/tutorials`](https://github.com/pytorch/tutorials) repo.
+
+Submit the changes as a PR to the main branch of
+[`pytorch/tutorials`](https://github.com/pytorch/tutorials).
+
+1. Add your changes, commit, and push:
+
+    ```
+    git add -A
+    git commit -m "Add <mytutorial>"
+    git push --set-upstream mybranch
+    ```
+
+1. Submit the PR and tag individuals on the PyTorch project who can review
+   your PR.
+1. Address all feedback comments from your reviewers.
+1. Make sure all CI checks are passing.
+
+Once you submit your PR, you can see a generated Netlify preview of your
+build. You can see an example Netlify preview at the following URL:
+
+>  <https://deploy-preview-954--pytorch-tutorials-preview.netlify.app/>
+
+
+## Do not merge the PR yourself ##
+
+Please **DO NOT MERGE** your own PR; the tutorial won't be published. In order to avoid potential build breaks with the tutorials site, only certain maintainers can authorize publishing.
diff --git a/LICENSE b/LICENSE
index 1ba2484d469..338dffbfe74 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,6 +1,6 @@
 BSD 3-Clause License
 
-Copyright (c) 2017, Pytorch contributors
+Copyright (c) 2017-2022, Pytorch contributors
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
diff --git a/Makefile b/Makefile
index 6461fbb4243..7fcf1de6636 100644
--- a/Makefile
+++ b/Makefile
@@ -5,7 +5,7 @@
 export LC_ALL=C
 
 # You can set these variables from the command line.
-SPHINXOPTS    =
+SPHINXOPTS    ?=
 SPHINXBUILD   = sphinx-build
 SPHINXPROJ    = PyTorchTutorials
 SOURCEDIR     = .
@@ -13,6 +13,9 @@ BUILDDIR      = _build
 DATADIR       = _data
 GH_PAGES_SOURCES = $(SOURCEDIR) Makefile
 
+ZIPOPTS       ?= -qo
+TAROPTS       ?=
+
 # Put it first so that "make" without argument is like "make help".
 help:
 	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
@@ -30,30 +33,19 @@ download:
 
 	# NOTE: Please consider using the Step1 and one of Step2 for new dataset,
 	# [something] should be replaced with the actual value.
-	# Step1. DOWNLOAD: wget -N [SOURCE_FILE] -P $(DATADIR)
+	# Step1. DOWNLOAD: wget -nv -N [SOURCE_FILE] -P $(DATADIR)
 	# Step2-1. UNZIP: unzip -o $(DATADIR)/[SOURCE_FILE] -d [*_source/data/]
 	# Step2-2. UNTAR: tar -xzf $(DATADIR)/[SOURCE_FILE] -C [*_source/data/]
 	# Step2-3. AS-IS: cp $(DATADIR)/[SOURCE_FILE] [*_source/data/]
 
-	# make data directories
-	mkdir -p $(DATADIR)
-	mkdir -p advanced_source/data
-	mkdir -p beginner_source/data
-	mkdir -p intermediate_source/data
-
-	# transfer learning tutorial data
-	wget -N https://download.pytorch.org/tutorial/hymenoptera_data.zip -P $(DATADIR)
-	unzip -o $(DATADIR)/hymenoptera_data.zip -d beginner_source/data/
-
-	# nlp tutorial data
-	wget -N https://download.pytorch.org/tutorial/data.zip -P $(DATADIR)
-	unzip -o $(DATADIR)/data.zip -d intermediate_source/  # This will unzip all files in data.zip to intermediate_source/data/ folder
+	# Run structured downloads first (will also make directories
+	python3 .jenkins/download_data.py
 
 	# data loader tutorial
-	wget -N https://download.pytorch.org/tutorial/faces.zip -P $(DATADIR)
-	unzip -o $(DATADIR)/faces.zip -d beginner_source/data/
+	wget -nv -N https://download.pytorch.org/tutorial/faces.zip -P $(DATADIR)
+	unzip $(ZIPOPTS) $(DATADIR)/faces.zip -d beginner_source/data/
 
-	wget -N https://download.pytorch.org/models/tutorials/4000_checkpoint.tar -P $(DATADIR)
+	wget -nv -N https://download.pytorch.org/models/tutorials/4000_checkpoint.tar -P $(DATADIR)
 	cp $(DATADIR)/4000_checkpoint.tar beginner_source/data/
 
 	# neural style images
@@ -61,39 +53,44 @@ download:
 	mkdir -p advanced_source/data/images/
 	cp -r _static/img/neural-style/ advanced_source/data/images/
 
-	# Download dataset for beginner_source/dcgan_faces_tutorial.py
-	wget -N https://s3.amazonaws.com/pytorch-tutorial-assets/img_align_celeba.zip -P $(DATADIR)
-	unzip -q -o $(DATADIR)/img_align_celeba.zip -d beginner_source/data/celeba
-
 	# Download dataset for beginner_source/hybrid_frontend/introduction_to_hybrid_frontend_tutorial.py
-	wget -N https://s3.amazonaws.com/pytorch-tutorial-assets/iris.data -P $(DATADIR)
+	wget -nv -N https://s3.amazonaws.com/pytorch-tutorial-assets/iris.data -P $(DATADIR)
 	cp $(DATADIR)/iris.data beginner_source/data/
 
 	# Download dataset for beginner_source/chatbot_tutorial.py
-	wget -N https://s3.amazonaws.com/pytorch-tutorial-assets/cornell_movie_dialogs_corpus.zip -P $(DATADIR)
-	unzip -q -o $(DATADIR)/cornell_movie_dialogs_corpus.zip -d beginner_source/data/
-
-	# Download dataset for beginner_source/audio_classifier_tutorial.py
-	wget -N https://s3.amazonaws.com/pytorch-tutorial-assets/UrbanSound8K.tar.gz -P $(DATADIR)
-	tar -xzf $(DATADIR)/UrbanSound8K.tar.gz -C ./beginner_source/data/
+	wget -nv -N https://s3.amazonaws.com/pytorch-tutorial-assets/cornell_movie_dialogs_corpus_v2.zip -P $(DATADIR)
+	unzip $(ZIPOPTS) $(DATADIR)/cornell_movie_dialogs_corpus_v2.zip -d beginner_source/data/
 
-	# Download model for beginner_source/fgsm_tutorial.py
-	wget -N https://s3.amazonaws.com/pytorch-tutorial-assets/lenet_mnist_model.pth -P $(DATADIR)
-	cp $(DATADIR)/lenet_mnist_model.pth ./beginner_source/data/lenet_mnist_model.pth
+	# 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/
 
+download-last-reviewed-json:
+	@echo "Downloading tutorials-review-data.json..."
+	curl -o tutorials-review-data.json https://raw.githubusercontent.com/pytorch/tutorials/refs/heads/last-reviewed-data-json/tutorials-review-data.json
+	@echo "Finished downloading tutorials-review-data.json."
 docs:
 	make download
+	make download-last-reviewed-json
 	make html
+	@python .jenkins/insert_last_verified.py $(BUILDDIR)/html
 	rm -rf docs
 	cp -r $(BUILDDIR)/html docs
 	touch docs/.nojekyll
+	rm -rf tutorials-review-data.json
 
 html-noplot:
 	$(SPHINXBUILD) -D plot_gallery=0 -b html $(SPHINXOPTS) "$(SOURCEDIR)" "$(BUILDDIR)/html"
-	bash .jenkins/remove_invisible_code_block_batch.sh "$(BUILDDIR)/html"
+	# bash .jenkins/remove_invisible_code_block_batch.sh "$(BUILDDIR)/html"
 	@echo
+	make download-last-reviewed-json
 	@echo "Build finished. The HTML pages are in $(BUILDDIR)/html."
+	@echo "Running post-processing script to insert 'Last Verified' dates..."
+	@python .jenkins/insert_last_verified.py $(BUILDDIR)/html
+	rm -rf tutorials-review-data.json
 
 clean-cache:
 	make clean
-	rm -rf advanced beginner intermediate
+	rm -rf advanced beginner intermediate recipes
+	# remove additional python files downloaded for torchvision_tutorial.py
+	rm -rf intermediate_source/engine.py intermediate_source/utils.py intermediate_source/transforms.py intermediate_source/coco_eval.py intermediate_source/coco_utils.py
diff --git a/README.md b/README.md
index f3e16646f55..3b858a3882b 100644
--- a/README.md
+++ b/README.md
@@ -5,25 +5,75 @@ All the tutorials are now presented as sphinx style documentation at:
 
 ## [https://pytorch.org/tutorials](https://pytorch.org/tutorials)
 
+# Asking a question
 
+If you have a question about a tutorial, post in https://dev-discuss.pytorch.org/ rather than creating an issue in this repo. Your question will be answered much faster on the dev-discuss forum.
+
+# Submitting an issue
+
+You can submit the following types of issues:
+
+* Feature request - request a new tutorial to be added. Please explain why this tutorial is needed and how it demonstrates PyTorch value.
+* Bug report - report a failure or outdated information in an existing tutorial. When submitting a bug report, please run: `python3 -m torch.utils.collect_env` to get information about your environment and add the output to the bug report.
 
 # Contributing
 
-We use sphinx-gallery's [notebook styled examples](https://sphinx-gallery.github.io/tutorials/plot_notebook.html#sphx-glr-tutorials-plot-notebook-py) to create the tutorials. Syntax is very simple. In essence, you write a slightly well formatted python file and it shows up as documentation page.
+We use sphinx-gallery's [notebook styled examples](https://sphinx-gallery.github.io/stable/tutorials/index.html) to create the tutorials. Syntax is very simple. In essence, you write a slightly well formatted Python file and it shows up as an HTML page. In addition, a Jupyter notebook is autogenerated and available to run in Google Colab.
+
+Here is how you can create a new tutorial (for a detailed description, see [CONTRIBUTING.md](./CONTRIBUTING.md)):
+
+NOTE: Before submitting a new tutorial, read [PyTorch Tutorial Submission Policy](./tutorial_submission_policy.md).
 
-Here's how to create a new tutorial:
-1. Create a notebook styled python file. If you want it executed while inserted into documentation, save the file with suffix `tutorial` so that file name is `your_tutorial.py`.
-2. Put it in one of the beginner_source, intermediate_source, advanced_source based on the level.
-2. Include it in the right TOC tree at index.rst
-3. Create a thumbnail in the index file using a command like `.. galleryitem:: beginner/your_tutorial.py`. (This is a custom directive. See `custom_directives.py` for more info.) 
+1. Create a Python file. If you want it executed while inserted into documentation, save the file with the suffix `tutorial` so that the file name is `your_tutorial.py`.
+2. Put it in one of the `beginner_source`, `intermediate_source`, `advanced_source` directory based on the level of difficulty. If it is a recipe, add it to `recipes_source`. For tutorials demonstrating unstable prototype features, add to the `prototype_source`.
+3. For Tutorials (except if it is a prototype feature), include it in the `toctree` directive and create a `customcarditem` in [index.rst](./index.rst).
+4. For Tutorials (except if it is a prototype feature), create a thumbnail in the [index.rst file](https://github.com/pytorch/tutorials/blob/main/index.rst) using a command like `.. customcarditem:: beginner/your_tutorial.html`. For Recipes, create a thumbnail in the [recipes_index.rst](https://github.com/pytorch/tutorials/blob/main/recipes_index.rst)
 
-In case you prefer to write your tutorial in jupyter, you can use [this script](https://gist.github.com/chsasank/7218ca16f8d022e02a9c0deb94a310fe) to convert the notebook to python file. After conversion and addition to the project, please make sure the sections headings etc are in logical order.
+If you are starting off with a Jupyter notebook, you can use [this script](https://gist.github.com/chsasank/7218ca16f8d022e02a9c0deb94a310fe) to convert the notebook to Python file. After conversion and addition to the project, please make sure that section headings and other things are in logical order.
 
-## Building
+## Building locally
 
-- Start with installing torch, torchvision, and your GPUs latest drivers. Install other requirements using `pip install -r requirements.txt`
+The tutorial build is very large and requires a GPU. If your machine does not have a GPU device, you can preview your HTML build without actually downloading the data and running the tutorial code:
 
-> If you want to use `virtualenv`, make your environment in a `venv` directory like: `virtualenv ./venv`, then `source ./venv/bin/activate`.
+1. Install required dependencies by running: `pip install -r requirements.txt`.
 
-- Then you can build using `make docs`. This will download the data, execute the tutorials and build the documentation to `docs/` directory. This will take about 60-120 min for systems with GPUs. If you do not have a GPU installed on your system, then see next step.
+> Typically, you would run either in `conda` or `virtualenv`. If you want to use `virtualenv`, in the root of the repo, run: `virtualenv venv`, then `source venv/bin/activate`.
+
+- If you have a GPU-powered laptop, you can build using `make docs`. This will download the data, execute the tutorials and build the documentation to `docs/` directory. This might take about 60-120 min for systems with GPUs. If you do not have a GPU installed on your system, then see next step.
 - You can skip the computationally intensive graph generation by running `make html-noplot` to build basic html documentation to `_build/html`. This way, you can quickly preview your tutorial.
+
+## Building a single tutorial
+
+You can build a single tutorial by using the `GALLERY_PATTERN` environment variable. For example to run only `neural_style_transfer_tutorial.py`, run:
+
+```
+GALLERY_PATTERN="neural_style_transfer_tutorial.py" make html
+```
+or
+
+```
+GALLERY_PATTERN="neural_style_transfer_tutorial.py" sphinx-build . _build
+```
+
+The `GALLERY_PATTERN` variable respects regular expressions.
+
+## Spell Check
+You can run pyspelling to check for spelling errors in the tutorials. To check only Python files, run pyspelling -n python. To check only .rst files, use pyspelling -n reST. Currently, .rst spell checking is limited to the beginner/ directory. Contributions to enable spell checking in other directories are welcome!
+
+
+```
+pyspelling          # full check (~3 mins)
+pyspelling -n python  # Python files only
+pyspelling -n reST    # reST files (only beginner/ dir currently included)
+```
+
+
+## About contributing to PyTorch Documentation and Tutorials
+* You can find information about contributing to PyTorch documentation in the
+PyTorch Repo [README.md](https://github.com/pytorch/pytorch/blob/master/README.md) file.
+* Additional information can be found in [PyTorch CONTRIBUTING.md](https://github.com/pytorch/pytorch/blob/master/CONTRIBUTING.md).
+
+
+## License
+
+PyTorch Tutorials is BSD licensed, as found in the LICENSE file.
diff --git a/_static/css/custom.css b/_static/css/custom.css
new file mode 100755
index 00000000000..a0882c1d4fc
--- /dev/null
+++ b/_static/css/custom.css
@@ -0,0 +1,97 @@
+/* sphinx-design styles for cards/tabs
+*/
+
+:root {
+    --sd-color-info: #ee4c2c;
+    --sd-color-primary: #6c6c6d;
+    --sd-color-primary-highlight: #f3f4f7;
+    --sd-color-card-border-hover: #ee4c2c;
+    --sd-color-card-border: #f3f4f7;
+    --sd-color-card-background: #fff;
+    --sd-color-card-text: inherit;
+    --sd-color-card-header: transparent;
+    --sd-color-card-footer: transparent;
+    --sd-color-tabs-label-active: hsla(231, 99%, 66%, 1);
+    --sd-color-tabs-label-hover: hsla(231, 99%, 66%, 1);
+    --sd-color-tabs-label-inactive: hsl(0, 0%, 66%);
+    --sd-color-tabs-underline-active: hsla(231, 99%, 66%, 1);
+    --sd-color-tabs-underline-hover: rgba(178, 206, 245, 0.62);
+    --sd-color-tabs-underline-inactive: transparent;
+    --sd-color-tabs-overline: rgb(222, 222, 222);
+    --sd-color-tabs-underline: rgb(222, 222, 222);
+}
+
+.sd-text-info {
+    color: #ee4c2c;
+}
+
+
+.sd-card {
+    position: relative;
+    background-color: #fff;
+    opacity: 1.0;
+    border-radius: 0px;
+    width: 30%;
+    border: none;
+    padding-bottom: 0px;
+}
+
+
+.sd-card-img {
+    opacity: 0.5;
+    width: 200px;
+    padding: 0px;
+}
+
+.sd-card-img:hover {
+    opacity: 1.0;
+    background-color: #f3f4f7;
+}
+
+
+.sd-card:after {
+    display: block;
+    opacity: 1;
+    content: '';
+    border-bottom: solid 1px #ee4c2c;  
+    background-color: #fff;
+    transform: scaleX(0);  
+    transition: transform .250s ease-in-out;
+    transform-origin:  0% 50%;
+}
+
+.sd-card:hover {
+    background-color: #fff;
+    opacity: 1;
+    border-top: 1px solid #f3f4f7;
+    border-left: 1px solid #f3f4f7;
+    border-right: 1px solid #f3f4f7;
+}
+
+.sd-card:hover:after {
+    transform: scaleX(1);
+}
+
+.card-prerequisites:hover {
+    transition: none;
+    border: none;
+}
+
+.card-prerequisites:hover:after {
+    transition: none;
+    transform: none;
+}
+
+.card-prerequisites:after {
+    display: block;
+    content: '';
+    border-bottom: none;
+    background-color: #fff;
+    transform: none;
+    transition: none;
+    transform-origin: none;
+}
+
+.pytorch-left-menu-search input[type=text] {
+    background-image: url("../images/search-icon.svg");
+}
diff --git a/_static/css/custom2.css b/_static/css/custom2.css
new file mode 100644
index 00000000000..a24ee796872
--- /dev/null
+++ b/_static/css/custom2.css
@@ -0,0 +1,112 @@
+/* Survey banner .css */
+
+.survey-banner {
+  margin-top: 10px;
+  background-color: #f3f4f7;
+  padding-top: 15px;
+  padding-left: 10px;
+  padding-bottom: 1px;
+}
+
+@media screen and (max-width: 600px) {
+  .survey-banner {
+    padding-top: 5px;
+    padding-left: 5px;
+    padding-bottom: -1px;
+    font-size: 12px;
+    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: "";
+}
+
+/* search radio button*/
+
+input[type="radio"] {
+    accent-color: #ee4c2c;
+}
+
+.gsst_b {
+    display: none;
+}
+
+#gsc-i-id1 {
+    height: 1.5rem;
+    text-indent: 12px !important; 
+    font-size: 1rem !important;
+    font-family: "FreightSansi";
+    background-image: url(../images/search-icon.svg) !important;
+    background-repeat: no-repeat !important;
+    background-size: 18px 18px !important;
+    background-position: 5px 0px !important;
+    padding-left: 20px !important;
+}
+
+#gsc-i-id1::placeholder {
+  font-family: 'FreightSans';
+  font-size: 1rem;
+  color: #262626;
+}
+
+.gsc-control-cse {
+   padding: 0 !important;
+   border-radius: 0px !important;
+   border: none !important;
+}
+
+.gsc-overflow-hidden {
+  overflow: visible !important;
+}
+
+#___gcse_0 {
+    height: 44px !important;
+    padding: 0 !important;
+}
+
+table.gsc-search-box td.gsc-input {
+    padding-right: 0 !important;
+}
+
+table.gsc-search-box td {
+    height: 44px;
+    margin-bottom: 0 !important;
+    padding-bottom: 0 !important;
+}
+
+.gsc-search-button-v2 {
+    display: none;
+}
+
+.gs_id50 {
+    width: 308px;
+}
+
+.gsib_a {
+    padding: 0px 8px 4px 9px !important;
+}
+
+.gsc-input-box {
+    border-radius: 0px !important;
+    border: none !important; 
+}
+
+form.gsc-search-box {
+    margin-bottom 0px;
+}
+
diff --git a/_static/doctools.js b/_static/doctools.js
deleted file mode 100755
index 6d984d66d2e..00000000000
--- a/_static/doctools.js
+++ /dev/null
@@ -1,313 +0,0 @@
-/*
- * doctools.js
- * ~~~~~~~~~~~
- *
- * Sphinx JavaScript utilities for all documentation.
- *
- * :copyright: Copyright 2007-2018 by the Sphinx team, see AUTHORS.
- * :license: BSD, see LICENSE for details.
- *
- */
-
-/**
- * select a different prefix for underscore
- */
-$u = _.noConflict();
-
-/**
- * make the code below compatible with browsers without
- * an installed firebug like debugger
-if (!window.console || !console.firebug) {
-  var names = ["log", "debug", "info", "warn", "error", "assert", "dir",
-    "dirxml", "group", "groupEnd", "time", "timeEnd", "count", "trace",
-    "profile", "profileEnd"];
-  window.console = {};
-  for (var i = 0; i < names.length; ++i)
-    window.console[names[i]] = function() {};
-}
- */
-
-/**
- * small helper function to urldecode strings
- */
-jQuery.urldecode = function(x) {
-  return decodeURIComponent(x).replace(/\+/g, ' ');
-};
-
-/**
- * small helper function to urlencode strings
- */
-jQuery.urlencode = encodeURIComponent;
-
-/**
- * This function returns the parsed url parameters of the
- * current request. Multiple values per key are supported,
- * it will always return arrays of strings for the value parts.
- */
-jQuery.getQueryParameters = function(s) {
-  if (typeof s === 'undefined')
-    s = document.location.search;
-  var parts = s.substr(s.indexOf('?') + 1).split('&');
-  var result = {};
-  for (var i = 0; i < parts.length; i++) {
-    var tmp = parts[i].split('=', 2);
-    var key = jQuery.urldecode(tmp[0]);
-    var value = jQuery.urldecode(tmp[1]);
-    if (key in result)
-      result[key].push(value);
-    else
-      result[key] = [value];
-  }
-  return result;
-};
-
-/**
- * highlight a given string on a jquery object by wrapping it in
- * span elements with the given class name.
- */
-jQuery.fn.highlightText = function(text, className) {
-  function highlight(node, addItems) {
-    if (node.nodeType === 3) {
-      var val = node.nodeValue;
-      var pos = val.toLowerCase().indexOf(text);
-      if (pos >= 0 &&
-          !jQuery(node.parentNode).hasClass(className) &&
-          !jQuery(node.parentNode).hasClass("nohighlight")) {
-        var span;
-        var isInSVG = jQuery(node).closest("body, svg, foreignObject").is("svg");
-        if (isInSVG) {
-          span = document.createElementNS("https://www.w3.org/2000/svg", "tspan");
-        } else {
-          span = document.createElement("span");
-          span.className = className;
-        }
-        span.appendChild(document.createTextNode(val.substr(pos, text.length)));
-        node.parentNode.insertBefore(span, node.parentNode.insertBefore(
-          document.createTextNode(val.substr(pos + text.length)),
-          node.nextSibling));
-        node.nodeValue = val.substr(0, pos);
-        if (isInSVG) {
-          var bbox = span.getBBox();
-          var rect = document.createElementNS("https://www.w3.org/2000/svg", "rect");
-       	  rect.x.baseVal.value = bbox.x;
-          rect.y.baseVal.value = bbox.y;
-          rect.width.baseVal.value = bbox.width;
-          rect.height.baseVal.value = bbox.height;
-          rect.setAttribute('class', className);
-          var parentOfText = node.parentNode.parentNode;
-          addItems.push({
-              "parent": node.parentNode,
-              "target": rect});
-        }
-      }
-    }
-    else if (!jQuery(node).is("button, select, textarea")) {
-      jQuery.each(node.childNodes, function() {
-        highlight(this, addItems);
-      });
-    }
-  }
-  var addItems = [];
-  var result = this.each(function() {
-    highlight(this, addItems);
-  });
-  for (var i = 0; i < addItems.length; ++i) {
-    jQuery(addItems[i].parent).before(addItems[i].target);
-  }
-  return result;
-};
-
-/*
- * backward compatibility for jQuery.browser
- * This will be supported until firefox bug is fixed.
- */
-if (!jQuery.browser) {
-  jQuery.uaMatch = function(ua) {
-    ua = ua.toLowerCase();
-
-    var match = /(chrome)[ \/]([\w.]+)/.exec(ua) ||
-      /(webkit)[ \/]([\w.]+)/.exec(ua) ||
-      /(opera)(?:.*version|)[ \/]([\w.]+)/.exec(ua) ||
-      /(msie) ([\w.]+)/.exec(ua) ||
-      ua.indexOf("compatible") < 0 && /(mozilla)(?:.*? rv:([\w.]+)|)/.exec(ua) ||
-      [];
-
-    return {
-      browser: match[ 1 ] || "",
-      version: match[ 2 ] || "0"
-    };
-  };
-  jQuery.browser = {};
-  jQuery.browser[jQuery.uaMatch(navigator.userAgent).browser] = true;
-}
-
-/**
- * Small JavaScript module for the documentation.
- */
-var Documentation = {
-
-  init : function() {
-    this.fixFirefoxAnchorBug();
-    this.highlightSearchWords();
-    this.initIndexTable();
-    
-  },
-
-  /**
-   * i18n support
-   */
-  TRANSLATIONS : {},
-  PLURAL_EXPR : function(n) { return n === 1 ? 0 : 1; },
-  LOCALE : 'unknown',
-
-  // gettext and ngettext don't access this so that the functions
-  // can safely bound to a different name (_ = Documentation.gettext)
-  gettext : function(string) {
-    var translated = Documentation.TRANSLATIONS[string];
-    if (typeof translated === 'undefined')
-      return string;
-    return (typeof translated === 'string') ? translated : translated[0];
-  },
-
-  ngettext : function(singular, plural, n) {
-    var translated = Documentation.TRANSLATIONS[singular];
-    if (typeof translated === 'undefined')
-      return (n == 1) ? singular : plural;
-    return translated[Documentation.PLURALEXPR(n)];
-  },
-
-  addTranslations : function(catalog) {
-    for (var key in catalog.messages)
-      this.TRANSLATIONS[key] = catalog.messages[key];
-    this.PLURAL_EXPR = new Function('n', 'return +(' + catalog.plural_expr + ')');
-    this.LOCALE = catalog.locale;
-  },
-
-  /**
-   * add context elements like header anchor links
-   */
-  addContextElements : function() {
-    $('div[id] > :header:first').each(function() {
-      $('<a class="headerlink">\u00B6</a>').
-      attr('href', '#' + this.id).
-      attr('title', _('Permalink to this headline')).
-      appendTo(this);
-    });
-    $('dt[id]').each(function() {
-      $('<a class="headerlink">\u00B6</a>').
-      attr('href', '#' + this.id).
-      attr('title', _('Permalink to this definition')).
-      appendTo(this);
-    });
-  },
-
-  /**
-   * workaround a firefox stupidity
-   * see: https://bugzilla.mozilla.org/show_bug.cgi?id=645075
-   */
-  fixFirefoxAnchorBug : function() {
-    if (document.location.hash && $.browser.mozilla)
-      window.setTimeout(function() {
-        document.location.href += '';
-      }, 10);
-  },
-
-  /**
-   * highlight the search words provided in the url in the text
-   */
-  highlightSearchWords : function() {
-    var params = $.getQueryParameters();
-    var terms = (params.highlight) ? params.highlight[0].split(/\s+/) : [];
-    if (terms.length) {
-      var body = $('div.body');
-      if (!body.length) {
-        body = $('body');
-      }
-      window.setTimeout(function() {
-        $.each(terms, function() {
-          body.highlightText(this.toLowerCase(), 'highlighted');
-        });
-      }, 10);
-      $('<p class="highlight-link"><a href="javascript:Documentation.' +
-        'hideSearchWords()">' + _('Hide Search Matches') + '</a></p>')
-          .appendTo($('#searchbox'));
-    }
-  },
-
-  /**
-   * init the domain index toggle buttons
-   */
-  initIndexTable : function() {
-    var togglers = $('img.toggler').click(function() {
-      var src = $(this).attr('src');
-      var idnum = $(this).attr('id').substr(7);
-      $('tr.cg-' + idnum).toggle();
-      if (src.substr(-9) === 'minus.png')
-        $(this).attr('src', src.substr(0, src.length-9) + 'plus.png');
-      else
-        $(this).attr('src', src.substr(0, src.length-8) + 'minus.png');
-    }).css('display', '');
-    if (DOCUMENTATION_OPTIONS.COLLAPSE_INDEX) {
-        togglers.click();
-    }
-  },
-
-  /**
-   * helper function to hide the search marks again
-   */
-  hideSearchWords : function() {
-    $('#searchbox .highlight-link').fadeOut(300);
-    $('span.highlighted').removeClass('highlighted');
-  },
-
-  /**
-   * make the url absolute
-   */
-  makeURL : function(relativeURL) {
-    return DOCUMENTATION_OPTIONS.URL_ROOT + '/' + relativeURL;
-  },
-
-  /**
-   * get the current relative url
-   */
-  getCurrentURL : function() {
-    var path = document.location.pathname;
-    var parts = path.split(/\//);
-    $.each(DOCUMENTATION_OPTIONS.URL_ROOT.split(/\//), function() {
-      if (this === '..')
-        parts.pop();
-    });
-    var url = parts.join('/');
-    return path.substring(url.lastIndexOf('/') + 1, path.length - 1);
-  },
-
-  initOnKeyListeners: function() {
-    $(document).keyup(function(event) {
-      var activeElementType = document.activeElement.tagName;
-      // don't navigate when in search box or textarea
-      if (activeElementType !== 'TEXTAREA' && activeElementType !== 'INPUT' && activeElementType !== 'SELECT') {
-        switch (event.keyCode) {
-          case 37: // left
-            var prevHref = $('link[rel="prev"]').prop('href');
-            if (prevHref) {
-              window.location.href = prevHref;
-              return false;
-            }
-          case 39: // right
-            var nextHref = $('link[rel="next"]').prop('href');
-            if (nextHref) {
-              window.location.href = nextHref;
-              return false;
-            }
-        }
-      }
-    });
-  }
-};
-
-// quick alias for translations
-_ = Documentation.gettext;
-
-$(document).ready(function() {
-  Documentation.init();
-});
\ No newline at end of file
diff --git a/_static/documentation_options.js b/_static/documentation_options.js
deleted file mode 100755
index a9214d61b9c..00000000000
--- a/_static/documentation_options.js
+++ /dev/null
@@ -1,9 +0,0 @@
-var DOCUMENTATION_OPTIONS = {
-    URL_ROOT: document.getElementById("documentation_options").getAttribute('data-url_root'),
-    VERSION: '0.5.0a0+a24163a',
-    LANGUAGE: 'None',
-    COLLAPSE_INDEX: false,
-    FILE_SUFFIX: '.html',
-    HAS_SOURCE: true,
-    SOURCELINK_SUFFIX: '.txt'
-};
\ No newline at end of file
diff --git a/_static/imagenet_class_index.json b/_static/imagenet_class_index.json
new file mode 100644
index 00000000000..5fe0dfefcd3
--- /dev/null
+++ b/_static/imagenet_class_index.json
@@ -0,0 +1 @@
+{"0": ["n01440764", "tench"], "1": ["n01443537", "goldfish"], "2": ["n01484850", "great_white_shark"], "3": ["n01491361", "tiger_shark"], "4": ["n01494475", "hammerhead"], "5": ["n01496331", "electric_ray"], "6": ["n01498041", "stingray"], "7": ["n01514668", "cock"], "8": ["n01514859", "hen"], "9": ["n01518878", "ostrich"], "10": ["n01530575", "brambling"], "11": ["n01531178", "goldfinch"], "12": ["n01532829", "house_finch"], "13": ["n01534433", "junco"], "14": ["n01537544", "indigo_bunting"], "15": ["n01558993", "robin"], "16": ["n01560419", "bulbul"], "17": ["n01580077", "jay"], "18": ["n01582220", "magpie"], "19": ["n01592084", "chickadee"], "20": ["n01601694", "water_ouzel"], "21": ["n01608432", "kite"], "22": ["n01614925", "bald_eagle"], "23": ["n01616318", "vulture"], "24": ["n01622779", "great_grey_owl"], "25": ["n01629819", "European_fire_salamander"], "26": ["n01630670", "common_newt"], "27": ["n01631663", "eft"], "28": ["n01632458", "spotted_salamander"], "29": ["n01632777", "axolotl"], "30": ["n01641577", "bullfrog"], "31": ["n01644373", "tree_frog"], "32": ["n01644900", "tailed_frog"], "33": ["n01664065", "loggerhead"], "34": ["n01665541", "leatherback_turtle"], "35": ["n01667114", "mud_turtle"], "36": ["n01667778", "terrapin"], "37": ["n01669191", "box_turtle"], "38": ["n01675722", "banded_gecko"], "39": ["n01677366", "common_iguana"], "40": ["n01682714", "American_chameleon"], "41": ["n01685808", "whiptail"], "42": ["n01687978", "agama"], "43": ["n01688243", "frilled_lizard"], "44": ["n01689811", "alligator_lizard"], "45": ["n01692333", "Gila_monster"], "46": ["n01693334", "green_lizard"], "47": ["n01694178", "African_chameleon"], "48": ["n01695060", "Komodo_dragon"], "49": ["n01697457", "African_crocodile"], "50": ["n01698640", "American_alligator"], "51": ["n01704323", "triceratops"], "52": ["n01728572", "thunder_snake"], "53": ["n01728920", "ringneck_snake"], "54": ["n01729322", "hognose_snake"], "55": ["n01729977", "green_snake"], "56": ["n01734418", "king_snake"], "57": ["n01735189", "garter_snake"], "58": ["n01737021", "water_snake"], "59": ["n01739381", "vine_snake"], "60": ["n01740131", "night_snake"], "61": ["n01742172", "boa_constrictor"], "62": ["n01744401", "rock_python"], "63": ["n01748264", "Indian_cobra"], "64": ["n01749939", "green_mamba"], "65": ["n01751748", "sea_snake"], "66": ["n01753488", "horned_viper"], "67": ["n01755581", "diamondback"], "68": ["n01756291", "sidewinder"], "69": ["n01768244", "trilobite"], "70": ["n01770081", "harvestman"], "71": ["n01770393", "scorpion"], "72": ["n01773157", "black_and_gold_garden_spider"], "73": ["n01773549", "barn_spider"], "74": ["n01773797", "garden_spider"], "75": ["n01774384", "black_widow"], "76": ["n01774750", "tarantula"], "77": ["n01775062", "wolf_spider"], "78": ["n01776313", "tick"], "79": ["n01784675", "centipede"], "80": ["n01795545", "black_grouse"], "81": ["n01796340", "ptarmigan"], "82": ["n01797886", "ruffed_grouse"], "83": ["n01798484", "prairie_chicken"], "84": ["n01806143", "peacock"], "85": ["n01806567", "quail"], "86": ["n01807496", "partridge"], "87": ["n01817953", "African_grey"], "88": ["n01818515", "macaw"], "89": ["n01819313", "sulphur-crested_cockatoo"], "90": ["n01820546", "lorikeet"], "91": ["n01824575", "coucal"], "92": ["n01828970", "bee_eater"], "93": ["n01829413", "hornbill"], "94": ["n01833805", "hummingbird"], "95": ["n01843065", "jacamar"], "96": ["n01843383", "toucan"], "97": ["n01847000", "drake"], "98": ["n01855032", "red-breasted_merganser"], "99": ["n01855672", "goose"], "100": ["n01860187", "black_swan"], "101": ["n01871265", "tusker"], "102": ["n01872401", "echidna"], "103": ["n01873310", "platypus"], "104": ["n01877812", "wallaby"], "105": ["n01882714", "koala"], "106": ["n01883070", "wombat"], "107": ["n01910747", "jellyfish"], "108": ["n01914609", "sea_anemone"], "109": ["n01917289", "brain_coral"], "110": ["n01924916", "flatworm"], "111": ["n01930112", "nematode"], "112": ["n01943899", "conch"], "113": ["n01944390", "snail"], "114": ["n01945685", "slug"], "115": ["n01950731", "sea_slug"], "116": ["n01955084", "chiton"], "117": ["n01968897", "chambered_nautilus"], "118": ["n01978287", "Dungeness_crab"], "119": ["n01978455", "rock_crab"], "120": ["n01980166", "fiddler_crab"], "121": ["n01981276", "king_crab"], "122": ["n01983481", "American_lobster"], "123": ["n01984695", "spiny_lobster"], "124": ["n01985128", "crayfish"], "125": ["n01986214", "hermit_crab"], "126": ["n01990800", "isopod"], "127": ["n02002556", "white_stork"], "128": ["n02002724", "black_stork"], "129": ["n02006656", "spoonbill"], "130": ["n02007558", "flamingo"], "131": ["n02009229", "little_blue_heron"], "132": ["n02009912", "American_egret"], "133": ["n02011460", "bittern"], "134": ["n02012849", "crane"], "135": ["n02013706", "limpkin"], "136": ["n02017213", "European_gallinule"], "137": ["n02018207", "American_coot"], "138": ["n02018795", "bustard"], "139": ["n02025239", "ruddy_turnstone"], "140": ["n02027492", "red-backed_sandpiper"], "141": ["n02028035", "redshank"], "142": ["n02033041", "dowitcher"], "143": ["n02037110", "oystercatcher"], "144": ["n02051845", "pelican"], "145": ["n02056570", "king_penguin"], "146": ["n02058221", "albatross"], "147": ["n02066245", "grey_whale"], "148": ["n02071294", "killer_whale"], "149": ["n02074367", "dugong"], "150": ["n02077923", "sea_lion"], "151": ["n02085620", "Chihuahua"], "152": ["n02085782", "Japanese_spaniel"], "153": ["n02085936", "Maltese_dog"], "154": ["n02086079", "Pekinese"], "155": ["n02086240", "Shih-Tzu"], "156": ["n02086646", "Blenheim_spaniel"], "157": ["n02086910", "papillon"], "158": ["n02087046", "toy_terrier"], "159": ["n02087394", "Rhodesian_ridgeback"], "160": ["n02088094", "Afghan_hound"], "161": ["n02088238", "basset"], "162": ["n02088364", "beagle"], "163": ["n02088466", "bloodhound"], "164": ["n02088632", "bluetick"], "165": ["n02089078", "black-and-tan_coonhound"], "166": ["n02089867", "Walker_hound"], "167": ["n02089973", "English_foxhound"], "168": ["n02090379", "redbone"], "169": ["n02090622", "borzoi"], "170": ["n02090721", "Irish_wolfhound"], "171": ["n02091032", "Italian_greyhound"], "172": ["n02091134", "whippet"], "173": ["n02091244", "Ibizan_hound"], "174": ["n02091467", "Norwegian_elkhound"], "175": ["n02091635", "otterhound"], "176": ["n02091831", "Saluki"], "177": ["n02092002", "Scottish_deerhound"], "178": ["n02092339", "Weimaraner"], "179": ["n02093256", "Staffordshire_bullterrier"], "180": ["n02093428", "American_Staffordshire_terrier"], "181": ["n02093647", "Bedlington_terrier"], "182": ["n02093754", "Border_terrier"], "183": ["n02093859", "Kerry_blue_terrier"], "184": ["n02093991", "Irish_terrier"], "185": ["n02094114", "Norfolk_terrier"], "186": ["n02094258", "Norwich_terrier"], "187": ["n02094433", "Yorkshire_terrier"], "188": ["n02095314", "wire-haired_fox_terrier"], "189": ["n02095570", "Lakeland_terrier"], "190": ["n02095889", "Sealyham_terrier"], "191": ["n02096051", "Airedale"], "192": ["n02096177", "cairn"], "193": ["n02096294", "Australian_terrier"], "194": ["n02096437", "Dandie_Dinmont"], "195": ["n02096585", "Boston_bull"], "196": ["n02097047", "miniature_schnauzer"], "197": ["n02097130", "giant_schnauzer"], "198": ["n02097209", "standard_schnauzer"], "199": ["n02097298", "Scotch_terrier"], "200": ["n02097474", "Tibetan_terrier"], "201": ["n02097658", "silky_terrier"], "202": ["n02098105", "soft-coated_wheaten_terrier"], "203": ["n02098286", "West_Highland_white_terrier"], "204": ["n02098413", "Lhasa"], "205": ["n02099267", "flat-coated_retriever"], "206": ["n02099429", "curly-coated_retriever"], "207": ["n02099601", "golden_retriever"], "208": ["n02099712", "Labrador_retriever"], "209": ["n02099849", "Chesapeake_Bay_retriever"], "210": ["n02100236", "German_short-haired_pointer"], "211": ["n02100583", "vizsla"], "212": ["n02100735", "English_setter"], "213": ["n02100877", "Irish_setter"], "214": ["n02101006", "Gordon_setter"], "215": ["n02101388", "Brittany_spaniel"], "216": ["n02101556", "clumber"], "217": ["n02102040", "English_springer"], "218": ["n02102177", "Welsh_springer_spaniel"], "219": ["n02102318", "cocker_spaniel"], "220": ["n02102480", "Sussex_spaniel"], "221": ["n02102973", "Irish_water_spaniel"], "222": ["n02104029", "kuvasz"], "223": ["n02104365", "schipperke"], "224": ["n02105056", "groenendael"], "225": ["n02105162", "malinois"], "226": ["n02105251", "briard"], "227": ["n02105412", "kelpie"], "228": ["n02105505", "komondor"], "229": ["n02105641", "Old_English_sheepdog"], "230": ["n02105855", "Shetland_sheepdog"], "231": ["n02106030", "collie"], "232": ["n02106166", "Border_collie"], "233": ["n02106382", "Bouvier_des_Flandres"], "234": ["n02106550", "Rottweiler"], "235": ["n02106662", "German_shepherd"], "236": ["n02107142", "Doberman"], "237": ["n02107312", "miniature_pinscher"], "238": ["n02107574", "Greater_Swiss_Mountain_dog"], "239": ["n02107683", "Bernese_mountain_dog"], "240": ["n02107908", "Appenzeller"], "241": ["n02108000", "EntleBucher"], "242": ["n02108089", "boxer"], "243": ["n02108422", "bull_mastiff"], "244": ["n02108551", "Tibetan_mastiff"], "245": ["n02108915", "French_bulldog"], "246": ["n02109047", "Great_Dane"], "247": ["n02109525", "Saint_Bernard"], "248": ["n02109961", "Eskimo_dog"], "249": ["n02110063", "malamute"], "250": ["n02110185", "Siberian_husky"], "251": ["n02110341", "dalmatian"], "252": ["n02110627", "affenpinscher"], "253": ["n02110806", "basenji"], "254": ["n02110958", "pug"], "255": ["n02111129", "Leonberg"], "256": ["n02111277", "Newfoundland"], "257": ["n02111500", "Great_Pyrenees"], "258": ["n02111889", "Samoyed"], "259": ["n02112018", "Pomeranian"], "260": ["n02112137", "chow"], "261": ["n02112350", "keeshond"], "262": ["n02112706", "Brabancon_griffon"], "263": ["n02113023", "Pembroke"], "264": ["n02113186", "Cardigan"], "265": ["n02113624", "toy_poodle"], "266": ["n02113712", "miniature_poodle"], "267": ["n02113799", "standard_poodle"], "268": ["n02113978", "Mexican_hairless"], "269": ["n02114367", "timber_wolf"], "270": ["n02114548", "white_wolf"], "271": ["n02114712", "red_wolf"], "272": ["n02114855", "coyote"], "273": ["n02115641", "dingo"], "274": ["n02115913", "dhole"], "275": ["n02116738", "African_hunting_dog"], "276": ["n02117135", "hyena"], "277": ["n02119022", "red_fox"], "278": ["n02119789", "kit_fox"], "279": ["n02120079", "Arctic_fox"], "280": ["n02120505", "grey_fox"], "281": ["n02123045", "tabby"], "282": ["n02123159", "tiger_cat"], "283": ["n02123394", "Persian_cat"], "284": ["n02123597", "Siamese_cat"], "285": ["n02124075", "Egyptian_cat"], "286": ["n02125311", "cougar"], "287": ["n02127052", "lynx"], "288": ["n02128385", "leopard"], "289": ["n02128757", "snow_leopard"], "290": ["n02128925", "jaguar"], "291": ["n02129165", "lion"], "292": ["n02129604", "tiger"], "293": ["n02130308", "cheetah"], "294": ["n02132136", "brown_bear"], "295": ["n02133161", "American_black_bear"], "296": ["n02134084", "ice_bear"], "297": ["n02134418", "sloth_bear"], "298": ["n02137549", "mongoose"], "299": ["n02138441", "meerkat"], "300": ["n02165105", "tiger_beetle"], "301": ["n02165456", "ladybug"], "302": ["n02167151", "ground_beetle"], "303": ["n02168699", "long-horned_beetle"], "304": ["n02169497", "leaf_beetle"], "305": ["n02172182", "dung_beetle"], "306": ["n02174001", "rhinoceros_beetle"], "307": ["n02177972", "weevil"], "308": ["n02190166", "fly"], "309": ["n02206856", "bee"], "310": ["n02219486", "ant"], "311": ["n02226429", "grasshopper"], "312": ["n02229544", "cricket"], "313": ["n02231487", "walking_stick"], "314": ["n02233338", "cockroach"], "315": ["n02236044", "mantis"], "316": ["n02256656", "cicada"], "317": ["n02259212", "leafhopper"], "318": ["n02264363", "lacewing"], "319": ["n02268443", "dragonfly"], "320": ["n02268853", "damselfly"], "321": ["n02276258", "admiral"], "322": ["n02277742", "ringlet"], "323": ["n02279972", "monarch"], "324": ["n02280649", "cabbage_butterfly"], "325": ["n02281406", "sulphur_butterfly"], "326": ["n02281787", "lycaenid"], "327": ["n02317335", "starfish"], "328": ["n02319095", "sea_urchin"], "329": ["n02321529", "sea_cucumber"], "330": ["n02325366", "wood_rabbit"], "331": ["n02326432", "hare"], "332": ["n02328150", "Angora"], "333": ["n02342885", "hamster"], "334": ["n02346627", "porcupine"], "335": ["n02356798", "fox_squirrel"], "336": ["n02361337", "marmot"], "337": ["n02363005", "beaver"], "338": ["n02364673", "guinea_pig"], "339": ["n02389026", "sorrel"], "340": ["n02391049", "zebra"], "341": ["n02395406", "hog"], "342": ["n02396427", "wild_boar"], "343": ["n02397096", "warthog"], "344": ["n02398521", "hippopotamus"], "345": ["n02403003", "ox"], "346": ["n02408429", "water_buffalo"], "347": ["n02410509", "bison"], "348": ["n02412080", "ram"], "349": ["n02415577", "bighorn"], "350": ["n02417914", "ibex"], "351": ["n02422106", "hartebeest"], "352": ["n02422699", "impala"], "353": ["n02423022", "gazelle"], "354": ["n02437312", "Arabian_camel"], "355": ["n02437616", "llama"], "356": ["n02441942", "weasel"], "357": ["n02442845", "mink"], "358": ["n02443114", "polecat"], "359": ["n02443484", "black-footed_ferret"], "360": ["n02444819", "otter"], "361": ["n02445715", "skunk"], "362": ["n02447366", "badger"], "363": ["n02454379", "armadillo"], "364": ["n02457408", "three-toed_sloth"], "365": ["n02480495", "orangutan"], "366": ["n02480855", "gorilla"], "367": ["n02481823", "chimpanzee"], "368": ["n02483362", "gibbon"], "369": ["n02483708", "siamang"], "370": ["n02484975", "guenon"], "371": ["n02486261", "patas"], "372": ["n02486410", "baboon"], "373": ["n02487347", "macaque"], "374": ["n02488291", "langur"], "375": ["n02488702", "colobus"], "376": ["n02489166", "proboscis_monkey"], "377": ["n02490219", "marmoset"], "378": ["n02492035", "capuchin"], "379": ["n02492660", "howler_monkey"], "380": ["n02493509", "titi"], "381": ["n02493793", "spider_monkey"], "382": ["n02494079", "squirrel_monkey"], "383": ["n02497673", "Madagascar_cat"], "384": ["n02500267", "indri"], "385": ["n02504013", "Indian_elephant"], "386": ["n02504458", "African_elephant"], "387": ["n02509815", "lesser_panda"], "388": ["n02510455", "giant_panda"], "389": ["n02514041", "barracouta"], "390": ["n02526121", "eel"], "391": ["n02536864", "coho"], "392": ["n02606052", "rock_beauty"], "393": ["n02607072", "anemone_fish"], "394": ["n02640242", "sturgeon"], "395": ["n02641379", "gar"], "396": ["n02643566", "lionfish"], "397": ["n02655020", "puffer"], "398": ["n02666196", "abacus"], "399": ["n02667093", "abaya"], "400": ["n02669723", "academic_gown"], "401": ["n02672831", "accordion"], "402": ["n02676566", "acoustic_guitar"], "403": ["n02687172", "aircraft_carrier"], "404": ["n02690373", "airliner"], "405": ["n02692877", "airship"], "406": ["n02699494", "altar"], "407": ["n02701002", "ambulance"], "408": ["n02704792", "amphibian"], "409": ["n02708093", "analog_clock"], "410": ["n02727426", "apiary"], "411": ["n02730930", "apron"], "412": ["n02747177", "ashcan"], "413": ["n02749479", "assault_rifle"], "414": ["n02769748", "backpack"], "415": ["n02776631", "bakery"], "416": ["n02777292", "balance_beam"], "417": ["n02782093", "balloon"], "418": ["n02783161", "ballpoint"], "419": ["n02786058", "Band_Aid"], "420": ["n02787622", "banjo"], "421": ["n02788148", "bannister"], "422": ["n02790996", "barbell"], "423": ["n02791124", "barber_chair"], "424": ["n02791270", "barbershop"], "425": ["n02793495", "barn"], "426": ["n02794156", "barometer"], "427": ["n02795169", "barrel"], "428": ["n02797295", "barrow"], "429": ["n02799071", "baseball"], "430": ["n02802426", "basketball"], "431": ["n02804414", "bassinet"], "432": ["n02804610", "bassoon"], "433": ["n02807133", "bathing_cap"], "434": ["n02808304", "bath_towel"], "435": ["n02808440", "bathtub"], "436": ["n02814533", "beach_wagon"], "437": ["n02814860", "beacon"], "438": ["n02815834", "beaker"], "439": ["n02817516", "bearskin"], "440": ["n02823428", "beer_bottle"], "441": ["n02823750", "beer_glass"], "442": ["n02825657", "bell_cote"], "443": ["n02834397", "bib"], "444": ["n02835271", "bicycle-built-for-two"], "445": ["n02837789", "bikini"], "446": ["n02840245", "binder"], "447": ["n02841315", "binoculars"], "448": ["n02843684", "birdhouse"], "449": ["n02859443", "boathouse"], "450": ["n02860847", "bobsled"], "451": ["n02865351", "bolo_tie"], "452": ["n02869837", "bonnet"], "453": ["n02870880", "bookcase"], "454": ["n02871525", "bookshop"], "455": ["n02877765", "bottlecap"], "456": ["n02879718", "bow"], "457": ["n02883205", "bow_tie"], "458": ["n02892201", "brass"], "459": ["n02892767", "brassiere"], "460": ["n02894605", "breakwater"], "461": ["n02895154", "breastplate"], "462": ["n02906734", "broom"], "463": ["n02909870", "bucket"], "464": ["n02910353", "buckle"], "465": ["n02916936", "bulletproof_vest"], "466": ["n02917067", "bullet_train"], "467": ["n02927161", "butcher_shop"], "468": ["n02930766", "cab"], "469": ["n02939185", "caldron"], "470": ["n02948072", "candle"], "471": ["n02950826", "cannon"], "472": ["n02951358", "canoe"], "473": ["n02951585", "can_opener"], "474": ["n02963159", "cardigan"], "475": ["n02965783", "car_mirror"], "476": ["n02966193", "carousel"], "477": ["n02966687", "carpenter's_kit"], "478": ["n02971356", "carton"], "479": ["n02974003", "car_wheel"], "480": ["n02977058", "cash_machine"], "481": ["n02978881", "cassette"], "482": ["n02979186", "cassette_player"], "483": ["n02980441", "castle"], "484": ["n02981792", "catamaran"], "485": ["n02988304", "CD_player"], "486": ["n02992211", "cello"], "487": ["n02992529", "cellular_telephone"], "488": ["n02999410", "chain"], "489": ["n03000134", "chainlink_fence"], "490": ["n03000247", "chain_mail"], "491": ["n03000684", "chain_saw"], "492": ["n03014705", "chest"], "493": ["n03016953", "chiffonier"], "494": ["n03017168", "chime"], "495": ["n03018349", "china_cabinet"], "496": ["n03026506", "Christmas_stocking"], "497": ["n03028079", "church"], "498": ["n03032252", "cinema"], "499": ["n03041632", "cleaver"], "500": ["n03042490", "cliff_dwelling"], "501": ["n03045698", "cloak"], "502": ["n03047690", "clog"], "503": ["n03062245", "cocktail_shaker"], "504": ["n03063599", "coffee_mug"], "505": ["n03063689", "coffeepot"], "506": ["n03065424", "coil"], "507": ["n03075370", "combination_lock"], "508": ["n03085013", "computer_keyboard"], "509": ["n03089624", "confectionery"], "510": ["n03095699", "container_ship"], "511": ["n03100240", "convertible"], "512": ["n03109150", "corkscrew"], "513": ["n03110669", "cornet"], "514": ["n03124043", "cowboy_boot"], "515": ["n03124170", "cowboy_hat"], "516": ["n03125729", "cradle"], "517": ["n03126707", "crane"], "518": ["n03127747", "crash_helmet"], "519": ["n03127925", "crate"], "520": ["n03131574", "crib"], "521": ["n03133878", "Crock_Pot"], "522": ["n03134739", "croquet_ball"], "523": ["n03141823", "crutch"], "524": ["n03146219", "cuirass"], "525": ["n03160309", "dam"], "526": ["n03179701", "desk"], "527": ["n03180011", "desktop_computer"], "528": ["n03187595", "dial_telephone"], "529": ["n03188531", "diaper"], "530": ["n03196217", "digital_clock"], "531": ["n03197337", "digital_watch"], "532": ["n03201208", "dining_table"], "533": ["n03207743", "dishrag"], "534": ["n03207941", "dishwasher"], "535": ["n03208938", "disk_brake"], "536": ["n03216828", "dock"], "537": ["n03218198", "dogsled"], "538": ["n03220513", "dome"], "539": ["n03223299", "doormat"], "540": ["n03240683", "drilling_platform"], "541": ["n03249569", "drum"], "542": ["n03250847", "drumstick"], "543": ["n03255030", "dumbbell"], "544": ["n03259280", "Dutch_oven"], "545": ["n03271574", "electric_fan"], "546": ["n03272010", "electric_guitar"], "547": ["n03272562", "electric_locomotive"], "548": ["n03290653", "entertainment_center"], "549": ["n03291819", "envelope"], "550": ["n03297495", "espresso_maker"], "551": ["n03314780", "face_powder"], "552": ["n03325584", "feather_boa"], "553": ["n03337140", "file"], "554": ["n03344393", "fireboat"], "555": ["n03345487", "fire_engine"], "556": ["n03347037", "fire_screen"], "557": ["n03355925", "flagpole"], "558": ["n03372029", "flute"], "559": ["n03376595", "folding_chair"], "560": ["n03379051", "football_helmet"], "561": ["n03384352", "forklift"], "562": ["n03388043", "fountain"], "563": ["n03388183", "fountain_pen"], "564": ["n03388549", "four-poster"], "565": ["n03393912", "freight_car"], "566": ["n03394916", "French_horn"], "567": ["n03400231", "frying_pan"], "568": ["n03404251", "fur_coat"], "569": ["n03417042", "garbage_truck"], "570": ["n03424325", "gasmask"], "571": ["n03425413", "gas_pump"], "572": ["n03443371", "goblet"], "573": ["n03444034", "go-kart"], "574": ["n03445777", "golf_ball"], "575": ["n03445924", "golfcart"], "576": ["n03447447", "gondola"], "577": ["n03447721", "gong"], "578": ["n03450230", "gown"], "579": ["n03452741", "grand_piano"], "580": ["n03457902", "greenhouse"], "581": ["n03459775", "grille"], "582": ["n03461385", "grocery_store"], "583": ["n03467068", "guillotine"], "584": ["n03476684", "hair_slide"], "585": ["n03476991", "hair_spray"], "586": ["n03478589", "half_track"], "587": ["n03481172", "hammer"], "588": ["n03482405", "hamper"], "589": ["n03483316", "hand_blower"], "590": ["n03485407", "hand-held_computer"], "591": ["n03485794", "handkerchief"], "592": ["n03492542", "hard_disc"], "593": ["n03494278", "harmonica"], "594": ["n03495258", "harp"], "595": ["n03496892", "harvester"], "596": ["n03498962", "hatchet"], "597": ["n03527444", "holster"], "598": ["n03529860", "home_theater"], "599": ["n03530642", "honeycomb"], "600": ["n03532672", "hook"], "601": ["n03534580", "hoopskirt"], "602": ["n03535780", "horizontal_bar"], "603": ["n03538406", "horse_cart"], "604": ["n03544143", "hourglass"], "605": ["n03584254", "iPod"], "606": ["n03584829", "iron"], "607": ["n03590841", "jack-o'-lantern"], "608": ["n03594734", "jean"], "609": ["n03594945", "jeep"], "610": ["n03595614", "jersey"], "611": ["n03598930", "jigsaw_puzzle"], "612": ["n03599486", "jinrikisha"], "613": ["n03602883", "joystick"], "614": ["n03617480", "kimono"], "615": ["n03623198", "knee_pad"], "616": ["n03627232", "knot"], "617": ["n03630383", "lab_coat"], "618": ["n03633091", "ladle"], "619": ["n03637318", "lampshade"], "620": ["n03642806", "laptop"], "621": ["n03649909", "lawn_mower"], "622": ["n03657121", "lens_cap"], "623": ["n03658185", "letter_opener"], "624": ["n03661043", "library"], "625": ["n03662601", "lifeboat"], "626": ["n03666591", "lighter"], "627": ["n03670208", "limousine"], "628": ["n03673027", "liner"], "629": ["n03676483", "lipstick"], "630": ["n03680355", "Loafer"], "631": ["n03690938", "lotion"], "632": ["n03691459", "loudspeaker"], "633": ["n03692522", "loupe"], "634": ["n03697007", "lumbermill"], "635": ["n03706229", "magnetic_compass"], "636": ["n03709823", "mailbag"], "637": ["n03710193", "mailbox"], "638": ["n03710637", "maillot"], "639": ["n03710721", "maillot"], "640": ["n03717622", "manhole_cover"], "641": ["n03720891", "maraca"], "642": ["n03721384", "marimba"], "643": ["n03724870", "mask"], "644": ["n03729826", "matchstick"], "645": ["n03733131", "maypole"], "646": ["n03733281", "maze"], "647": ["n03733805", "measuring_cup"], "648": ["n03742115", "medicine_chest"], "649": ["n03743016", "megalith"], "650": ["n03759954", "microphone"], "651": ["n03761084", "microwave"], "652": ["n03763968", "military_uniform"], "653": ["n03764736", "milk_can"], "654": ["n03769881", "minibus"], "655": ["n03770439", "miniskirt"], "656": ["n03770679", "minivan"], "657": ["n03773504", "missile"], "658": ["n03775071", "mitten"], "659": ["n03775546", "mixing_bowl"], "660": ["n03776460", "mobile_home"], "661": ["n03777568", "Model_T"], "662": ["n03777754", "modem"], "663": ["n03781244", "monastery"], "664": ["n03782006", "monitor"], "665": ["n03785016", "moped"], "666": ["n03786901", "mortar"], "667": ["n03787032", "mortarboard"], "668": ["n03788195", "mosque"], "669": ["n03788365", "mosquito_net"], "670": ["n03791053", "motor_scooter"], "671": ["n03792782", "mountain_bike"], "672": ["n03792972", "mountain_tent"], "673": ["n03793489", "mouse"], "674": ["n03794056", "mousetrap"], "675": ["n03796401", "moving_van"], "676": ["n03803284", "muzzle"], "677": ["n03804744", "nail"], "678": ["n03814639", "neck_brace"], "679": ["n03814906", "necklace"], "680": ["n03825788", "nipple"], "681": ["n03832673", "notebook"], "682": ["n03837869", "obelisk"], "683": ["n03838899", "oboe"], "684": ["n03840681", "ocarina"], "685": ["n03841143", "odometer"], "686": ["n03843555", "oil_filter"], "687": ["n03854065", "organ"], "688": ["n03857828", "oscilloscope"], "689": ["n03866082", "overskirt"], "690": ["n03868242", "oxcart"], "691": ["n03868863", "oxygen_mask"], "692": ["n03871628", "packet"], "693": ["n03873416", "paddle"], "694": ["n03874293", "paddlewheel"], "695": ["n03874599", "padlock"], "696": ["n03876231", "paintbrush"], "697": ["n03877472", "pajama"], "698": ["n03877845", "palace"], "699": ["n03884397", "panpipe"], "700": ["n03887697", "paper_towel"], "701": ["n03888257", "parachute"], "702": ["n03888605", "parallel_bars"], "703": ["n03891251", "park_bench"], "704": ["n03891332", "parking_meter"], "705": ["n03895866", "passenger_car"], "706": ["n03899768", "patio"], "707": ["n03902125", "pay-phone"], "708": ["n03903868", "pedestal"], "709": ["n03908618", "pencil_box"], "710": ["n03908714", "pencil_sharpener"], "711": ["n03916031", "perfume"], "712": ["n03920288", "Petri_dish"], "713": ["n03924679", "photocopier"], "714": ["n03929660", "pick"], "715": ["n03929855", "pickelhaube"], "716": ["n03930313", "picket_fence"], "717": ["n03930630", "pickup"], "718": ["n03933933", "pier"], "719": ["n03935335", "piggy_bank"], "720": ["n03937543", "pill_bottle"], "721": ["n03938244", "pillow"], "722": ["n03942813", "ping-pong_ball"], "723": ["n03944341", "pinwheel"], "724": ["n03947888", "pirate"], "725": ["n03950228", "pitcher"], "726": ["n03954731", "plane"], "727": ["n03956157", "planetarium"], "728": ["n03958227", "plastic_bag"], "729": ["n03961711", "plate_rack"], "730": ["n03967562", "plow"], "731": ["n03970156", "plunger"], "732": ["n03976467", "Polaroid_camera"], "733": ["n03976657", "pole"], "734": ["n03977966", "police_van"], "735": ["n03980874", "poncho"], "736": ["n03982430", "pool_table"], "737": ["n03983396", "pop_bottle"], "738": ["n03991062", "pot"], "739": ["n03992509", "potter's_wheel"], "740": ["n03995372", "power_drill"], "741": ["n03998194", "prayer_rug"], "742": ["n04004767", "printer"], "743": ["n04005630", "prison"], "744": ["n04008634", "projectile"], "745": ["n04009552", "projector"], "746": ["n04019541", "puck"], "747": ["n04023962", "punching_bag"], "748": ["n04026417", "purse"], "749": ["n04033901", "quill"], "750": ["n04033995", "quilt"], "751": ["n04037443", "racer"], "752": ["n04039381", "racket"], "753": ["n04040759", "radiator"], "754": ["n04041544", "radio"], "755": ["n04044716", "radio_telescope"], "756": ["n04049303", "rain_barrel"], "757": ["n04065272", "recreational_vehicle"], "758": ["n04067472", "reel"], "759": ["n04069434", "reflex_camera"], "760": ["n04070727", "refrigerator"], "761": ["n04074963", "remote_control"], "762": ["n04081281", "restaurant"], "763": ["n04086273", "revolver"], "764": ["n04090263", "rifle"], "765": ["n04099969", "rocking_chair"], "766": ["n04111531", "rotisserie"], "767": ["n04116512", "rubber_eraser"], "768": ["n04118538", "rugby_ball"], "769": ["n04118776", "rule"], "770": ["n04120489", "running_shoe"], "771": ["n04125021", "safe"], "772": ["n04127249", "safety_pin"], "773": ["n04131690", "saltshaker"], "774": ["n04133789", "sandal"], "775": ["n04136333", "sarong"], "776": ["n04141076", "sax"], "777": ["n04141327", "scabbard"], "778": ["n04141975", "scale"], "779": ["n04146614", "school_bus"], "780": ["n04147183", "schooner"], "781": ["n04149813", "scoreboard"], "782": ["n04152593", "screen"], "783": ["n04153751", "screw"], "784": ["n04154565", "screwdriver"], "785": ["n04162706", "seat_belt"], "786": ["n04179913", "sewing_machine"], "787": ["n04192698", "shield"], "788": ["n04200800", "shoe_shop"], "789": ["n04201297", "shoji"], "790": ["n04204238", "shopping_basket"], "791": ["n04204347", "shopping_cart"], "792": ["n04208210", "shovel"], "793": ["n04209133", "shower_cap"], "794": ["n04209239", "shower_curtain"], "795": ["n04228054", "ski"], "796": ["n04229816", "ski_mask"], "797": ["n04235860", "sleeping_bag"], "798": ["n04238763", "slide_rule"], "799": ["n04239074", "sliding_door"], "800": ["n04243546", "slot"], "801": ["n04251144", "snorkel"], "802": ["n04252077", "snowmobile"], "803": ["n04252225", "snowplow"], "804": ["n04254120", "soap_dispenser"], "805": ["n04254680", "soccer_ball"], "806": ["n04254777", "sock"], "807": ["n04258138", "solar_dish"], "808": ["n04259630", "sombrero"], "809": ["n04263257", "soup_bowl"], "810": ["n04264628", "space_bar"], "811": ["n04265275", "space_heater"], "812": ["n04266014", "space_shuttle"], "813": ["n04270147", "spatula"], "814": ["n04273569", "speedboat"], "815": ["n04275548", "spider_web"], "816": ["n04277352", "spindle"], "817": ["n04285008", "sports_car"], "818": ["n04286575", "spotlight"], "819": ["n04296562", "stage"], "820": ["n04310018", "steam_locomotive"], "821": ["n04311004", "steel_arch_bridge"], "822": ["n04311174", "steel_drum"], "823": ["n04317175", "stethoscope"], "824": ["n04325704", "stole"], "825": ["n04326547", "stone_wall"], "826": ["n04328186", "stopwatch"], "827": ["n04330267", "stove"], "828": ["n04332243", "strainer"], "829": ["n04335435", "streetcar"], "830": ["n04336792", "stretcher"], "831": ["n04344873", "studio_couch"], "832": ["n04346328", "stupa"], "833": ["n04347754", "submarine"], "834": ["n04350905", "suit"], "835": ["n04355338", "sundial"], "836": ["n04355933", "sunglass"], "837": ["n04356056", "sunglasses"], "838": ["n04357314", "sunscreen"], "839": ["n04366367", "suspension_bridge"], "840": ["n04367480", "swab"], "841": ["n04370456", "sweatshirt"], "842": ["n04371430", "swimming_trunks"], "843": ["n04371774", "swing"], "844": ["n04372370", "switch"], "845": ["n04376876", "syringe"], "846": ["n04380533", "table_lamp"], "847": ["n04389033", "tank"], "848": ["n04392985", "tape_player"], "849": ["n04398044", "teapot"], "850": ["n04399382", "teddy"], "851": ["n04404412", "television"], "852": ["n04409515", "tennis_ball"], "853": ["n04417672", "thatch"], "854": ["n04418357", "theater_curtain"], "855": ["n04423845", "thimble"], "856": ["n04428191", "thresher"], "857": ["n04429376", "throne"], "858": ["n04435653", "tile_roof"], "859": ["n04442312", "toaster"], "860": ["n04443257", "tobacco_shop"], "861": ["n04447861", "toilet_seat"], "862": ["n04456115", "torch"], "863": ["n04458633", "totem_pole"], "864": ["n04461696", "tow_truck"], "865": ["n04462240", "toyshop"], "866": ["n04465501", "tractor"], "867": ["n04467665", "trailer_truck"], "868": ["n04476259", "tray"], "869": ["n04479046", "trench_coat"], "870": ["n04482393", "tricycle"], "871": ["n04483307", "trimaran"], "872": ["n04485082", "tripod"], "873": ["n04486054", "triumphal_arch"], "874": ["n04487081", "trolleybus"], "875": ["n04487394", "trombone"], "876": ["n04493381", "tub"], "877": ["n04501370", "turnstile"], "878": ["n04505470", "typewriter_keyboard"], "879": ["n04507155", "umbrella"], "880": ["n04509417", "unicycle"], "881": ["n04515003", "upright"], "882": ["n04517823", "vacuum"], "883": ["n04522168", "vase"], "884": ["n04523525", "vault"], "885": ["n04525038", "velvet"], "886": ["n04525305", "vending_machine"], "887": ["n04532106", "vestment"], "888": ["n04532670", "viaduct"], "889": ["n04536866", "violin"], "890": ["n04540053", "volleyball"], "891": ["n04542943", "waffle_iron"], "892": ["n04548280", "wall_clock"], "893": ["n04548362", "wallet"], "894": ["n04550184", "wardrobe"], "895": ["n04552348", "warplane"], "896": ["n04553703", "washbasin"], "897": ["n04554684", "washer"], "898": ["n04557648", "water_bottle"], "899": ["n04560804", "water_jug"], "900": ["n04562935", "water_tower"], "901": ["n04579145", "whiskey_jug"], "902": ["n04579432", "whistle"], "903": ["n04584207", "wig"], "904": ["n04589890", "window_screen"], "905": ["n04590129", "window_shade"], "906": ["n04591157", "Windsor_tie"], "907": ["n04591713", "wine_bottle"], "908": ["n04592741", "wing"], "909": ["n04596742", "wok"], "910": ["n04597913", "wooden_spoon"], "911": ["n04599235", "wool"], "912": ["n04604644", "worm_fence"], "913": ["n04606251", "wreck"], "914": ["n04612504", "yawl"], "915": ["n04613696", "yurt"], "916": ["n06359193", "web_site"], "917": ["n06596364", "comic_book"], "918": ["n06785654", "crossword_puzzle"], "919": ["n06794110", "street_sign"], "920": ["n06874185", "traffic_light"], "921": ["n07248320", "book_jacket"], "922": ["n07565083", "menu"], "923": ["n07579787", "plate"], "924": ["n07583066", "guacamole"], "925": ["n07584110", "consomme"], "926": ["n07590611", "hot_pot"], "927": ["n07613480", "trifle"], "928": ["n07614500", "ice_cream"], "929": ["n07615774", "ice_lolly"], "930": ["n07684084", "French_loaf"], "931": ["n07693725", "bagel"], "932": ["n07695742", "pretzel"], "933": ["n07697313", "cheeseburger"], "934": ["n07697537", "hotdog"], "935": ["n07711569", "mashed_potato"], "936": ["n07714571", "head_cabbage"], "937": ["n07714990", "broccoli"], "938": ["n07715103", "cauliflower"], "939": ["n07716358", "zucchini"], "940": ["n07716906", "spaghetti_squash"], "941": ["n07717410", "acorn_squash"], "942": ["n07717556", "butternut_squash"], "943": ["n07718472", "cucumber"], "944": ["n07718747", "artichoke"], "945": ["n07720875", "bell_pepper"], "946": ["n07730033", "cardoon"], "947": ["n07734744", "mushroom"], "948": ["n07742313", "Granny_Smith"], "949": ["n07745940", "strawberry"], "950": ["n07747607", "orange"], "951": ["n07749582", "lemon"], "952": ["n07753113", "fig"], "953": ["n07753275", "pineapple"], "954": ["n07753592", "banana"], "955": ["n07754684", "jackfruit"], "956": ["n07760859", "custard_apple"], "957": ["n07768694", "pomegranate"], "958": ["n07802026", "hay"], "959": ["n07831146", "carbonara"], "960": ["n07836838", "chocolate_sauce"], "961": ["n07860988", "dough"], "962": ["n07871810", "meat_loaf"], "963": ["n07873807", "pizza"], "964": ["n07875152", "potpie"], "965": ["n07880968", "burrito"], "966": ["n07892512", "red_wine"], "967": ["n07920052", "espresso"], "968": ["n07930864", "cup"], "969": ["n07932039", "eggnog"], "970": ["n09193705", "alp"], "971": ["n09229709", "bubble"], "972": ["n09246464", "cliff"], "973": ["n09256479", "coral_reef"], "974": ["n09288635", "geyser"], "975": ["n09332890", "lakeside"], "976": ["n09399592", "promontory"], "977": ["n09421951", "sandbar"], "978": ["n09428293", "seashore"], "979": ["n09468604", "valley"], "980": ["n09472597", "volcano"], "981": ["n09835506", "ballplayer"], "982": ["n10148035", "groom"], "983": ["n10565667", "scuba_diver"], "984": ["n11879895", "rapeseed"], "985": ["n11939491", "daisy"], "986": ["n12057211", "yellow_lady's_slipper"], "987": ["n12144580", "corn"], "988": ["n12267677", "acorn"], "989": ["n12620546", "hip"], "990": ["n12768682", "buckeye"], "991": ["n12985857", "coral_fungus"], "992": ["n12998815", "agaric"], "993": ["n13037406", "gyromitra"], "994": ["n13040303", "stinkhorn"], "995": ["n13044778", "earthstar"], "996": ["n13052670", "hen-of-the-woods"], "997": ["n13054560", "bolete"], "998": ["n13133613", "ear"], "999": ["n15075141", "toilet_tissue"]}
\ No newline at end of file
diff --git a/_static/images/microsoft-logo.svg b/_static/images/microsoft-logo.svg
new file mode 100644
index 00000000000..a1a7ce2d7a7
--- /dev/null
+++ b/_static/images/microsoft-logo.svg
@@ -0,0 +1,80 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 25.2.3, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 viewBox="0 0 1024 1024" style="enable-background:new 0 0 1024 1024;" xml:space="preserve">
+<image style="overflow:visible;" width="1024" height="1024" xlink:href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAABAAAAAQACAMAAABIw9uxAAAABGdBTUEAALGPC/xhBQAAACBjSFJN
+AAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAATlBMVEXz8/Pzz8Tzp5HzuqrL
+35+92YLZ573zUyXzfVqfykOBvAbznIO11XKf2PJDuvFyyfL61HP8yUX336CBzvIFpvD/ugj52IO9
+4vP25r7///8wcQ+eAAAAAWJLR0QZ7G61iAAAAAd0SU1FB+QEEgsoICT3q2MAAA8eSURBVHja7dRL
+EoJAEETBkY+CCgooev+TegV7MYsO8l2horIUSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIk
+SZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIO3KlR2trI0l2vtJ2rAdBclLYhsvR4
+Vdp6AAgAAACAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+QAAAAAAEAAAAQAAQAAQAAUAAEAAEAAFAABAABAABQAAQAAQAAUAAEAAEAAFAABAABAABQAAQAAQA
+AUAAEAAEAAFAABAABAABQAAQAAQAAUAAEAAEAAFAABAABAABAAAAEAAAAAABAAAAEAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuBEAAAAAAQAAABAAAAAAAUAAEAAEAAFAABAA
+BAABQAAQAAQAAUAAEAAEAAFAABAABAABQAAQAAQAAUAAEAAEAAFAABAABAABQAAQAAQAAUAAEAAE
+AAFAABAABAABQAAQAAQAAABAAAAAAAQAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAgAAAAAAIAAAAgAAAAAAKAACAACAACgAAgAAgAAoAAIAAIAAKAACAACAACgAAgAAgA
+AoAAIAAIAAKAACAACAACgAAgAAgAAoAAIAAIAAKAACAACAACgAAgAAgAAoAAIAAIAAAAgAAAAAAI
+AAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAEAAAAQAAAAAAE
+AAFAABAABAABQAAQAAQAAUAAEAAEAAFAABAABAABQAAQAAQAAUAAEAAEAAFAABAABAABQAAQAAQA
+AUAAEAAEAAFAABAABAABQAAQAAQAAUAAEAAAAAABAAAAEAAAAAABAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAACAAAAIAAAAAACAACgAAgAAgAAoAAIAAIAAKAACAACAAC
+gAAgAAgAAoAAIAAIAAKAACAACAACgAAgAAgAAoAAIAAIAAKAACAACAACgAAgAAgAAoAAIAAIAAKA
+ACAAAAAAAgAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEA
+AAAQAAAAAAEAAAAQAAQAAUAAEAAEAAFAABAABAABQAAQAAQAAUAAEAAEAAFAABAABAABQAAQAAQA
+AUAAEAAEAAFAABAABAABQAAQAAQAAUAAEAAEAAFAABAABAABQAAAAAAEAAAAQAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAACAAAAAAAoAbAUAAEAAEAAFAABAA
+BAABQAAQAAQAAUAAEAAEAAFAABAABAABQAAQAAQAAUAAEAAEAAFAABAABAABQAAQAAQAAUAAEAAE
+AAFAABAABAABQAAQAAAAAAEAAAAQAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAACAAAAIAAAAAACAACgAAgAAgAAoAAIAAIAAKAACAACAACgAAgAAgAAoAAIAAI
+AAKAACAACAACgAAgAAgAAoAAIAAIAAKAACAACAACgAAgAAgAAoAAIAAIAAKAACAAAAAAAgAAACAA
+AAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANwIAAAAgAAAAAAIAAAAg
+AAgAAoAAIAAIAAKAACAACAACgAAgAAgAAoAAIAAIAAKAACAACAACgAAgAAgAAoAAIAAIAAKAACAA
+CAACgAAgAAgAAoAAIAAIAAKAACAACAACgAAAAAAIAAAAgAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAQAAAAAAEAAAAQAAQAAQAAUAAEAAEAAFAABAABAABQAAQ
+AAQAAUAAEAAEAAFAABAABAABQAAQAAQAAUAAEAAEAAFAABAABAABQAAQAAQAAUAAEAAEAAFAABAA
+BAABAAAAEAAAAAABAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAA
+AIAAAAAACAAAAIAAIAAIAAKAACAACAACgAAgAAgAAoAAIAAIAAKAACAACAACgAAgAAgAAoAAIAAI
+AAKAACAACAACgAAgAAgAAoAAIAAIAAKAACAACAACgAAgAAgAAgAAACAAAAAAAgAAACAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAQAAABAAAAAAAUAAEAAEAAFAABAA
+BAABQAAQAAQAAUAAEAAEAAFAABAABAABQAAQAAQAAUAAEAAEAAFAABAABAABQAAQAAQAAUAAEAAE
+AAFAABAABAABQAAQAAQAANSoHZS2W2Tp+6i0dUWSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmS
+JEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJP3XNCttj8jSz0VpW6sBsL2Utjmy
+9PJW2nYACAAAAIAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AABAAAAAAAQAAABAABAABAABQAAQAAQAAUAAEAAEAAFAABAABAABQAAQAAQAAUAAEAAEAAFAABAA
+BAABQAAQAAQAAUAAEAAEAAFAABAABAABQAAQAAQAAUAAEAAEAAEAAAAQAAAAAAEAAAAQAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC4EQAAAAABAAAAEAAAAAABQAAQAAQAAUAA
+EAAEAAFAABAABAABQAAQAAQAAUAAEAAEAAFAABAABAABQAAQAAQAAUAAEAAEAAFAABAABAABQAAQ
+AAQAAUAAEAAEAAFAABAABAAAAEAAAAAABAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAACAAAAAAAgAAACAAAAAAAoAAIAAIAAKAACAACAACgAAgAAgAAoAAIAAIAAKAACAA
+CAACgAAgAAgAAoAAIAAIAAKAACAACAACgAAgAAgAAoAAIAAIAAKAACAACAACgAAgAAgAAACAAAAA
+AAgAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAQAAABAAAAA
+AAQAAUAAEAAEAAFAABAABAABQAAQAAQAAUAAEAAEAAFAABAABAABQAAQAAQAAUAAEAAEAAFAABAA
+BAABQAAQAAQAAUAAEAAEAAFAABAABAABQAAQAAAAAAEAAAAQAAAAAAEAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAIAAAAgAAAAAAIAAKAACAACAACgAAgAAgAAoAAIAAI
+AAKAACAACAACgAAgAAgAAoAAIAAIAAKAACAACAACgAAgAAgAAoAAIAAIAAKAACAACAACgAAgAAgA
+AoAAIAAAAAACAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AQAAABAAAAAAAQAAABAABAABQAAQAAQAAUAAEAAEAAFAABAABAABQAAQAAQAAUAAEAAEAAFAABAA
+BAABQAAQAAQAAUAAEAAEAAFAABAABAABQAAQAAQAAUAAEAAEAAFAAAAAAAQAAABAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAIAAAAAACgBsBQAAQAAQAAUAA
+EAAEAAFAABAABAABQAAQAAQAAUAAEAAEAAFAABAABAABQAAQAAQAAUAAEAAEAAFAABAABAABQAAQ
+AAQAAUAAEAAEAAFAABAAAAAAAQAAABAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAIAAAAgAAAAAAIAAKAACAACAACgAAgAAgAAoAAIAAIAAKAACAACAACgAAg
+AAgAAoAAIAAIAAKAACAACAACgAAgAAgAAoAAIAAIAAKAACAACAACgAAgAAgAAoAAIAAAAAACAAAA
+IAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3AgAAACAAAAAAAgAA
+ACAACAACgAAgAAgAAoAAIAAIAAKAACAACAACgAAgAAgAAoAAIAAIAAKAACAACAACgAAgAAgAAoAA
+IAAIAAKAACAACAACgAAgAAgAAoAAIAAIAAKAAAAAAAgAAACAAAAAAAgAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAABAAAAAAAQAAABAABAABAABQAAQAAQAAUAAEAAEAAFA
+ABAABAABQAAQAAQAAUAAEAAEAAFAABAABAABQAAQAAQAAUAAEAAEAAFAABAABAABQAAQAAQAAUAA
+EAAEAAEAAAAQAAAAAAEAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI
+AAAAgAAAAAAIAAAAgAAgAAgAAoAAIAAIAAKAACAACAACgAAgAAgAAoAAIAAIAAKAACAACAACgAAg
+AAgAAoAAIAAIAAKAACAACAACgAAgAAgAAoAAIAAIAAKAACAACAACAAAAIAAAAAACAAAAIAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAABAAAAEAAAAAABQAAQAAQAAUAA
+EAAEAAFAABAABAABQAAQAAQAAUAAEAAEAAFAABAABAABQAAQAAQAAUAAEAAEAAFAABAABAABQAAQ
+AAQAAUAAEAAEAAFAABAABAAA1OizKW1TZOl1V9q+RZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIk
+SZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZKkA/cDwJ7PmkABLLQAAAAldEVY
+dGRhdGU6Y3JlYXRlADIwMjAtMDQtMThUMTE6NDA6MzIrMDA6MDD4EWKnAAAAJXRFWHRkYXRlOm1v
+ZGlmeQAyMDIwLTA0LTE4VDExOjQwOjMyKzAwOjAwiUzaGwAAAABJRU5ErkJggg==">
+</image>
+</svg>
diff --git a/_static/img/8_workers.png b/_static/img/8_workers.png
new file mode 100644
index 00000000000..9a51182eb4b
Binary files /dev/null and b/_static/img/8_workers.png differ
diff --git a/_static/img/ExecuTorch-Logo-cropped.svg b/_static/img/ExecuTorch-Logo-cropped.svg
new file mode 100644
index 00000000000..9e0ef52fbd8
--- /dev/null
+++ b/_static/img/ExecuTorch-Logo-cropped.svg
@@ -0,0 +1,57 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   id="Layer_2"
+   viewBox="0 0 51.200001 38.52"
+   width="51.200001"
+   height="38.52"
+   version="1.1"
+   sodipodi:docname="ExecuTorch-Logo-cropped.svg"
+   inkscape:version="1.2.1 (9c6d41e4, 2022-07-14)"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:svg="http://www.w3.org/2000/svg">
+  <sodipodi:namedview
+     id="namedview15"
+     pagecolor="#ffffff"
+     bordercolor="#000000"
+     borderopacity="0.25"
+     inkscape:showpageshadow="2"
+     inkscape:pageopacity="0.0"
+     inkscape:pagecheckerboard="0"
+     inkscape:deskcolor="#d1d1d1"
+     showgrid="false"
+     inkscape:zoom="8.0613964"
+     inkscape:cx="18.235054"
+     inkscape:cy="7.6289512"
+     inkscape:window-width="1680"
+     inkscape:window-height="819"
+     inkscape:window-x="0"
+     inkscape:window-y="25"
+     inkscape:window-maximized="0"
+     inkscape:current-layer="Layer_2" />
+  <defs
+     id="defs4">
+    <style
+       id="style2">.cls-1{fill:#cc2faa;}</style>
+  </defs>
+  <path
+     class="cls-1"
+     d="m 26.89,12.15 c 1.27,-1.27 3.33,-1.27 4.59,0 1.26,1.27 1.26,3.32 0,4.59 -1.26,1.27 -3.33,1.27 -4.59,0 -1.26,-1.27 -1.26,-3.32 0,-4.59"
+     id="path6" />
+  <polygon
+     class="cls-1"
+     points="16.1,27.25 16.11,21.52 39.95,45.19 51.49,45.17 51.53,22.49 55.6,18.42 55.55,49.23 38.27,49.26 "
+     id="polygon8"
+     transform="translate(-4.4,-10.74)" />
+  <polygon
+     class="cls-1"
+     points="4.4,41.62 4.45,10.77 21.74,10.74 30.38,19.31 27.5,22.19 20.05,14.81 8.52,14.83 8.48,37.55 "
+     id="polygon10"
+     transform="translate(-4.4,-10.74)" />
+  <polygon
+     class="cls-1"
+     points="39.52,28.41 44.48,33.33 44.47,39.06 36.66,31.31 "
+     id="polygon12"
+     transform="translate(-4.4,-10.74)" />
+</svg>
diff --git a/_static/img/audio_preprocessing_tutorial_waveform.png b/_static/img/audio_preprocessing_tutorial_waveform.png
new file mode 100644
index 00000000000..320b53c996d
Binary files /dev/null and b/_static/img/audio_preprocessing_tutorial_waveform.png differ
diff --git a/_static/img/ax_logo.png b/_static/img/ax_logo.png
new file mode 100644
index 00000000000..ecb4302b524
Binary files /dev/null and b/_static/img/ax_logo.png differ
diff --git a/_static/img/ax_scheduler_illustration.png b/_static/img/ax_scheduler_illustration.png
new file mode 100644
index 00000000000..65e5a004a1b
Binary files /dev/null and b/_static/img/ax_scheduler_illustration.png differ
diff --git a/_static/img/basics/comp-graph.png b/_static/img/basics/comp-graph.png
new file mode 100644
index 00000000000..cfa6163d58a
Binary files /dev/null and b/_static/img/basics/comp-graph.png differ
diff --git a/_static/img/basics/fashion_mnist.png b/_static/img/basics/fashion_mnist.png
new file mode 100644
index 00000000000..213b1e1f17b
Binary files /dev/null and b/_static/img/basics/fashion_mnist.png differ
diff --git a/_static/img/basics/optimizationloops.png b/_static/img/basics/optimizationloops.png
new file mode 100644
index 00000000000..c43d83f2799
Binary files /dev/null and b/_static/img/basics/optimizationloops.png differ
diff --git a/_static/img/basics/typesdata.png b/_static/img/basics/typesdata.png
new file mode 100644
index 00000000000..5d0e0291eef
Binary files /dev/null and b/_static/img/basics/typesdata.png differ
diff --git a/_static/img/bert_mrpc.png b/_static/img/bert_mrpc.png
new file mode 100644
index 00000000000..fb0ff796f79
Binary files /dev/null and b/_static/img/bert_mrpc.png differ
diff --git a/_static/img/cat_224x224.jpg b/_static/img/cat_224x224.jpg
deleted file mode 100755
index 05660ce53f9..00000000000
Binary files a/_static/img/cat_224x224.jpg and /dev/null differ
diff --git a/_static/img/cat_output1.png b/_static/img/cat_output1.png
deleted file mode 100755
index 92694433024..00000000000
Binary files a/_static/img/cat_output1.png and /dev/null differ
diff --git a/_static/img/channels_last_memory_format.png b/_static/img/channels_last_memory_format.png
new file mode 100644
index 00000000000..d2b2922023f
Binary files /dev/null and b/_static/img/channels_last_memory_format.png differ
diff --git a/_static/img/chatbot/diff.png b/_static/img/chatbot/diff.png
old mode 100755
new mode 100644
index 525c426679d..fc3cc56789b
Binary files a/_static/img/chatbot/diff.png and b/_static/img/chatbot/diff.png differ
diff --git a/_static/img/chatbot/pytorch_workflow.png b/_static/img/chatbot/pytorch_workflow.png
old mode 100755
new mode 100644
index 1598490ddad..8a81f1995f0
Binary files a/_static/img/chatbot/pytorch_workflow.png and b/_static/img/chatbot/pytorch_workflow.png differ
diff --git a/_static/img/classic_memory_format.png b/_static/img/classic_memory_format.png
new file mode 100644
index 00000000000..65cff010d88
Binary files /dev/null and b/_static/img/classic_memory_format.png differ
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 00000000000..3e094cf6f73
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 00000000000..4ce2b8538ee
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 00000000000..41ae56acf2d
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 00000000000..800a1784587
Binary files /dev/null and b/_static/img/compiled_autograd/recompile_due_to_node.png differ
diff --git a/_static/img/dag_autograd.png b/_static/img/dag_autograd.png
new file mode 100644
index 00000000000..cdc50fed625
Binary files /dev/null and b/_static/img/dag_autograd.png differ
diff --git a/_static/img/deeplabv3_android.png b/_static/img/deeplabv3_android.png
new file mode 100644
index 00000000000..e0a451be8ef
Binary files /dev/null and b/_static/img/deeplabv3_android.png differ
diff --git a/_static/img/deeplabv3_android2.png b/_static/img/deeplabv3_android2.png
new file mode 100644
index 00000000000..0ae041479aa
Binary files /dev/null and b/_static/img/deeplabv3_android2.png differ
diff --git a/_static/img/deeplabv3_ios.png b/_static/img/deeplabv3_ios.png
new file mode 100644
index 00000000000..c901179e1ee
Binary files /dev/null and b/_static/img/deeplabv3_ios.png differ
diff --git a/_static/img/deeplabv3_ios2.png b/_static/img/deeplabv3_ios2.png
new file mode 100644
index 00000000000..3dc0073ca13
Binary files /dev/null and b/_static/img/deeplabv3_ios2.png differ
diff --git a/_static/img/distributed/DDP_memory.gif b/_static/img/distributed/DDP_memory.gif
new file mode 100644
index 00000000000..4049b9dba43
Binary files /dev/null and b/_static/img/distributed/DDP_memory.gif differ
diff --git a/_static/img/distributed/FSDP_autowrap.gif b/_static/img/distributed/FSDP_autowrap.gif
new file mode 100644
index 00000000000..d9e782d4c95
Binary files /dev/null and b/_static/img/distributed/FSDP_autowrap.gif differ
diff --git a/_static/img/distributed/FSDP_memory.gif b/_static/img/distributed/FSDP_memory.gif
new file mode 100644
index 00000000000..aece4e4b8a0
Binary files /dev/null and b/_static/img/distributed/FSDP_memory.gif differ
diff --git a/_static/img/distributed/device_mesh.png b/_static/img/distributed/device_mesh.png
new file mode 100644
index 00000000000..2ccabcc4824
Binary files /dev/null and b/_static/img/distributed/device_mesh.png differ
diff --git a/_static/img/distributed/distributed_checkpoint_generated_files.png b/_static/img/distributed/distributed_checkpoint_generated_files.png
new file mode 100644
index 00000000000..b32dddb7e62
Binary files /dev/null and b/_static/img/distributed/distributed_checkpoint_generated_files.png differ
diff --git a/_static/img/distributed/fsdp_implicit.png b/_static/img/distributed/fsdp_implicit.png
new file mode 100644
index 00000000000..85b19b7e72e
Binary files /dev/null and b/_static/img/distributed/fsdp_implicit.png differ
diff --git a/_static/img/distributed/fsdp_sharding.png b/_static/img/distributed/fsdp_sharding.png
new file mode 100755
index 00000000000..9dd1e3c111e
Binary files /dev/null and b/_static/img/distributed/fsdp_sharding.png differ
diff --git a/_static/img/distributed/fsdp_tp.png b/_static/img/distributed/fsdp_tp.png
new file mode 100644
index 00000000000..e419304ac7d
Binary files /dev/null and b/_static/img/distributed/fsdp_tp.png differ
diff --git a/_static/img/distributed/fsdp_workflow.png b/_static/img/distributed/fsdp_workflow.png
new file mode 100644
index 00000000000..1a8df0e44b6
Binary files /dev/null and b/_static/img/distributed/fsdp_workflow.png differ
diff --git a/_static/img/distributed/loss_parallel.png b/_static/img/distributed/loss_parallel.png
new file mode 100644
index 00000000000..b5cf9a499bc
Binary files /dev/null and b/_static/img/distributed/loss_parallel.png differ
diff --git a/_static/img/distributed/megatron_lm.png b/_static/img/distributed/megatron_lm.png
new file mode 100644
index 00000000000..38f7b06639f
Binary files /dev/null and b/_static/img/distributed/megatron_lm.png differ
diff --git a/_static/img/distributed/tcpstore_barrier_time.png b/_static/img/distributed/tcpstore_barrier_time.png
new file mode 100644
index 00000000000..5ece3a7471d
Binary files /dev/null and b/_static/img/distributed/tcpstore_barrier_time.png differ
diff --git a/_static/img/distributed/tcpstore_init_time.png b/_static/img/distributed/tcpstore_init_time.png
new file mode 100644
index 00000000000..df514b4dc48
Binary files /dev/null and b/_static/img/distributed/tcpstore_init_time.png differ
diff --git a/_static/img/flask.png b/_static/img/flask.png
new file mode 100644
index 00000000000..bad6738efdd
Binary files /dev/null and b/_static/img/flask.png differ
diff --git a/_static/img/half_cheetah.gif b/_static/img/half_cheetah.gif
new file mode 100644
index 00000000000..b61ff47d4e6
Binary files /dev/null and b/_static/img/half_cheetah.gif differ
diff --git a/_static/img/hta/comm_across_ranks.png b/_static/img/hta/comm_across_ranks.png
new file mode 100644
index 00000000000..2336de3bcbc
Binary files /dev/null and b/_static/img/hta/comm_across_ranks.png differ
diff --git a/_static/img/hta/counts_diff.png b/_static/img/hta/counts_diff.png
new file mode 100644
index 00000000000..34575c145de
Binary files /dev/null and b/_static/img/hta/counts_diff.png differ
diff --git a/_static/img/hta/cuda_kernel_launch.png b/_static/img/hta/cuda_kernel_launch.png
new file mode 100644
index 00000000000..e57c54a2fc5
Binary files /dev/null and b/_static/img/hta/cuda_kernel_launch.png differ
diff --git a/_static/img/hta/cuda_kernel_launch_stats.png b/_static/img/hta/cuda_kernel_launch_stats.png
new file mode 100644
index 00000000000..33a160fc752
Binary files /dev/null and b/_static/img/hta/cuda_kernel_launch_stats.png differ
diff --git a/_static/img/hta/duration_diff.png b/_static/img/hta/duration_diff.png
new file mode 100644
index 00000000000..050d491c872
Binary files /dev/null and b/_static/img/hta/duration_diff.png differ
diff --git a/_static/img/hta/idle_time.png b/_static/img/hta/idle_time.png
new file mode 100644
index 00000000000..782bfe9adb5
Binary files /dev/null and b/_static/img/hta/idle_time.png differ
diff --git a/_static/img/hta/idle_time_breakdown_percentage.png b/_static/img/hta/idle_time_breakdown_percentage.png
new file mode 100644
index 00000000000..3bab5946eab
Binary files /dev/null and b/_static/img/hta/idle_time_breakdown_percentage.png differ
diff --git a/_static/img/hta/idle_time_summary.png b/_static/img/hta/idle_time_summary.png
new file mode 100644
index 00000000000..101b696b534
Binary files /dev/null and b/_static/img/hta/idle_time_summary.png differ
diff --git a/_static/img/hta/kernel_metrics_df.png b/_static/img/hta/kernel_metrics_df.png
new file mode 100644
index 00000000000..53eefb58b0c
Binary files /dev/null and b/_static/img/hta/kernel_metrics_df.png differ
diff --git a/_static/img/hta/kernel_type_breakdown.png b/_static/img/hta/kernel_type_breakdown.png
new file mode 100644
index 00000000000..29a29cf89b2
Binary files /dev/null and b/_static/img/hta/kernel_type_breakdown.png differ
diff --git a/_static/img/hta/launch_delay_outliers.png b/_static/img/hta/launch_delay_outliers.png
new file mode 100644
index 00000000000..9bb455adea4
Binary files /dev/null and b/_static/img/hta/launch_delay_outliers.png differ
diff --git a/_static/img/hta/mem_bandwidth_queue_length.png b/_static/img/hta/mem_bandwidth_queue_length.png
new file mode 100644
index 00000000000..9df5383b5d9
Binary files /dev/null and b/_static/img/hta/mem_bandwidth_queue_length.png differ
diff --git a/_static/img/hta/overlap_df.png b/_static/img/hta/overlap_df.png
new file mode 100644
index 00000000000..ef164a28a12
Binary files /dev/null and b/_static/img/hta/overlap_df.png differ
diff --git a/_static/img/hta/overlap_plot.png b/_static/img/hta/overlap_plot.png
new file mode 100644
index 00000000000..acd449bc7ff
Binary files /dev/null and b/_static/img/hta/overlap_plot.png differ
diff --git a/_static/img/hta/pie_charts.png b/_static/img/hta/pie_charts.png
new file mode 100644
index 00000000000..fa9137109a6
Binary files /dev/null and b/_static/img/hta/pie_charts.png differ
diff --git a/_static/img/hta/queue_length_summary.png b/_static/img/hta/queue_length_summary.png
new file mode 100644
index 00000000000..639a03fb6d1
Binary files /dev/null and b/_static/img/hta/queue_length_summary.png differ
diff --git a/_static/img/hta/runtime_outliers.png b/_static/img/hta/runtime_outliers.png
new file mode 100644
index 00000000000..1e2dfff9006
Binary files /dev/null and b/_static/img/hta/runtime_outliers.png differ
diff --git a/_static/img/hta/short_gpu_kernels.png b/_static/img/hta/short_gpu_kernels.png
new file mode 100644
index 00000000000..ff382a3a7f0
Binary files /dev/null and b/_static/img/hta/short_gpu_kernels.png differ
diff --git a/_static/img/hta/temporal_breakdown_df.png b/_static/img/hta/temporal_breakdown_df.png
new file mode 100644
index 00000000000..dce1829d113
Binary files /dev/null and b/_static/img/hta/temporal_breakdown_df.png differ
diff --git a/_static/img/hta/temporal_breakdown_plot.png b/_static/img/hta/temporal_breakdown_plot.png
new file mode 100644
index 00000000000..9c5f45c1d35
Binary files /dev/null and b/_static/img/hta/temporal_breakdown_plot.png differ
diff --git a/_static/img/hybrid.png b/_static/img/hybrid.png
deleted file mode 100755
index d4dc016d863..00000000000
Binary files a/_static/img/hybrid.png and /dev/null differ
diff --git a/_static/img/install_msvc.png b/_static/img/install_msvc.png
new file mode 100644
index 00000000000..fce73207a80
Binary files /dev/null and b/_static/img/install_msvc.png differ
diff --git a/_static/img/invpendulum.gif b/_static/img/invpendulum.gif
new file mode 100644
index 00000000000..3102c5b55cf
Binary files /dev/null and b/_static/img/invpendulum.gif differ
diff --git a/_static/img/itt_tutorial/vtune_config.png b/_static/img/itt_tutorial/vtune_config.png
new file mode 100755
index 00000000000..9f3c4605022
Binary files /dev/null and b/_static/img/itt_tutorial/vtune_config.png differ
diff --git a/_static/img/itt_tutorial/vtune_start.png b/_static/img/itt_tutorial/vtune_start.png
new file mode 100755
index 00000000000..9460df7c5f3
Binary files /dev/null and b/_static/img/itt_tutorial/vtune_start.png differ
diff --git a/_static/img/itt_tutorial/vtune_timeline.png b/_static/img/itt_tutorial/vtune_timeline.png
new file mode 100755
index 00000000000..1f1f018e3fa
Binary files /dev/null and b/_static/img/itt_tutorial/vtune_timeline.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 00000000000..80dd1812d26
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 00000000000..43818cf105c
Binary files /dev/null and b/_static/img/itt_tutorial/vtune_xpu_timeline.png differ
diff --git a/_static/img/knowledge_distillation/ce_only.png b/_static/img/knowledge_distillation/ce_only.png
new file mode 100644
index 00000000000..a7503716575
Binary files /dev/null and b/_static/img/knowledge_distillation/ce_only.png differ
diff --git a/_static/img/knowledge_distillation/cosine_embedding_loss.png b/_static/img/knowledge_distillation/cosine_embedding_loss.png
new file mode 100644
index 00000000000..ebfd957a250
Binary files /dev/null and b/_static/img/knowledge_distillation/cosine_embedding_loss.png differ
diff --git a/_static/img/knowledge_distillation/cosine_loss_distillation.png b/_static/img/knowledge_distillation/cosine_loss_distillation.png
new file mode 100644
index 00000000000..81f241eb07f
Binary files /dev/null and b/_static/img/knowledge_distillation/cosine_loss_distillation.png differ
diff --git a/_static/img/knowledge_distillation/distillation_output_loss.png b/_static/img/knowledge_distillation/distillation_output_loss.png
new file mode 100644
index 00000000000..f86cbddbdfd
Binary files /dev/null and b/_static/img/knowledge_distillation/distillation_output_loss.png differ
diff --git a/_static/img/knowledge_distillation/fitnets_knowledge_distill.png b/_static/img/knowledge_distillation/fitnets_knowledge_distill.png
new file mode 100644
index 00000000000..407d9de89f6
Binary files /dev/null and b/_static/img/knowledge_distillation/fitnets_knowledge_distill.png differ
diff --git a/_static/img/mario.gif b/_static/img/mario.gif
new file mode 100644
index 00000000000..95d8c0cb172
Binary files /dev/null and b/_static/img/mario.gif differ
diff --git a/_static/img/mario_env.png b/_static/img/mario_env.png
new file mode 100644
index 00000000000..b6fc09c3c8c
Binary files /dev/null and b/_static/img/mario_env.png differ
diff --git a/_static/img/memory_format_logo.png b/_static/img/memory_format_logo.png
new file mode 100644
index 00000000000..6d1043ed29a
Binary files /dev/null and b/_static/img/memory_format_logo.png differ
diff --git a/_static/img/mnist.png b/_static/img/mnist.png
old mode 100755
new mode 100644
index a85fc423984..53c876a89d5
Binary files a/_static/img/mnist.png and b/_static/img/mnist.png differ
diff --git a/_static/img/named_tensor.png b/_static/img/named_tensor.png
new file mode 100644
index 00000000000..2efceb9f516
Binary files /dev/null and b/_static/img/named_tensor.png differ
diff --git a/_static/img/nvfuser_intro/nvfuser_transformer_block.png b/_static/img/nvfuser_intro/nvfuser_transformer_block.png
new file mode 100755
index 00000000000..8dd88bbdf94
Binary files /dev/null and b/_static/img/nvfuser_intro/nvfuser_transformer_block.png differ
diff --git a/_static/img/nvfuser_intro/nvfuser_tutorial_0.png b/_static/img/nvfuser_intro/nvfuser_tutorial_0.png
new file mode 100755
index 00000000000..d3448d192bc
Binary files /dev/null and b/_static/img/nvfuser_intro/nvfuser_tutorial_0.png differ
diff --git a/_static/img/nvfuser_intro/nvfuser_tutorial_1.png b/_static/img/nvfuser_intro/nvfuser_tutorial_1.png
new file mode 100755
index 00000000000..4752695fa91
Binary files /dev/null and b/_static/img/nvfuser_intro/nvfuser_tutorial_1.png differ
diff --git a/_static/img/nvfuser_intro/nvfuser_tutorial_2.png b/_static/img/nvfuser_intro/nvfuser_tutorial_2.png
new file mode 100755
index 00000000000..ec45793d67d
Binary files /dev/null and b/_static/img/nvfuser_intro/nvfuser_tutorial_2.png differ
diff --git a/_static/img/nvfuser_intro/nvfuser_tutorial_3.png b/_static/img/nvfuser_intro/nvfuser_tutorial_3.png
new file mode 100755
index 00000000000..be529d93259
Binary files /dev/null and b/_static/img/nvfuser_intro/nvfuser_tutorial_3.png differ
diff --git a/_static/img/nvfuser_intro/nvfuser_tutorial_4.png b/_static/img/nvfuser_intro/nvfuser_tutorial_4.png
new file mode 100755
index 00000000000..f2e7c3ff339
Binary files /dev/null and b/_static/img/nvfuser_intro/nvfuser_tutorial_4.png differ
diff --git a/_static/img/nvfuser_intro/nvfuser_tutorial_5.png b/_static/img/nvfuser_intro/nvfuser_tutorial_5.png
new file mode 100755
index 00000000000..efe43d73741
Binary files /dev/null and b/_static/img/nvfuser_intro/nvfuser_tutorial_5.png differ
diff --git a/_static/img/nvfuser_intro/nvfuser_tutorial_6.png b/_static/img/nvfuser_intro/nvfuser_tutorial_6.png
new file mode 100755
index 00000000000..59a54a87f86
Binary files /dev/null and b/_static/img/nvfuser_intro/nvfuser_tutorial_6.png differ
diff --git a/_static/img/oneworker.png b/_static/img/oneworker.png
new file mode 100644
index 00000000000..255ec584834
Binary files /dev/null and b/_static/img/oneworker.png differ
diff --git a/_static/img/onnx/image_classifier_onnx_model_on_netron_web_ui.png b/_static/img/onnx/image_classifier_onnx_model_on_netron_web_ui.png
new file mode 100644
index 00000000000..6430e4943ff
Binary files /dev/null and b/_static/img/onnx/image_classifier_onnx_model_on_netron_web_ui.png differ
diff --git a/_static/img/onnx/netron_web_ui.png b/_static/img/onnx/netron_web_ui.png
new file mode 100755
index 00000000000..f88936eb824
Binary files /dev/null and b/_static/img/onnx/netron_web_ui.png differ
diff --git a/_static/img/optim_step_in_bwd/snapshot.jpg b/_static/img/optim_step_in_bwd/snapshot.jpg
new file mode 100644
index 00000000000..50be55e7b9a
Binary files /dev/null and b/_static/img/optim_step_in_bwd/snapshot.jpg differ
diff --git a/_static/img/optim_step_in_bwd/snapshot_opt_in_bwd.jpg b/_static/img/optim_step_in_bwd/snapshot_opt_in_bwd.jpg
new file mode 100644
index 00000000000..65d53d21c38
Binary files /dev/null and b/_static/img/optim_step_in_bwd/snapshot_opt_in_bwd.jpg differ
diff --git a/_static/img/pendulum.gif b/_static/img/pendulum.gif
new file mode 100644
index 00000000000..a7adf181fc8
Binary files /dev/null and b/_static/img/pendulum.gif differ
diff --git a/_static/img/per_channel_quant.png b/_static/img/per_channel_quant.png
new file mode 100644
index 00000000000..e28810aca3e
Binary files /dev/null and b/_static/img/per_channel_quant.png differ
diff --git a/_static/img/per_tensor_quant.png b/_static/img/per_tensor_quant.png
new file mode 100644
index 00000000000..183bab6fa3b
Binary files /dev/null and b/_static/img/per_tensor_quant.png differ
diff --git a/_static/img/perf_viz.png b/_static/img/perf_viz.png
new file mode 100644
index 00000000000..85608557bcb
Binary files /dev/null and b/_static/img/perf_viz.png differ
diff --git a/_static/img/pinmem/pinmem.png b/_static/img/pinmem/pinmem.png
new file mode 100644
index 00000000000..9d84e9d229d
Binary files /dev/null and b/_static/img/pinmem/pinmem.png differ
diff --git a/_static/img/pinmem/trace_streamed0_pinned0.png b/_static/img/pinmem/trace_streamed0_pinned0.png
new file mode 100644
index 00000000000..dedac997b0b
Binary files /dev/null and b/_static/img/pinmem/trace_streamed0_pinned0.png differ
diff --git a/_static/img/pinmem/trace_streamed0_pinned1.png b/_static/img/pinmem/trace_streamed0_pinned1.png
new file mode 100644
index 00000000000..2d5ff462e1a
Binary files /dev/null and b/_static/img/pinmem/trace_streamed0_pinned1.png differ
diff --git a/_static/img/pinmem/trace_streamed1_pinned0.png b/_static/img/pinmem/trace_streamed1_pinned0.png
new file mode 100644
index 00000000000..130182a1978
Binary files /dev/null and b/_static/img/pinmem/trace_streamed1_pinned0.png differ
diff --git a/_static/img/pinmem/trace_streamed1_pinned1.png b/_static/img/pinmem/trace_streamed1_pinned1.png
new file mode 100644
index 00000000000..c596fcdb691
Binary files /dev/null and b/_static/img/pinmem/trace_streamed1_pinned1.png differ
diff --git a/_static/img/profiler_callstack.png b/_static/img/profiler_callstack.png
new file mode 100644
index 00000000000..835673ba63c
Binary files /dev/null and b/_static/img/profiler_callstack.png differ
diff --git a/_static/img/profiler_distributed_view.png b/_static/img/profiler_distributed_view.png
new file mode 100644
index 00000000000..2b0d5565131
Binary files /dev/null and b/_static/img/profiler_distributed_view.png differ
diff --git a/_static/img/profiler_kernel_view.png b/_static/img/profiler_kernel_view.png
new file mode 100644
index 00000000000..cfe01b83a0d
Binary files /dev/null and b/_static/img/profiler_kernel_view.png differ
diff --git a/_static/img/profiler_memory_curve_selecting.png b/_static/img/profiler_memory_curve_selecting.png
new file mode 100644
index 00000000000..b5dc0c10e9b
Binary files /dev/null and b/_static/img/profiler_memory_curve_selecting.png differ
diff --git a/_static/img/profiler_memory_curve_single.png b/_static/img/profiler_memory_curve_single.png
new file mode 100644
index 00000000000..c12d480ac40
Binary files /dev/null and b/_static/img/profiler_memory_curve_single.png differ
diff --git a/_static/img/profiler_memory_view.png b/_static/img/profiler_memory_view.png
new file mode 100644
index 00000000000..4839505ab8c
Binary files /dev/null and b/_static/img/profiler_memory_view.png differ
diff --git a/_static/img/profiler_operator_view.png b/_static/img/profiler_operator_view.png
new file mode 100644
index 00000000000..e3e60b03025
Binary files /dev/null and b/_static/img/profiler_operator_view.png differ
diff --git a/_static/img/profiler_overview1.png b/_static/img/profiler_overview1.png
new file mode 100644
index 00000000000..01eef8fda68
Binary files /dev/null and b/_static/img/profiler_overview1.png differ
diff --git a/_static/img/profiler_overview2.png b/_static/img/profiler_overview2.png
new file mode 100644
index 00000000000..cc7826b352a
Binary files /dev/null and b/_static/img/profiler_overview2.png differ
diff --git a/_static/img/profiler_rocm_chrome_trace_view.png b/_static/img/profiler_rocm_chrome_trace_view.png
new file mode 100644
index 00000000000..cff7ba98c8a
Binary files /dev/null and b/_static/img/profiler_rocm_chrome_trace_view.png differ
diff --git a/_static/img/profiler_rocm_tensorboard_operartor_view.png b/_static/img/profiler_rocm_tensorboard_operartor_view.png
new file mode 100644
index 00000000000..27effb91e7c
Binary files /dev/null and b/_static/img/profiler_rocm_tensorboard_operartor_view.png differ
diff --git a/_static/img/profiler_trace_view1.png b/_static/img/profiler_trace_view1.png
new file mode 100644
index 00000000000..215fe03e724
Binary files /dev/null and b/_static/img/profiler_trace_view1.png differ
diff --git a/_static/img/profiler_trace_view2.png b/_static/img/profiler_trace_view2.png
new file mode 100644
index 00000000000..790ef5d58ea
Binary files /dev/null and b/_static/img/profiler_trace_view2.png differ
diff --git a/_static/img/profiler_trace_view_fwd_bwd.png b/_static/img/profiler_trace_view_fwd_bwd.png
new file mode 100644
index 00000000000..c773b829e5d
Binary files /dev/null and b/_static/img/profiler_trace_view_fwd_bwd.png differ
diff --git a/_static/img/profiler_views_list.png b/_static/img/profiler_views_list.png
new file mode 100644
index 00000000000..040f392e366
Binary files /dev/null and b/_static/img/profiler_views_list.png differ
diff --git a/_static/img/profiler_vscode.png b/_static/img/profiler_vscode.png
new file mode 100644
index 00000000000..afb99f06937
Binary files /dev/null and b/_static/img/profiler_vscode.png differ
diff --git a/_static/img/pruning.png b/_static/img/pruning.png
new file mode 100644
index 00000000000..7359f11e9a6
Binary files /dev/null and b/_static/img/pruning.png differ
diff --git a/_static/img/pruning_flow.jpg b/_static/img/pruning_flow.jpg
new file mode 100644
index 00000000000..bd57158b302
Binary files /dev/null and b/_static/img/pruning_flow.jpg differ
diff --git a/_static/img/python_extension_autoload_impl.png b/_static/img/python_extension_autoload_impl.png
new file mode 100644
index 00000000000..64e18fc7b4b
Binary files /dev/null and b/_static/img/python_extension_autoload_impl.png differ
diff --git a/_static/img/qat.png b/_static/img/qat.png
new file mode 100644
index 00000000000..e8ca311745c
Binary files /dev/null and b/_static/img/qat.png differ
diff --git a/_static/img/quant_embeddings.png b/_static/img/quant_embeddings.png
new file mode 100644
index 00000000000..035561465a2
Binary files /dev/null and b/_static/img/quant_embeddings.png differ
diff --git a/_static/img/ray-tune.png b/_static/img/ray-tune.png
new file mode 100644
index 00000000000..febd6de282e
Binary files /dev/null and b/_static/img/ray-tune.png differ
diff --git a/_static/img/reinforcement_learning_diagram.drawio b/_static/img/reinforcement_learning_diagram.drawio
new file mode 100644
index 00000000000..2ff4e6f0270
--- /dev/null
+++ b/_static/img/reinforcement_learning_diagram.drawio
@@ -0,0 +1 @@
+<mxfile host="app.diagrams.net" modified="2022-10-01T16:00:40.980Z" agent="5.0 (X11)" etag="_qbqVrrm3wUvm_i0-Q9T" version="20.4.0" type="device"><diagram id="aSXDm0BvLjt-Za0vl2Tv" name="Page-1">5Vpbc+MmFP41nmkfmpGEpMiPjTftzrTZZtbbbbYvHSxhiRQJFeHb/vqChG4gx95ElqfTeCaGwwEO37lwDskMLNL9zwzmyQONEJk5VrSfgXczx7GtuSW+JOVQUXzXrggxw5FiaglL/BXVMxV1gyNU9Bg5pYTjvE8MaZahkPdokDG667OtKenvmsMYGYRlCIlJ/QNHPKmogWe19PcIx0m9s22pkRTWzIpQJDCiuw4J3M/AglHKq1a6XyAiwatxqeb9dGS0EYyhjJ8z4flQfCient3PwfKXVfTn40P6/vMPapUtJBt14I8oJ/AgaA8opeygZOeHGhBGN1mE5JrWDNztEszRMoehHN0JExC0hKdE9GzRXGNCFpRQVs4Fa09+BD1mMMJC7s7YqvyIsYIz+jfqjPjljxhRsiLG0f4oCHYDrbBJRFPE5SEsNcGt1aPMMVDdXatbu1ZY0tGrr2hQmVPcrNwiLhoK9G9QgGMo4Lec41T6gWN9535v4C/WFLaPTmM/AlrebR8t2z0TruBScAEDLgaziKaCtoI8TAy4wg3bltYqIUFZ9KOMCaIbElgUOOxD1rftai0UGQFCg0/sRzcsRKfdjEMWI37KGkx1dOD2BtCuaQwRyPG2L+6QCtQOjxSLgxz1DRdoWqyOqWZ1I42+kNdfCOjmUOFgLCR0U0aemi2XDMVxgQ3ztK0X5fJtjR/0+EWjkqA1z0YHr7dYz7DYR0pwKM/5AfFRw2sEUbAOh8PrLYI+sgbDaxig1foy4dWxrh1fAzOACodeqi5lPKExzSC5b6laGGh5fqU0V8g/I84PKluBG06HQu8okcN/W+Q4OyS8CWTfsPFPlbz/Cxu/eg5hm0nEmPcg2mP+JNs3nup96Yy823c7h/HvTu8/cXfqV9H8lXen5xxJuUa+O91A2yd4+e709LvTP8Hvvsh/mbvWNtPDUR0hE+I9NVNF50vrFrLb+kLZq52hcaCO+9hTuY9zpvt413Qf3Vqc29e6z1xbyJkm9TSKb51fS4mdKVJP2zXc4fc8grwsLb3rlpaODog3cItaU96ijUdNmirWscHuXq03jjdVeLDnZ8aHI+qcJsGspewFdp8Iee8ivJU7Ehxn5YD/z0a+qN0RtOZtT7Ri9Q1Tac3ZqsjLvvWJQZzhLBbNUmtqXSFnuXQzb5zd7Bvxa5FQWkgvbB4vJDxCgXVlCEOOaXZhURwpylJQiRQFZdsL7wfkfh9RSFkkGql6XrQ2KiRddG9X7t2+rF10L6/ElUpu5VZ/ZWUt1D/piuk76/K8pWyq5S+lHiVi23oGaA9E7PlAxG4Yxw/ZZr4X1q5Vu9AE6V8wP5UAyt4jYlgcG7HrlUhVGL1WkgeO5EDf/r5oDdcuo9dIeqUPXk7ygK/xn3iPNACxJkgKHTMpHNVJBmod6+Z2snzmqmWMrlCgVx/nWjjQLc+7jIUDvYw5ZeFA43emsFjzCf0iYd2ava6q7z2LTVbX18XdyaDvX9UjNIMBevl2tkdo71VATyrG8ghd4LcV6qLb/oW/Ym//TwLc/ws=</diagram></mxfile>
\ No newline at end of file
diff --git a/_static/img/reinforcement_learning_diagram.jpg b/_static/img/reinforcement_learning_diagram.jpg
index bdcbc322502..7e04efc2534 100644
Binary files a/_static/img/reinforcement_learning_diagram.jpg and b/_static/img/reinforcement_learning_diagram.jpg differ
diff --git a/_static/img/replaybuffer_traj.png b/_static/img/replaybuffer_traj.png
new file mode 100644
index 00000000000..64773ee8f78
Binary files /dev/null and b/_static/img/replaybuffer_traj.png differ
diff --git a/_static/img/rollout_recurrent.png b/_static/img/rollout_recurrent.png
new file mode 100644
index 00000000000..2ce24d40d23
Binary files /dev/null and b/_static/img/rollout_recurrent.png differ
diff --git a/_static/img/rpc-images/batch.png b/_static/img/rpc-images/batch.png
new file mode 100644
index 00000000000..cde410d1bd1
Binary files /dev/null and b/_static/img/rpc-images/batch.png differ
diff --git a/_static/img/rpc_trace_img.png b/_static/img/rpc_trace_img.png
new file mode 100644
index 00000000000..4faaf97ad47
Binary files /dev/null and b/_static/img/rpc_trace_img.png differ
diff --git a/_static/img/sample_file.jpeg b/_static/img/sample_file.jpeg
new file mode 100644
index 00000000000..a7b314bd969
Binary files /dev/null and b/_static/img/sample_file.jpeg differ
diff --git a/_static/img/seq-seq-images/attention-decoder-network.png b/_static/img/seq-seq-images/attention-decoder-network.png
index 243f87c6e97..d31d42a5af1 100755
Binary files a/_static/img/seq-seq-images/attention-decoder-network.png and b/_static/img/seq-seq-images/attention-decoder-network.png differ
diff --git a/_static/img/steam-train-whistle-daniel_simon-converted-from-mp3.wav b/_static/img/steam-train-whistle-daniel_simon-converted-from-mp3.wav
new file mode 100644
index 00000000000..3f899c9dadd
Binary files /dev/null and b/_static/img/steam-train-whistle-daniel_simon-converted-from-mp3.wav differ
diff --git a/_static/img/tensorboard_figure.png b/_static/img/tensorboard_figure.png
new file mode 100644
index 00000000000..e4dd38e98da
Binary files /dev/null and b/_static/img/tensorboard_figure.png differ
diff --git a/_static/img/tensorboard_first_view.png b/_static/img/tensorboard_first_view.png
new file mode 100644
index 00000000000..702c8158a82
Binary files /dev/null and b/_static/img/tensorboard_first_view.png differ
diff --git a/_static/img/tensorboard_images.png b/_static/img/tensorboard_images.png
new file mode 100644
index 00000000000..79b7e15a7af
Binary files /dev/null and b/_static/img/tensorboard_images.png differ
diff --git a/_static/img/tensorboard_model_viz.png b/_static/img/tensorboard_model_viz.png
new file mode 100644
index 00000000000..2cd22344f15
Binary files /dev/null and b/_static/img/tensorboard_model_viz.png differ
diff --git a/_static/img/tensorboard_pr_curves.png b/_static/img/tensorboard_pr_curves.png
new file mode 100644
index 00000000000..0360187eae6
Binary files /dev/null and b/_static/img/tensorboard_pr_curves.png differ
diff --git a/_static/img/tensorboard_projector.png b/_static/img/tensorboard_projector.png
new file mode 100644
index 00000000000..f709efc32d0
Binary files /dev/null and b/_static/img/tensorboard_projector.png differ
diff --git a/_static/img/tensorboard_scalar_runs.png b/_static/img/tensorboard_scalar_runs.png
new file mode 100644
index 00000000000..f89ace713aa
Binary files /dev/null and b/_static/img/tensorboard_scalar_runs.png differ
diff --git a/_static/img/text_sentiment_ngrams_model.png b/_static/img/text_sentiment_ngrams_model.png
new file mode 100644
index 00000000000..94fdf554047
Binary files /dev/null and b/_static/img/text_sentiment_ngrams_model.png differ
diff --git a/_static/img/thumbnails/captum_teaser.png b/_static/img/thumbnails/captum_teaser.png
new file mode 100644
index 00000000000..c7fcb2c093a
Binary files /dev/null and b/_static/img/thumbnails/captum_teaser.png differ
diff --git a/_static/img/thumbnails/cropped/60-min-blitz.png b/_static/img/thumbnails/cropped/60-min-blitz.png
new file mode 100644
index 00000000000..681a16d9935
Binary files /dev/null and b/_static/img/thumbnails/cropped/60-min-blitz.png differ
diff --git a/_static/img/thumbnails/cropped/Adversarial-Example-Generation.png b/_static/img/thumbnails/cropped/Adversarial-Example-Generation.png
new file mode 100644
index 00000000000..ad5014e805c
Binary files /dev/null and b/_static/img/thumbnails/cropped/Adversarial-Example-Generation.png differ
diff --git a/_static/img/thumbnails/cropped/Autograd-in-Cpp-Frontend.png b/_static/img/thumbnails/cropped/Autograd-in-Cpp-Frontend.png
new file mode 100644
index 00000000000..3aec75031ae
Binary files /dev/null and b/_static/img/thumbnails/cropped/Autograd-in-Cpp-Frontend.png differ
diff --git a/_static/img/thumbnails/cropped/Combining-Distributed-DataParallel-with-Distributed-RPC-Framework.png b/_static/img/thumbnails/cropped/Combining-Distributed-DataParallel-with-Distributed-RPC-Framework.png
new file mode 100644
index 00000000000..426a14d98f5
Binary files /dev/null and b/_static/img/thumbnails/cropped/Combining-Distributed-DataParallel-with-Distributed-RPC-Framework.png differ
diff --git a/_static/img/thumbnails/cropped/Custom-Cpp-and-CUDA-Extensions.png b/_static/img/thumbnails/cropped/Custom-Cpp-and-CUDA-Extensions.png
new file mode 100644
index 00000000000..426a14d98f5
Binary files /dev/null and b/_static/img/thumbnails/cropped/Custom-Cpp-and-CUDA-Extensions.png differ
diff --git a/_static/img/thumbnails/cropped/Customize-Process-Group-Backends-Using-Cpp-Extensions.png b/_static/img/thumbnails/cropped/Customize-Process-Group-Backends-Using-Cpp-Extensions.png
new file mode 100644
index 00000000000..426a14d98f5
Binary files /dev/null and b/_static/img/thumbnails/cropped/Customize-Process-Group-Backends-Using-Cpp-Extensions.png differ
diff --git a/_static/img/thumbnails/cropped/DCGAN-Tutorial.png b/_static/img/thumbnails/cropped/DCGAN-Tutorial.png
new file mode 100644
index 00000000000..a0c89096e9a
Binary files /dev/null and b/_static/img/thumbnails/cropped/DCGAN-Tutorial.png differ
diff --git a/_static/img/thumbnails/cropped/Deploying-PyTorch-in-Python-via-a-REST-API-with-Flask.png b/_static/img/thumbnails/cropped/Deploying-PyTorch-in-Python-via-a-REST-API-with-Flask.png
new file mode 100644
index 00000000000..426a14d98f5
Binary files /dev/null and b/_static/img/thumbnails/cropped/Deploying-PyTorch-in-Python-via-a-REST-API-with-Flask.png differ
diff --git a/_static/img/thumbnails/cropped/Distributed-Pipeline-Parallelism-Using-RPC.png b/_static/img/thumbnails/cropped/Distributed-Pipeline-Parallelism-Using-RPC.png
new file mode 100644
index 00000000000..426a14d98f5
Binary files /dev/null and b/_static/img/thumbnails/cropped/Distributed-Pipeline-Parallelism-Using-RPC.png differ
diff --git a/_static/img/thumbnails/cropped/Exporting-PyTorch-Models-to-ONNX-Graphs.png b/_static/img/thumbnails/cropped/Exporting-PyTorch-Models-to-ONNX-Graphs.png
new file mode 100755
index 00000000000..00156df042e
Binary files /dev/null and b/_static/img/thumbnails/cropped/Exporting-PyTorch-Models-to-ONNX-Graphs.png differ
diff --git a/_static/img/thumbnails/cropped/Extending-TorchScript-with-Custom-Cpp-Classes.png b/_static/img/thumbnails/cropped/Extending-TorchScript-with-Custom-Cpp-Classes.png
new file mode 100644
index 00000000000..426a14d98f5
Binary files /dev/null and b/_static/img/thumbnails/cropped/Extending-TorchScript-with-Custom-Cpp-Classes.png differ
diff --git a/_static/img/thumbnails/cropped/Extending-TorchScript-with-Custom-Cpp-Operators.png b/_static/img/thumbnails/cropped/Extending-TorchScript-with-Custom-Cpp-Operators.png
new file mode 100644
index 00000000000..426a14d98f5
Binary files /dev/null and b/_static/img/thumbnails/cropped/Extending-TorchScript-with-Custom-Cpp-Operators.png differ
diff --git a/_static/img/thumbnails/cropped/Getting Started with Distributed-RPC-Framework.png b/_static/img/thumbnails/cropped/Getting Started with Distributed-RPC-Framework.png
new file mode 100644
index 00000000000..426a14d98f5
Binary files /dev/null and b/_static/img/thumbnails/cropped/Getting Started with Distributed-RPC-Framework.png differ
diff --git a/_static/img/thumbnails/cropped/Getting-Started-with Distributed RPC Framework.png b/_static/img/thumbnails/cropped/Getting-Started-with Distributed RPC Framework.png
new file mode 100644
index 00000000000..426a14d98f5
Binary files /dev/null and b/_static/img/thumbnails/cropped/Getting-Started-with Distributed RPC Framework.png differ
diff --git a/_static/img/thumbnails/cropped/Getting-Started-with-DCP.png b/_static/img/thumbnails/cropped/Getting-Started-with-DCP.png
new file mode 100644
index 00000000000..426a14d98f5
Binary files /dev/null and b/_static/img/thumbnails/cropped/Getting-Started-with-DCP.png differ
diff --git a/_static/img/thumbnails/cropped/Getting-Started-with-Distributed-Data-Parallel.png b/_static/img/thumbnails/cropped/Getting-Started-with-Distributed-Data-Parallel.png
new file mode 100644
index 00000000000..426a14d98f5
Binary files /dev/null and b/_static/img/thumbnails/cropped/Getting-Started-with-Distributed-Data-Parallel.png differ
diff --git a/_static/img/thumbnails/cropped/Getting-Started-with-Distributed-RPC-Framework.png b/_static/img/thumbnails/cropped/Getting-Started-with-Distributed-RPC-Framework.png
new file mode 100644
index 00000000000..426a14d98f5
Binary files /dev/null and b/_static/img/thumbnails/cropped/Getting-Started-with-Distributed-RPC-Framework.png differ
diff --git a/_static/img/thumbnails/cropped/Getting-Started-with-FSDP.png b/_static/img/thumbnails/cropped/Getting-Started-with-FSDP.png
new file mode 100644
index 00000000000..426a14d98f5
Binary files /dev/null and b/_static/img/thumbnails/cropped/Getting-Started-with-FSDP.png differ
diff --git a/_static/img/thumbnails/cropped/Implementing-Batch-RPC-Processing-Using-Asynchronous-Executions.png b/_static/img/thumbnails/cropped/Implementing-Batch-RPC-Processing-Using-Asynchronous-Executions.png
new file mode 100644
index 00000000000..426a14d98f5
Binary files /dev/null and b/_static/img/thumbnails/cropped/Implementing-Batch-RPC-Processing-Using-Asynchronous-Executions.png differ
diff --git a/_static/img/thumbnails/cropped/Implementing-a-Parameter-Server-Using-Distributed-RPC-Framework.png b/_static/img/thumbnails/cropped/Implementing-a-Parameter-Server-Using-Distributed-RPC-Framework.png
new file mode 100644
index 00000000000..426a14d98f5
Binary files /dev/null and b/_static/img/thumbnails/cropped/Implementing-a-Parameter-Server-Using-Distributed-RPC-Framework.png differ
diff --git a/_static/img/thumbnails/cropped/Introduction-to-TorchScript.png b/_static/img/thumbnails/cropped/Introduction-to-TorchScript.png
new file mode 100644
index 00000000000..426a14d98f5
Binary files /dev/null and b/_static/img/thumbnails/cropped/Introduction-to-TorchScript.png differ
diff --git a/_static/img/thumbnails/cropped/Language-Translation-with-TorchText.png b/_static/img/thumbnails/cropped/Language-Translation-with-TorchText.png
new file mode 100644
index 00000000000..9330c6cbdb5
Binary files /dev/null and b/_static/img/thumbnails/cropped/Language-Translation-with-TorchText.png differ
diff --git a/_static/img/thumbnails/cropped/Large-Scale-Transformer-model-training-with-Tensor-Parallel.png b/_static/img/thumbnails/cropped/Large-Scale-Transformer-model-training-with-Tensor-Parallel.png
new file mode 100644
index 00000000000..426a14d98f5
Binary files /dev/null and b/_static/img/thumbnails/cropped/Large-Scale-Transformer-model-training-with-Tensor-Parallel.png differ
diff --git a/_static/img/thumbnails/cropped/Loading-a-TorchScript-Model-in-Cpp.png b/_static/img/thumbnails/cropped/Loading-a-TorchScript-Model-in-Cpp.png
new file mode 100644
index 00000000000..426a14d98f5
Binary files /dev/null and b/_static/img/thumbnails/cropped/Loading-a-TorchScript-Model-in-Cpp.png differ
diff --git a/_static/img/thumbnails/cropped/Model-Parallel-Best-Practices.png b/_static/img/thumbnails/cropped/Model-Parallel-Best-Practices.png
new file mode 100644
index 00000000000..426a14d98f5
Binary files /dev/null and b/_static/img/thumbnails/cropped/Model-Parallel-Best-Practices.png differ
diff --git a/_static/img/thumbnails/cropped/NLP-From-Scratch-Classifying-Names-with-a-Character-Level-RNN.png b/_static/img/thumbnails/cropped/NLP-From-Scratch-Classifying-Names-with-a-Character-Level-RNN.png
new file mode 100644
index 00000000000..0aa02de9a53
Binary files /dev/null and b/_static/img/thumbnails/cropped/NLP-From-Scratch-Classifying-Names-with-a-Character-Level-RNN.png differ
diff --git a/_static/img/thumbnails/cropped/NLP-From-Scratch-Generating-Names-with-a-Character-Level-RNN.png b/_static/img/thumbnails/cropped/NLP-From-Scratch-Generating-Names-with-a-Character-Level-RNN.png
new file mode 100644
index 00000000000..a63d82ba4b4
Binary files /dev/null and b/_static/img/thumbnails/cropped/NLP-From-Scratch-Generating-Names-with-a-Character-Level-RNN.png differ
diff --git a/_static/img/thumbnails/cropped/NLP-From-Scratch-Translation-with-a-Sequence-to-Sequence-Network-and-Attention.png b/_static/img/thumbnails/cropped/NLP-From-Scratch-Translation-with-a-Sequence-to-Sequence-Network-and-Attention.png
new file mode 100644
index 00000000000..11d4f07c3bf
Binary files /dev/null and b/_static/img/thumbnails/cropped/NLP-From-Scratch-Translation-with-a-Sequence-to-Sequence-Network-and-Attention.png differ
diff --git a/_static/img/thumbnails/cropped/Pruning-Tutorial.png b/_static/img/thumbnails/cropped/Pruning-Tutorial.png
new file mode 100644
index 00000000000..32953c7ab19
Binary files /dev/null and b/_static/img/thumbnails/cropped/Pruning-Tutorial.png differ
diff --git a/_static/img/thumbnails/cropped/PyTorch-Distributed-Overview.png b/_static/img/thumbnails/cropped/PyTorch-Distributed-Overview.png
new file mode 100644
index 00000000000..426a14d98f5
Binary files /dev/null and b/_static/img/thumbnails/cropped/PyTorch-Distributed-Overview.png differ
diff --git a/_static/img/thumbnails/cropped/Sequence-to-Sequence-Modeling-with-nnTransformer-andTorchText.png b/_static/img/thumbnails/cropped/Sequence-to-Sequence-Modeling-with-nnTransformer-andTorchText.png
new file mode 100644
index 00000000000..00c4a236f24
Binary files /dev/null and b/_static/img/thumbnails/cropped/Sequence-to-Sequence-Modeling-with-nnTransformer-andTorchText.png differ
diff --git a/_static/img/thumbnails/cropped/TIAToolbox-Tutorial.png b/_static/img/thumbnails/cropped/TIAToolbox-Tutorial.png
new file mode 100644
index 00000000000..76f2bcaf4de
Binary files /dev/null and b/_static/img/thumbnails/cropped/TIAToolbox-Tutorial.png differ
diff --git a/_static/img/thumbnails/cropped/Text-Classification-with-TorchText.png b/_static/img/thumbnails/cropped/Text-Classification-with-TorchText.png
new file mode 100644
index 00000000000..e46aa333390
Binary files /dev/null and b/_static/img/thumbnails/cropped/Text-Classification-with-TorchText.png differ
diff --git a/_static/img/thumbnails/cropped/TorchScript-Parallelism.jpg b/_static/img/thumbnails/cropped/TorchScript-Parallelism.jpg
new file mode 100644
index 00000000000..237990a0460
Binary files /dev/null and b/_static/img/thumbnails/cropped/TorchScript-Parallelism.jpg differ
diff --git a/_static/img/thumbnails/cropped/TorchVision-Object-Detection-Finetuning-Tutorial.png b/_static/img/thumbnails/cropped/TorchVision-Object-Detection-Finetuning-Tutorial.png
new file mode 100644
index 00000000000..e79ff0d395e
Binary files /dev/null and b/_static/img/thumbnails/cropped/TorchVision-Object-Detection-Finetuning-Tutorial.png differ
diff --git a/_static/img/thumbnails/cropped/Training-Transformer-Models-using-Distributed-Data-Parallel-and-Pipeline-Parallelism.png b/_static/img/thumbnails/cropped/Training-Transformer-Models-using-Distributed-Data-Parallel-and-Pipeline-Parallelism.png
new file mode 100644
index 00000000000..426a14d98f5
Binary files /dev/null and b/_static/img/thumbnails/cropped/Training-Transformer-Models-using-Distributed-Data-Parallel-and-Pipeline-Parallelism.png differ
diff --git a/_static/img/thumbnails/cropped/Training-Transformer-models-using-Pipeline-Parallelism.png b/_static/img/thumbnails/cropped/Training-Transformer-models-using-Pipeline-Parallelism.png
new file mode 100644
index 00000000000..426a14d98f5
Binary files /dev/null and b/_static/img/thumbnails/cropped/Training-Transformer-models-using-Pipeline-Parallelism.png differ
diff --git a/_static/img/thumbnails/cropped/Transfer-Learning-for-Computer-Vision-Tutorial.png b/_static/img/thumbnails/cropped/Transfer-Learning-for-Computer-Vision-Tutorial.png
new file mode 100644
index 00000000000..029f0ff1bea
Binary files /dev/null and b/_static/img/thumbnails/cropped/Transfer-Learning-for-Computer-Vision-Tutorial.png differ
diff --git a/_static/img/thumbnails/cropped/Tutorials_Card_Template.psd b/_static/img/thumbnails/cropped/Tutorials_Card_Template.psd
new file mode 100644
index 00000000000..6caf48a5951
Binary files /dev/null and b/_static/img/thumbnails/cropped/Tutorials_Card_Template.psd differ
diff --git a/_static/img/thumbnails/cropped/Using-the-PyTorch-Cpp-Frontend.png b/_static/img/thumbnails/cropped/Using-the-PyTorch-Cpp-Frontend.png
new file mode 100644
index 00000000000..3aec75031ae
Binary files /dev/null and b/_static/img/thumbnails/cropped/Using-the-PyTorch-Cpp-Frontend.png differ
diff --git a/_static/img/thumbnails/cropped/Writing-Distributed-Applications-with-PyTorch.png b/_static/img/thumbnails/cropped/Writing-Distributed-Applications-with-PyTorch.png
new file mode 100644
index 00000000000..426a14d98f5
Binary files /dev/null and b/_static/img/thumbnails/cropped/Writing-Distributed-Applications-with-PyTorch.png differ
diff --git a/_static/img/thumbnails/cropped/advanced-PyTorch-1point0-Distributed-Trainer-with-Amazon-AWS.png b/_static/img/thumbnails/cropped/advanced-PyTorch-1point0-Distributed-Trainer-with-Amazon-AWS.png
new file mode 100644
index 00000000000..426a14d98f5
Binary files /dev/null and b/_static/img/thumbnails/cropped/advanced-PyTorch-1point0-Distributed-Trainer-with-Amazon-AWS.png differ
diff --git a/_static/img/thumbnails/cropped/amp.png b/_static/img/thumbnails/cropped/amp.png
new file mode 100644
index 00000000000..a6916ce5605
Binary files /dev/null and b/_static/img/thumbnails/cropped/amp.png differ
diff --git a/_static/img/thumbnails/cropped/android.png b/_static/img/thumbnails/cropped/android.png
new file mode 100644
index 00000000000..5c6079d9090
Binary files /dev/null and b/_static/img/thumbnails/cropped/android.png differ
diff --git a/_static/img/thumbnails/cropped/custom-datasets-transforms-and-dataloaders.png b/_static/img/thumbnails/cropped/custom-datasets-transforms-and-dataloaders.png
new file mode 100644
index 00000000000..5f73aa5663c
Binary files /dev/null and b/_static/img/thumbnails/cropped/custom-datasets-transforms-and-dataloaders.png differ
diff --git a/_static/img/thumbnails/cropped/defining-a-network.PNG b/_static/img/thumbnails/cropped/defining-a-network.PNG
new file mode 100644
index 00000000000..ded6a9ed583
Binary files /dev/null and b/_static/img/thumbnails/cropped/defining-a-network.PNG differ
diff --git a/_static/img/thumbnails/cropped/experimental-Channels-Last-Memory-Format-in-PyTorch.png b/_static/img/thumbnails/cropped/experimental-Channels-Last-Memory-Format-in-PyTorch.png
new file mode 100644
index 00000000000..18cbc1d0bc2
Binary files /dev/null and b/_static/img/thumbnails/cropped/experimental-Channels-Last-Memory-Format-in-PyTorch.png differ
diff --git a/_static/img/thumbnails/cropped/experimental-Introduction-to-Named-Tensors-in-PyTorch.png b/_static/img/thumbnails/cropped/experimental-Introduction-to-Named-Tensors-in-PyTorch.png
new file mode 100644
index 00000000000..d52414ec275
Binary files /dev/null and b/_static/img/thumbnails/cropped/experimental-Introduction-to-Named-Tensors-in-PyTorch.png differ
diff --git a/_static/img/thumbnails/cropped/experimental-Quantized-Transfer-Learning-for-Computer-Vision-Tutorial.png b/_static/img/thumbnails/cropped/experimental-Quantized-Transfer-Learning-for-Computer-Vision-Tutorial.png
new file mode 100644
index 00000000000..d826d8170c1
Binary files /dev/null and b/_static/img/thumbnails/cropped/experimental-Quantized-Transfer-Learning-for-Computer-Vision-Tutorial.png differ
diff --git a/_static/img/thumbnails/cropped/experimental-Static-Quantization-with-Eager-Mode-in-PyTorch.png b/_static/img/thumbnails/cropped/experimental-Static-Quantization-with-Eager-Mode-in-PyTorch.png
new file mode 100644
index 00000000000..d826d8170c1
Binary files /dev/null and b/_static/img/thumbnails/cropped/experimental-Static-Quantization-with-Eager-Mode-in-PyTorch.png differ
diff --git a/_static/img/thumbnails/cropped/generic-pytorch-logo.png b/_static/img/thumbnails/cropped/generic-pytorch-logo.png
new file mode 100644
index 00000000000..426a14d98f5
Binary files /dev/null and b/_static/img/thumbnails/cropped/generic-pytorch-logo.png differ
diff --git a/_static/img/thumbnails/cropped/ios.png b/_static/img/thumbnails/cropped/ios.png
new file mode 100644
index 00000000000..8c1d4a2b04d
Binary files /dev/null and b/_static/img/thumbnails/cropped/ios.png differ
diff --git a/_static/img/thumbnails/cropped/knowledge_distillation_pytorch_logo.png b/_static/img/thumbnails/cropped/knowledge_distillation_pytorch_logo.png
new file mode 100644
index 00000000000..3ce40781542
Binary files /dev/null and b/_static/img/thumbnails/cropped/knowledge_distillation_pytorch_logo.png differ
diff --git a/_static/img/thumbnails/cropped/learning-pytorch-with-examples.png b/_static/img/thumbnails/cropped/learning-pytorch-with-examples.png
new file mode 100644
index 00000000000..b292603835b
Binary files /dev/null and b/_static/img/thumbnails/cropped/learning-pytorch-with-examples.png differ
diff --git a/_static/img/thumbnails/cropped/loading-data-in-pytorch.png b/_static/img/thumbnails/cropped/loading-data-in-pytorch.png
new file mode 100644
index 00000000000..20309e32cf5
Binary files /dev/null and b/_static/img/thumbnails/cropped/loading-data-in-pytorch.png differ
diff --git a/_static/img/thumbnails/cropped/loading-data.PNG b/_static/img/thumbnails/cropped/loading-data.PNG
new file mode 100644
index 00000000000..0cb07e34e5e
Binary files /dev/null and b/_static/img/thumbnails/cropped/loading-data.PNG differ
diff --git a/_static/img/thumbnails/cropped/model-interpretability-using-captum.png b/_static/img/thumbnails/cropped/model-interpretability-using-captum.png
new file mode 100644
index 00000000000..2e531ae27c9
Binary files /dev/null and b/_static/img/thumbnails/cropped/model-interpretability-using-captum.png differ
diff --git a/_static/img/thumbnails/cropped/parametrizations.png b/_static/img/thumbnails/cropped/parametrizations.png
new file mode 100644
index 00000000000..426a14d98f5
Binary files /dev/null and b/_static/img/thumbnails/cropped/parametrizations.png differ
diff --git a/_static/img/thumbnails/cropped/profile.png b/_static/img/thumbnails/cropped/profile.png
new file mode 100644
index 00000000000..372db8bbe87
Binary files /dev/null and b/_static/img/thumbnails/cropped/profile.png differ
diff --git a/_static/img/thumbnails/cropped/profiler.png b/_static/img/thumbnails/cropped/profiler.png
new file mode 100644
index 00000000000..426a14d98f5
Binary files /dev/null and b/_static/img/thumbnails/cropped/profiler.png differ
diff --git a/_static/img/thumbnails/cropped/pytorch-logo.png b/_static/img/thumbnails/cropped/pytorch-logo.png
new file mode 100644
index 00000000000..426a14d98f5
Binary files /dev/null and b/_static/img/thumbnails/cropped/pytorch-logo.png differ
diff --git a/_static/img/thumbnails/cropped/realtime_rpi.png b/_static/img/thumbnails/cropped/realtime_rpi.png
new file mode 100644
index 00000000000..b233f3df3a1
Binary files /dev/null and b/_static/img/thumbnails/cropped/realtime_rpi.png differ
diff --git a/_static/img/thumbnails/cropped/saving-and-loading-general-checkpoint.PNG b/_static/img/thumbnails/cropped/saving-and-loading-general-checkpoint.PNG
new file mode 100644
index 00000000000..ba351430712
Binary files /dev/null and b/_static/img/thumbnails/cropped/saving-and-loading-general-checkpoint.PNG differ
diff --git a/_static/img/thumbnails/cropped/saving-and-loading-models-across-devices.PNG b/_static/img/thumbnails/cropped/saving-and-loading-models-across-devices.PNG
new file mode 100644
index 00000000000..a1c337928a1
Binary files /dev/null and b/_static/img/thumbnails/cropped/saving-and-loading-models-across-devices.PNG differ
diff --git a/_static/img/thumbnails/cropped/saving-and-loading-models-for-inference.PNG b/_static/img/thumbnails/cropped/saving-and-loading-models-for-inference.PNG
new file mode 100644
index 00000000000..b8075559c1d
Binary files /dev/null and b/_static/img/thumbnails/cropped/saving-and-loading-models-for-inference.PNG differ
diff --git a/_static/img/thumbnails/cropped/saving-multiple-models.PNG b/_static/img/thumbnails/cropped/saving-multiple-models.PNG
new file mode 100644
index 00000000000..2917cac557a
Binary files /dev/null and b/_static/img/thumbnails/cropped/saving-multiple-models.PNG differ
diff --git a/_static/img/thumbnails/cropped/torch-nn.png b/_static/img/thumbnails/cropped/torch-nn.png
new file mode 100644
index 00000000000..44a3e8dca1d
Binary files /dev/null and b/_static/img/thumbnails/cropped/torch-nn.png differ
diff --git a/_static/img/thumbnails/cropped/torch_text_logo.png b/_static/img/thumbnails/cropped/torch_text_logo.png
new file mode 100644
index 00000000000..3fe736d60e2
Binary files /dev/null and b/_static/img/thumbnails/cropped/torch_text_logo.png differ
diff --git a/_static/img/thumbnails/cropped/torchaudio-Tutorial.png b/_static/img/thumbnails/cropped/torchaudio-Tutorial.png
new file mode 100644
index 00000000000..c49aa17c02f
Binary files /dev/null and b/_static/img/thumbnails/cropped/torchaudio-Tutorial.png differ
diff --git a/_static/img/thumbnails/cropped/torchaudio-alignment.png b/_static/img/thumbnails/cropped/torchaudio-alignment.png
new file mode 100644
index 00000000000..d5a25f35219
Binary files /dev/null and b/_static/img/thumbnails/cropped/torchaudio-alignment.png differ
diff --git a/_static/img/thumbnails/cropped/torchaudio-asr.png b/_static/img/thumbnails/cropped/torchaudio-asr.png
new file mode 100644
index 00000000000..ff84f3ff3f1
Binary files /dev/null and b/_static/img/thumbnails/cropped/torchaudio-asr.png differ
diff --git a/_static/img/thumbnails/cropped/torchaudio-speech.png b/_static/img/thumbnails/cropped/torchaudio-speech.png
new file mode 100644
index 00000000000..c874a6bb482
Binary files /dev/null and b/_static/img/thumbnails/cropped/torchaudio-speech.png differ
diff --git a/_static/img/thumbnails/cropped/torchscript_overview.png b/_static/img/thumbnails/cropped/torchscript_overview.png
new file mode 100644
index 00000000000..63e599b1a80
Binary files /dev/null and b/_static/img/thumbnails/cropped/torchscript_overview.png differ
diff --git a/_static/img/thumbnails/cropped/understanding_leaf_vs_nonleaf.png b/_static/img/thumbnails/cropped/understanding_leaf_vs_nonleaf.png
new file mode 100644
index 00000000000..0590cf227d9
Binary files /dev/null and b/_static/img/thumbnails/cropped/understanding_leaf_vs_nonleaf.png differ
diff --git a/_static/img/thumbnails/cropped/using-flask-create-restful-api.png b/_static/img/thumbnails/cropped/using-flask-create-restful-api.png
new file mode 100644
index 00000000000..176c4de6d5b
Binary files /dev/null and b/_static/img/thumbnails/cropped/using-flask-create-restful-api.png differ
diff --git a/_static/img/thumbnails/cropped/visualizing-with-tensorboard.png b/_static/img/thumbnails/cropped/visualizing-with-tensorboard.png
new file mode 100644
index 00000000000..8fdecca65fe
Binary files /dev/null and b/_static/img/thumbnails/cropped/visualizing-with-tensorboard.png differ
diff --git a/_static/img/thumbnails/cropped/visualizing_gradients_tutorial.png b/_static/img/thumbnails/cropped/visualizing_gradients_tutorial.png
new file mode 100644
index 00000000000..6ff6d97f2e2
Binary files /dev/null and b/_static/img/thumbnails/cropped/visualizing_gradients_tutorial.png differ
diff --git a/_static/img/thumbnails/cropped/warmstarting-models.PNG b/_static/img/thumbnails/cropped/warmstarting-models.PNG
new file mode 100644
index 00000000000..385f2ab80c8
Binary files /dev/null and b/_static/img/thumbnails/cropped/warmstarting-models.PNG differ
diff --git a/_static/img/thumbnails/cropped/what-is-a-state-dict.PNG b/_static/img/thumbnails/cropped/what-is-a-state-dict.PNG
new file mode 100644
index 00000000000..b0eee89ad73
Binary files /dev/null and b/_static/img/thumbnails/cropped/what-is-a-state-dict.PNG differ
diff --git a/_static/img/thumbnails/cropped/zeroing-out-gradients.PNG b/_static/img/thumbnails/cropped/zeroing-out-gradients.PNG
new file mode 100644
index 00000000000..0f21b230abf
Binary files /dev/null and b/_static/img/thumbnails/cropped/zeroing-out-gradients.PNG differ
diff --git a/_static/img/thumbnails/custom_dataset.png b/_static/img/thumbnails/custom_dataset.png
new file mode 100644
index 00000000000..59a8993bc4a
Binary files /dev/null and b/_static/img/thumbnails/custom_dataset.png differ
diff --git a/_static/img/thumbnails/defining_a_network.png b/_static/img/thumbnails/defining_a_network.png
new file mode 100644
index 00000000000..f0c0a940713
Binary files /dev/null and b/_static/img/thumbnails/defining_a_network.png differ
diff --git a/_static/img/thumbnails/german_to_english_translation.png b/_static/img/thumbnails/german_to_english_translation.png
new file mode 100644
index 00000000000..a3560c574a6
Binary files /dev/null and b/_static/img/thumbnails/german_to_english_translation.png differ
diff --git a/_static/img/thumbnails/pixelated-cat.png b/_static/img/thumbnails/pixelated-cat.png
new file mode 100644
index 00000000000..c3d527f0691
Binary files /dev/null and b/_static/img/thumbnails/pixelated-cat.png differ
diff --git a/_static/img/thumbnails/pytorch_tensorboard.png b/_static/img/thumbnails/pytorch_tensorboard.png
new file mode 100644
index 00000000000..2dce6a6e268
Binary files /dev/null and b/_static/img/thumbnails/pytorch_tensorboard.png differ
diff --git a/_static/img/thumbnails/tensorboard_dev.png b/_static/img/thumbnails/tensorboard_dev.png
new file mode 100644
index 00000000000..056839a6359
Binary files /dev/null and b/_static/img/thumbnails/tensorboard_dev.png differ
diff --git a/_static/img/thumbnails/tensorboard_scalars.png b/_static/img/thumbnails/tensorboard_scalars.png
new file mode 100644
index 00000000000..ab6734ab3e9
Binary files /dev/null and b/_static/img/thumbnails/tensorboard_scalars.png differ
diff --git a/_static/img/thumbnails/torchrec.png b/_static/img/thumbnails/torchrec.png
new file mode 100644
index 00000000000..1304b56873e
Binary files /dev/null and b/_static/img/thumbnails/torchrec.png differ
diff --git a/_static/img/thumbnails/torchtext.png b/_static/img/thumbnails/torchtext.png
new file mode 100644
index 00000000000..ee4285aef34
Binary files /dev/null and b/_static/img/thumbnails/torchtext.png differ
diff --git a/_static/img/torchscript.png b/_static/img/torchscript.png
new file mode 100644
index 00000000000..b748d45d231
Binary files /dev/null and b/_static/img/torchscript.png differ
diff --git a/_static/img/torchscript_to_cpp.png b/_static/img/torchscript_to_cpp.png
new file mode 100644
index 00000000000..579d65b00d4
Binary files /dev/null and b/_static/img/torchscript_to_cpp.png differ
diff --git a/_static/img/torchserve-ipex-images-2/1.png b/_static/img/torchserve-ipex-images-2/1.png
new file mode 100644
index 00000000000..4a9f488236b
Binary files /dev/null and b/_static/img/torchserve-ipex-images-2/1.png differ
diff --git a/_static/img/torchserve-ipex-images-2/10.png b/_static/img/torchserve-ipex-images-2/10.png
new file mode 100644
index 00000000000..d56f34600d8
Binary files /dev/null and b/_static/img/torchserve-ipex-images-2/10.png differ
diff --git a/_static/img/torchserve-ipex-images-2/11.png b/_static/img/torchserve-ipex-images-2/11.png
new file mode 100644
index 00000000000..8ebbcc03d51
Binary files /dev/null and b/_static/img/torchserve-ipex-images-2/11.png differ
diff --git a/_static/img/torchserve-ipex-images-2/12.png b/_static/img/torchserve-ipex-images-2/12.png
new file mode 100644
index 00000000000..23c4794ae36
Binary files /dev/null and b/_static/img/torchserve-ipex-images-2/12.png differ
diff --git a/_static/img/torchserve-ipex-images-2/13.png b/_static/img/torchserve-ipex-images-2/13.png
new file mode 100644
index 00000000000..4e1dc6e1a03
Binary files /dev/null and b/_static/img/torchserve-ipex-images-2/13.png differ
diff --git a/_static/img/torchserve-ipex-images-2/14.png b/_static/img/torchserve-ipex-images-2/14.png
new file mode 100644
index 00000000000..701399e9d9b
Binary files /dev/null and b/_static/img/torchserve-ipex-images-2/14.png differ
diff --git a/_static/img/torchserve-ipex-images-2/15.png b/_static/img/torchserve-ipex-images-2/15.png
new file mode 100644
index 00000000000..b345a9d0d8c
Binary files /dev/null and b/_static/img/torchserve-ipex-images-2/15.png differ
diff --git a/_static/img/torchserve-ipex-images-2/16.png b/_static/img/torchserve-ipex-images-2/16.png
new file mode 100644
index 00000000000..39b5d6afb9c
Binary files /dev/null and b/_static/img/torchserve-ipex-images-2/16.png differ
diff --git a/_static/img/torchserve-ipex-images-2/17.png b/_static/img/torchserve-ipex-images-2/17.png
new file mode 100644
index 00000000000..bb7359bcbe6
Binary files /dev/null and b/_static/img/torchserve-ipex-images-2/17.png differ
diff --git a/_static/img/torchserve-ipex-images-2/18.png b/_static/img/torchserve-ipex-images-2/18.png
new file mode 100644
index 00000000000..30ad817a561
Binary files /dev/null and b/_static/img/torchserve-ipex-images-2/18.png differ
diff --git a/_static/img/torchserve-ipex-images-2/19.png b/_static/img/torchserve-ipex-images-2/19.png
new file mode 100644
index 00000000000..353bfb897a1
Binary files /dev/null and b/_static/img/torchserve-ipex-images-2/19.png differ
diff --git a/_static/img/torchserve-ipex-images-2/2.png b/_static/img/torchserve-ipex-images-2/2.png
new file mode 100644
index 00000000000..d7d351a3e74
Binary files /dev/null and b/_static/img/torchserve-ipex-images-2/2.png differ
diff --git a/_static/img/torchserve-ipex-images-2/20.png b/_static/img/torchserve-ipex-images-2/20.png
new file mode 100644
index 00000000000..aa94ff57dce
Binary files /dev/null and b/_static/img/torchserve-ipex-images-2/20.png differ
diff --git a/_static/img/torchserve-ipex-images-2/21.png b/_static/img/torchserve-ipex-images-2/21.png
new file mode 100644
index 00000000000..c714adc1453
Binary files /dev/null and b/_static/img/torchserve-ipex-images-2/21.png differ
diff --git a/_static/img/torchserve-ipex-images-2/22.png b/_static/img/torchserve-ipex-images-2/22.png
new file mode 100644
index 00000000000..fa7ae84c702
Binary files /dev/null and b/_static/img/torchserve-ipex-images-2/22.png differ
diff --git a/_static/img/torchserve-ipex-images-2/23.png b/_static/img/torchserve-ipex-images-2/23.png
new file mode 100644
index 00000000000..fd8a1bf8389
Binary files /dev/null and b/_static/img/torchserve-ipex-images-2/23.png differ
diff --git a/_static/img/torchserve-ipex-images-2/24.png b/_static/img/torchserve-ipex-images-2/24.png
new file mode 100644
index 00000000000..6ba858f98f0
Binary files /dev/null and b/_static/img/torchserve-ipex-images-2/24.png differ
diff --git a/_static/img/torchserve-ipex-images-2/3.png b/_static/img/torchserve-ipex-images-2/3.png
new file mode 100644
index 00000000000..6ae485bd132
Binary files /dev/null and b/_static/img/torchserve-ipex-images-2/3.png differ
diff --git a/_static/img/torchserve-ipex-images-2/4.png b/_static/img/torchserve-ipex-images-2/4.png
new file mode 100644
index 00000000000..b0fa5e68133
Binary files /dev/null and b/_static/img/torchserve-ipex-images-2/4.png differ
diff --git a/_static/img/torchserve-ipex-images-2/5.png b/_static/img/torchserve-ipex-images-2/5.png
new file mode 100644
index 00000000000..25adc177ad1
Binary files /dev/null and b/_static/img/torchserve-ipex-images-2/5.png differ
diff --git a/_static/img/torchserve-ipex-images-2/6.png b/_static/img/torchserve-ipex-images-2/6.png
new file mode 100644
index 00000000000..739d3b388d3
Binary files /dev/null and b/_static/img/torchserve-ipex-images-2/6.png differ
diff --git a/_static/img/torchserve-ipex-images-2/7.png b/_static/img/torchserve-ipex-images-2/7.png
new file mode 100644
index 00000000000..77765616d65
Binary files /dev/null and b/_static/img/torchserve-ipex-images-2/7.png differ
diff --git a/_static/img/torchserve-ipex-images-2/8.png b/_static/img/torchserve-ipex-images-2/8.png
new file mode 100644
index 00000000000..b731676cc21
Binary files /dev/null and b/_static/img/torchserve-ipex-images-2/8.png differ
diff --git a/_static/img/torchserve-ipex-images-2/9.png b/_static/img/torchserve-ipex-images-2/9.png
new file mode 100644
index 00000000000..9155201ab3c
Binary files /dev/null and b/_static/img/torchserve-ipex-images-2/9.png differ
diff --git a/_static/img/torchserve-ipex-images/1.png b/_static/img/torchserve-ipex-images/1.png
new file mode 100644
index 00000000000..fc8748b22a5
Binary files /dev/null and b/_static/img/torchserve-ipex-images/1.png differ
diff --git a/_static/img/torchserve-ipex-images/10.png b/_static/img/torchserve-ipex-images/10.png
new file mode 100644
index 00000000000..833a1bb7cf9
Binary files /dev/null and b/_static/img/torchserve-ipex-images/10.png differ
diff --git a/_static/img/torchserve-ipex-images/11.gif b/_static/img/torchserve-ipex-images/11.gif
new file mode 100644
index 00000000000..1c1a2644e8e
Binary files /dev/null and b/_static/img/torchserve-ipex-images/11.gif differ
diff --git a/_static/img/torchserve-ipex-images/12.png b/_static/img/torchserve-ipex-images/12.png
new file mode 100644
index 00000000000..b55968fd705
Binary files /dev/null and b/_static/img/torchserve-ipex-images/12.png differ
diff --git a/_static/img/torchserve-ipex-images/13.png b/_static/img/torchserve-ipex-images/13.png
new file mode 100644
index 00000000000..de9c08814e6
Binary files /dev/null and b/_static/img/torchserve-ipex-images/13.png differ
diff --git a/_static/img/torchserve-ipex-images/14.png b/_static/img/torchserve-ipex-images/14.png
new file mode 100644
index 00000000000..4d776d81647
Binary files /dev/null and b/_static/img/torchserve-ipex-images/14.png differ
diff --git a/_static/img/torchserve-ipex-images/15.png b/_static/img/torchserve-ipex-images/15.png
new file mode 100644
index 00000000000..513ccf8e053
Binary files /dev/null and b/_static/img/torchserve-ipex-images/15.png differ
diff --git a/_static/img/torchserve-ipex-images/16.png b/_static/img/torchserve-ipex-images/16.png
new file mode 100644
index 00000000000..3670d0a1dc4
Binary files /dev/null and b/_static/img/torchserve-ipex-images/16.png differ
diff --git a/_static/img/torchserve-ipex-images/17.png b/_static/img/torchserve-ipex-images/17.png
new file mode 100644
index 00000000000..5ab17373c95
Binary files /dev/null and b/_static/img/torchserve-ipex-images/17.png differ
diff --git a/_static/img/torchserve-ipex-images/18.png b/_static/img/torchserve-ipex-images/18.png
new file mode 100644
index 00000000000..50304884d3e
Binary files /dev/null and b/_static/img/torchserve-ipex-images/18.png differ
diff --git a/_static/img/torchserve-ipex-images/19.png b/_static/img/torchserve-ipex-images/19.png
new file mode 100644
index 00000000000..b123480530e
Binary files /dev/null and b/_static/img/torchserve-ipex-images/19.png differ
diff --git a/_static/img/torchserve-ipex-images/1_.png b/_static/img/torchserve-ipex-images/1_.png
new file mode 100644
index 00000000000..fc8748b22a5
Binary files /dev/null and b/_static/img/torchserve-ipex-images/1_.png differ
diff --git a/_static/img/torchserve-ipex-images/2.png b/_static/img/torchserve-ipex-images/2.png
new file mode 100644
index 00000000000..27633f25bcb
Binary files /dev/null and b/_static/img/torchserve-ipex-images/2.png differ
diff --git a/_static/img/torchserve-ipex-images/20.gif b/_static/img/torchserve-ipex-images/20.gif
new file mode 100644
index 00000000000..ba8e9e95315
Binary files /dev/null and b/_static/img/torchserve-ipex-images/20.gif differ
diff --git a/_static/img/torchserve-ipex-images/21.png b/_static/img/torchserve-ipex-images/21.png
new file mode 100644
index 00000000000..04b3ca622bf
Binary files /dev/null and b/_static/img/torchserve-ipex-images/21.png differ
diff --git a/_static/img/torchserve-ipex-images/22.png b/_static/img/torchserve-ipex-images/22.png
new file mode 100644
index 00000000000..cbb2c269a90
Binary files /dev/null and b/_static/img/torchserve-ipex-images/22.png differ
diff --git a/_static/img/torchserve-ipex-images/23.png b/_static/img/torchserve-ipex-images/23.png
new file mode 100644
index 00000000000..c9bc44463f3
Binary files /dev/null and b/_static/img/torchserve-ipex-images/23.png differ
diff --git a/_static/img/torchserve-ipex-images/24.png b/_static/img/torchserve-ipex-images/24.png
new file mode 100644
index 00000000000..8b5718c30f3
Binary files /dev/null and b/_static/img/torchserve-ipex-images/24.png differ
diff --git a/_static/img/torchserve-ipex-images/25.png b/_static/img/torchserve-ipex-images/25.png
new file mode 100644
index 00000000000..4de920e632b
Binary files /dev/null and b/_static/img/torchserve-ipex-images/25.png differ
diff --git a/_static/img/torchserve-ipex-images/26.gif b/_static/img/torchserve-ipex-images/26.gif
new file mode 100644
index 00000000000..60a5a64ad15
Binary files /dev/null and b/_static/img/torchserve-ipex-images/26.gif differ
diff --git a/_static/img/torchserve-ipex-images/27.png b/_static/img/torchserve-ipex-images/27.png
new file mode 100644
index 00000000000..c7e766155f5
Binary files /dev/null and b/_static/img/torchserve-ipex-images/27.png differ
diff --git a/_static/img/torchserve-ipex-images/28.png b/_static/img/torchserve-ipex-images/28.png
new file mode 100644
index 00000000000..b7056c4c4ac
Binary files /dev/null and b/_static/img/torchserve-ipex-images/28.png differ
diff --git a/_static/img/torchserve-ipex-images/29.png b/_static/img/torchserve-ipex-images/29.png
new file mode 100644
index 00000000000..9dcd8735111
Binary files /dev/null and b/_static/img/torchserve-ipex-images/29.png differ
diff --git a/_static/img/torchserve-ipex-images/3.png b/_static/img/torchserve-ipex-images/3.png
new file mode 100644
index 00000000000..2309071571c
Binary files /dev/null and b/_static/img/torchserve-ipex-images/3.png differ
diff --git a/_static/img/torchserve-ipex-images/30.png b/_static/img/torchserve-ipex-images/30.png
new file mode 100644
index 00000000000..96b07ec7205
Binary files /dev/null and b/_static/img/torchserve-ipex-images/30.png differ
diff --git a/_static/img/torchserve-ipex-images/31.png b/_static/img/torchserve-ipex-images/31.png
new file mode 100644
index 00000000000..601b63e511d
Binary files /dev/null and b/_static/img/torchserve-ipex-images/31.png differ
diff --git a/_static/img/torchserve-ipex-images/4.png b/_static/img/torchserve-ipex-images/4.png
new file mode 100644
index 00000000000..f12d8c7cc40
Binary files /dev/null and b/_static/img/torchserve-ipex-images/4.png differ
diff --git a/_static/img/torchserve-ipex-images/5.png b/_static/img/torchserve-ipex-images/5.png
new file mode 100644
index 00000000000..55e05e5e53c
Binary files /dev/null and b/_static/img/torchserve-ipex-images/5.png differ
diff --git a/_static/img/torchserve-ipex-images/6.png b/_static/img/torchserve-ipex-images/6.png
new file mode 100644
index 00000000000..59a028f94b9
Binary files /dev/null and b/_static/img/torchserve-ipex-images/6.png differ
diff --git a/_static/img/torchserve-ipex-images/7.png b/_static/img/torchserve-ipex-images/7.png
new file mode 100644
index 00000000000..5739cb4f53a
Binary files /dev/null and b/_static/img/torchserve-ipex-images/7.png differ
diff --git a/_static/img/torchserve-ipex-images/8.png b/_static/img/torchserve-ipex-images/8.png
new file mode 100644
index 00000000000..1e6531b6cab
Binary files /dev/null and b/_static/img/torchserve-ipex-images/8.png differ
diff --git a/_static/img/torchserve-ipex-images/9.gif b/_static/img/torchserve-ipex-images/9.gif
new file mode 100644
index 00000000000..682e2f3425e
Binary files /dev/null and b/_static/img/torchserve-ipex-images/9.gif differ
diff --git a/_static/img/trace_img.png b/_static/img/trace_img.png
new file mode 100644
index 00000000000..8c540ceb519
Binary files /dev/null and b/_static/img/trace_img.png differ
diff --git a/_static/img/trace_xpu_img.png b/_static/img/trace_xpu_img.png
new file mode 100644
index 00000000000..2eca0a78cb6
Binary files /dev/null and b/_static/img/trace_xpu_img.png differ
diff --git a/_static/img/transformer_architecture.jpg b/_static/img/transformer_architecture.jpg
new file mode 100644
index 00000000000..4188fae7c85
Binary files /dev/null and b/_static/img/transformer_architecture.jpg differ
diff --git a/_static/img/transformer_input_target.png b/_static/img/transformer_input_target.png
new file mode 100644
index 00000000000..02e87174762
Binary files /dev/null and b/_static/img/transformer_input_target.png differ
diff --git a/_static/img/tts_pipeline.png b/_static/img/tts_pipeline.png
new file mode 100644
index 00000000000..5dc37ae9ddd
Binary files /dev/null and b/_static/img/tts_pipeline.png differ
diff --git a/_static/img/tv_tutorial/tv_image01.png b/_static/img/tv_tutorial/tv_image01.png
deleted file mode 100644
index bb47d27d24e..00000000000
Binary files a/_static/img/tv_tutorial/tv_image01.png and /dev/null differ
diff --git a/_static/img/tv_tutorial/tv_image02.png b/_static/img/tv_tutorial/tv_image02.png
deleted file mode 100644
index 8717199010b..00000000000
Binary files a/_static/img/tv_tutorial/tv_image02.png and /dev/null differ
diff --git a/_static/img/tv_tutorial/tv_image05.png b/_static/img/tv_tutorial/tv_image05.png
deleted file mode 100644
index 3961033693a..00000000000
Binary files a/_static/img/tv_tutorial/tv_image05.png and /dev/null differ
diff --git a/_static/img/tv_tutorial/tv_image06.png b/_static/img/tv_tutorial/tv_image06.png
deleted file mode 100644
index b885866081a..00000000000
Binary files a/_static/img/tv_tutorial/tv_image06.png and /dev/null differ
diff --git a/_static/img/tv_tutorial/tv_image07.png b/_static/img/tv_tutorial/tv_image07.png
deleted file mode 100644
index e3d88cd5989..00000000000
Binary files a/_static/img/tv_tutorial/tv_image07.png and /dev/null differ
diff --git a/_static/img/understanding_leaf_vs_nonleaf/comp-graph-1.png b/_static/img/understanding_leaf_vs_nonleaf/comp-graph-1.png
new file mode 100644
index 00000000000..1fa3d80d339
Binary files /dev/null and b/_static/img/understanding_leaf_vs_nonleaf/comp-graph-1.png differ
diff --git a/_static/img/understanding_leaf_vs_nonleaf/comp-graph-2.png b/_static/img/understanding_leaf_vs_nonleaf/comp-graph-2.png
new file mode 100644
index 00000000000..3f76deab3bf
Binary files /dev/null and b/_static/img/understanding_leaf_vs_nonleaf/comp-graph-2.png differ
diff --git a/_static/img/usb_semisup_learn/code.png b/_static/img/usb_semisup_learn/code.png
new file mode 100644
index 00000000000..fdc7b798a37
Binary files /dev/null and b/_static/img/usb_semisup_learn/code.png differ
diff --git a/_static/jquery-3.2.1.js b/_static/jquery-3.2.1.js
deleted file mode 100755
index 2cbd2ab50e7..00000000000
--- a/_static/jquery-3.2.1.js
+++ /dev/null
@@ -1,10253 +0,0 @@
-/*!
- * jQuery JavaScript Library v3.2.1
- * https://jquery.com/
- *
- * Includes Sizzle.js
- * https://sizzlejs.com/
- *
- * Copyright JS Foundation and other contributors
- * Released under the MIT license
- * https://jquery.org/license
- *
- * Date: 2017-03-20T18:59Z
- */
-( function( global, factory ) {
-
-	"use strict";
-
-	if ( typeof module === "object" && typeof module.exports === "object" ) {
-
-		// For CommonJS and CommonJS-like environments where a proper `window`
-		// is present, execute the factory and get jQuery.
-		// For environments that do not have a `window` with a `document`
-		// (such as Node.js), expose a factory as module.exports.
-		// This accentuates the need for the creation of a real `window`.
-		// e.g. var jQuery = require("jquery")(window);
-		// See ticket #14549 for more info.
-		module.exports = global.document ?
-			factory( global, true ) :
-			function( w ) {
-				if ( !w.document ) {
-					throw new Error( "jQuery requires a window with a document" );
-				}
-				return factory( w );
-			};
-	} else {
-		factory( global );
-	}
-
-// Pass this if window is not defined yet
-} )( typeof window !== "undefined" ? window : this, function( window, noGlobal ) {
-
-// Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1
-// throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode
-// arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common
-// enough that all such attempts are guarded in a try block.
-"use strict";
-
-var arr = [];
-
-var document = window.document;
-
-var getProto = Object.getPrototypeOf;
-
-var slice = arr.slice;
-
-var concat = arr.concat;
-
-var push = arr.push;
-
-var indexOf = arr.indexOf;
-
-var class2type = {};
-
-var toString = class2type.toString;
-
-var hasOwn = class2type.hasOwnProperty;
-
-var fnToString = hasOwn.toString;
-
-var ObjectFunctionString = fnToString.call( Object );
-
-var support = {};
-
-
-
-	function DOMEval( code, doc ) {
-		doc = doc || document;
-
-		var script = doc.createElement( "script" );
-
-		script.text = code;
-		doc.head.appendChild( script ).parentNode.removeChild( script );
-	}
-/* global Symbol */
-// Defining this global in .eslintrc.json would create a danger of using the global
-// unguarded in another place, it seems safer to define global only for this module
-
-
-
-var
-	version = "3.2.1",
-
-	// Define a local copy of jQuery
-	jQuery = function( selector, context ) {
-
-		// The jQuery object is actually just the init constructor 'enhanced'
-		// Need init if jQuery is called (just allow error to be thrown if not included)
-		return new jQuery.fn.init( selector, context );
-	},
-
-	// Support: Android <=4.0 only
-	// Make sure we trim BOM and NBSP
-	rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
-
-	// Matches dashed string for camelizing
-	rmsPrefix = /^-ms-/,
-	rdashAlpha = /-([a-z])/g,
-
-	// Used by jQuery.camelCase as callback to replace()
-	fcamelCase = function( all, letter ) {
-		return letter.toUpperCase();
-	};
-
-jQuery.fn = jQuery.prototype = {
-
-	// The current version of jQuery being used
-	jquery: version,
-
-	constructor: jQuery,
-
-	// The default length of a jQuery object is 0
-	length: 0,
-
-	toArray: function() {
-		return slice.call( this );
-	},
-
-	// Get the Nth element in the matched element set OR
-	// Get the whole matched element set as a clean array
-	get: function( num ) {
-
-		// Return all the elements in a clean array
-		if ( num == null ) {
-			return slice.call( this );
-		}
-
-		// Return just the one element from the set
-		return num < 0 ? this[ num + this.length ] : this[ num ];
-	},
-
-	// Take an array of elements and push it onto the stack
-	// (returning the new matched element set)
-	pushStack: function( elems ) {
-
-		// Build a new jQuery matched element set
-		var ret = jQuery.merge( this.constructor(), elems );
-
-		// Add the old object onto the stack (as a reference)
-		ret.prevObject = this;
-
-		// Return the newly-formed element set
-		return ret;
-	},
-
-	// Execute a callback for every element in the matched set.
-	each: function( callback ) {
-		return jQuery.each( this, callback );
-	},
-
-	map: function( callback ) {
-		return this.pushStack( jQuery.map( this, function( elem, i ) {
-			return callback.call( elem, i, elem );
-		} ) );
-	},
-
-	slice: function() {
-		return this.pushStack( slice.apply( this, arguments ) );
-	},
-
-	first: function() {
-		return this.eq( 0 );
-	},
-
-	last: function() {
-		return this.eq( -1 );
-	},
-
-	eq: function( i ) {
-		var len = this.length,
-			j = +i + ( i < 0 ? len : 0 );
-		return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] );
-	},
-
-	end: function() {
-		return this.prevObject || this.constructor();
-	},
-
-	// For internal use only.
-	// Behaves like an Array's method, not like a jQuery method.
-	push: push,
-	sort: arr.sort,
-	splice: arr.splice
-};
-
-jQuery.extend = jQuery.fn.extend = function() {
-	var options, name, src, copy, copyIsArray, clone,
-		target = arguments[ 0 ] || {},
-		i = 1,
-		length = arguments.length,
-		deep = false;
-
-	// Handle a deep copy situation
-	if ( typeof target === "boolean" ) {
-		deep = target;
-
-		// Skip the boolean and the target
-		target = arguments[ i ] || {};
-		i++;
-	}
-
-	// Handle case when target is a string or something (possible in deep copy)
-	if ( typeof target !== "object" && !jQuery.isFunction( target ) ) {
-		target = {};
-	}
-
-	// Extend jQuery itself if only one argument is passed
-	if ( i === length ) {
-		target = this;
-		i--;
-	}
-
-	for ( ; i < length; i++ ) {
-
-		// Only deal with non-null/undefined values
-		if ( ( options = arguments[ i ] ) != null ) {
-
-			// Extend the base object
-			for ( name in options ) {
-				src = target[ name ];
-				copy = options[ name ];
-
-				// Prevent never-ending loop
-				if ( target === copy ) {
-					continue;
-				}
-
-				// Recurse if we're merging plain objects or arrays
-				if ( deep && copy && ( jQuery.isPlainObject( copy ) ||
-					( copyIsArray = Array.isArray( copy ) ) ) ) {
-
-					if ( copyIsArray ) {
-						copyIsArray = false;
-						clone = src && Array.isArray( src ) ? src : [];
-
-					} else {
-						clone = src && jQuery.isPlainObject( src ) ? src : {};
-					}
-
-					// Never move original objects, clone them
-					target[ name ] = jQuery.extend( deep, clone, copy );
-
-				// Don't bring in undefined values
-				} else if ( copy !== undefined ) {
-					target[ name ] = copy;
-				}
-			}
-		}
-	}
-
-	// Return the modified object
-	return target;
-};
-
-jQuery.extend( {
-
-	// Unique for each copy of jQuery on the page
-	expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ),
-
-	// Assume jQuery is ready without the ready module
-	isReady: true,
-
-	error: function( msg ) {
-		throw new Error( msg );
-	},
-
-	noop: function() {},
-
-	isFunction: function( obj ) {
-		return jQuery.type( obj ) === "function";
-	},
-
-	isWindow: function( obj ) {
-		return obj != null && obj === obj.window;
-	},
-
-	isNumeric: function( obj ) {
-
-		// As of jQuery 3.0, isNumeric is limited to
-		// strings and numbers (primitives or objects)
-		// that can be coerced to finite numbers (gh-2662)
-		var type = jQuery.type( obj );
-		return ( type === "number" || type === "string" ) &&
-
-			// parseFloat NaNs numeric-cast false positives ("")
-			// ...but misinterprets leading-number strings, particularly hex literals ("0x...")
-			// subtraction forces infinities to NaN
-			!isNaN( obj - parseFloat( obj ) );
-	},
-
-	isPlainObject: function( obj ) {
-		var proto, Ctor;
-
-		// Detect obvious negatives
-		// Use toString instead of jQuery.type to catch host objects
-		if ( !obj || toString.call( obj ) !== "[object Object]" ) {
-			return false;
-		}
-
-		proto = getProto( obj );
-
-		// Objects with no prototype (e.g., `Object.create( null )`) are plain
-		if ( !proto ) {
-			return true;
-		}
-
-		// Objects with prototype are plain iff they were constructed by a global Object function
-		Ctor = hasOwn.call( proto, "constructor" ) && proto.constructor;
-		return typeof Ctor === "function" && fnToString.call( Ctor ) === ObjectFunctionString;
-	},
-
-	isEmptyObject: function( obj ) {
-
-		/* eslint-disable no-unused-vars */
-		// See https://github.com/eslint/eslint/issues/6125
-		var name;
-
-		for ( name in obj ) {
-			return false;
-		}
-		return true;
-	},
-
-	type: function( obj ) {
-		if ( obj == null ) {
-			return obj + "";
-		}
-
-		// Support: Android <=2.3 only (functionish RegExp)
-		return typeof obj === "object" || typeof obj === "function" ?
-			class2type[ toString.call( obj ) ] || "object" :
-			typeof obj;
-	},
-
-	// Evaluates a script in a global context
-	globalEval: function( code ) {
-		DOMEval( code );
-	},
-
-	// Convert dashed to camelCase; used by the css and data modules
-	// Support: IE <=9 - 11, Edge 12 - 13
-	// Microsoft forgot to hump their vendor prefix (#9572)
-	camelCase: function( string ) {
-		return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
-	},
-
-	each: function( obj, callback ) {
-		var length, i = 0;
-
-		if ( isArrayLike( obj ) ) {
-			length = obj.length;
-			for ( ; i < length; i++ ) {
-				if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
-					break;
-				}
-			}
-		} else {
-			for ( i in obj ) {
-				if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
-					break;
-				}
-			}
-		}
-
-		return obj;
-	},
-
-	// Support: Android <=4.0 only
-	trim: function( text ) {
-		return text == null ?
-			"" :
-			( text + "" ).replace( rtrim, "" );
-	},
-
-	// results is for internal usage only
-	makeArray: function( arr, results ) {
-		var ret = results || [];
-
-		if ( arr != null ) {
-			if ( isArrayLike( Object( arr ) ) ) {
-				jQuery.merge( ret,
-					typeof arr === "string" ?
-					[ arr ] : arr
-				);
-			} else {
-				push.call( ret, arr );
-			}
-		}
-
-		return ret;
-	},
-
-	inArray: function( elem, arr, i ) {
-		return arr == null ? -1 : indexOf.call( arr, elem, i );
-	},
-
-	// Support: Android <=4.0 only, PhantomJS 1 only
-	// push.apply(_, arraylike) throws on ancient WebKit
-	merge: function( first, second ) {
-		var len = +second.length,
-			j = 0,
-			i = first.length;
-
-		for ( ; j < len; j++ ) {
-			first[ i++ ] = second[ j ];
-		}
-
-		first.length = i;
-
-		return first;
-	},
-
-	grep: function( elems, callback, invert ) {
-		var callbackInverse,
-			matches = [],
-			i = 0,
-			length = elems.length,
-			callbackExpect = !invert;
-
-		// Go through the array, only saving the items
-		// that pass the validator function
-		for ( ; i < length; i++ ) {
-			callbackInverse = !callback( elems[ i ], i );
-			if ( callbackInverse !== callbackExpect ) {
-				matches.push( elems[ i ] );
-			}
-		}
-
-		return matches;
-	},
-
-	// arg is for internal usage only
-	map: function( elems, callback, arg ) {
-		var length, value,
-			i = 0,
-			ret = [];
-
-		// Go through the array, translating each of the items to their new values
-		if ( isArrayLike( elems ) ) {
-			length = elems.length;
-			for ( ; i < length; i++ ) {
-				value = callback( elems[ i ], i, arg );
-
-				if ( value != null ) {
-					ret.push( value );
-				}
-			}
-
-		// Go through every key on the object,
-		} else {
-			for ( i in elems ) {
-				value = callback( elems[ i ], i, arg );
-
-				if ( value != null ) {
-					ret.push( value );
-				}
-			}
-		}
-
-		// Flatten any nested arrays
-		return concat.apply( [], ret );
-	},
-
-	// A global GUID counter for objects
-	guid: 1,
-
-	// Bind a function to a context, optionally partially applying any
-	// arguments.
-	proxy: function( fn, context ) {
-		var tmp, args, proxy;
-
-		if ( typeof context === "string" ) {
-			tmp = fn[ context ];
-			context = fn;
-			fn = tmp;
-		}
-
-		// Quick check to determine if target is callable, in the spec
-		// this throws a TypeError, but we will just return undefined.
-		if ( !jQuery.isFunction( fn ) ) {
-			return undefined;
-		}
-
-		// Simulated bind
-		args = slice.call( arguments, 2 );
-		proxy = function() {
-			return fn.apply( context || this, args.concat( slice.call( arguments ) ) );
-		};
-
-		// Set the guid of unique handler to the same of original handler, so it can be removed
-		proxy.guid = fn.guid = fn.guid || jQuery.guid++;
-
-		return proxy;
-	},
-
-	now: Date.now,
-
-	// jQuery.support is not used in Core but other projects attach their
-	// properties to it so it needs to exist.
-	support: support
-} );
-
-if ( typeof Symbol === "function" ) {
-	jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ];
-}
-
-// Populate the class2type map
-jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ),
-function( i, name ) {
-	class2type[ "[object " + name + "]" ] = name.toLowerCase();
-} );
-
-function isArrayLike( obj ) {
-
-	// Support: real iOS 8.2 only (not reproducible in simulator)
-	// `in` check used to prevent JIT error (gh-2145)
-	// hasOwn isn't used here due to false negatives
-	// regarding Nodelist length in IE
-	var length = !!obj && "length" in obj && obj.length,
-		type = jQuery.type( obj );
-
-	if ( type === "function" || jQuery.isWindow( obj ) ) {
-		return false;
-	}
-
-	return type === "array" || length === 0 ||
-		typeof length === "number" && length > 0 && ( length - 1 ) in obj;
-}
-var Sizzle =
-/*!
- * Sizzle CSS Selector Engine v2.3.3
- * https://sizzlejs.com/
- *
- * Copyright jQuery Foundation and other contributors
- * Released under the MIT license
- * https://jquery.org/license
- *
- * Date: 2016-08-08
- */
-(function( window ) {
-
-var i,
-	support,
-	Expr,
-	getText,
-	isXML,
-	tokenize,
-	compile,
-	select,
-	outermostContext,
-	sortInput,
-	hasDuplicate,
-
-	// Local document vars
-	setDocument,
-	document,
-	docElem,
-	documentIsHTML,
-	rbuggyQSA,
-	rbuggyMatches,
-	matches,
-	contains,
-
-	// Instance-specific data
-	expando = "sizzle" + 1 * new Date(),
-	preferredDoc = window.document,
-	dirruns = 0,
-	done = 0,
-	classCache = createCache(),
-	tokenCache = createCache(),
-	compilerCache = createCache(),
-	sortOrder = function( a, b ) {
-		if ( a === b ) {
-			hasDuplicate = true;
-		}
-		return 0;
-	},
-
-	// Instance methods
-	hasOwn = ({}).hasOwnProperty,
-	arr = [],
-	pop = arr.pop,
-	push_native = arr.push,
-	push = arr.push,
-	slice = arr.slice,
-	// Use a stripped-down indexOf as it's faster than native
-	// https://jsperf.com/thor-indexof-vs-for/5
-	indexOf = function( list, elem ) {
-		var i = 0,
-			len = list.length;
-		for ( ; i < len; i++ ) {
-			if ( list[i] === elem ) {
-				return i;
-			}
-		}
-		return -1;
-	},
-
-	booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",
-
-	// Regular expressions
-
-	// https://www.w3.org/TR/css3-selectors/#whitespace
-	whitespace = "[\\x20\\t\\r\\n\\f]",
-
-	// https://www.w3.org/TR/CSS21/syndata.html#value-def-identifier
-	identifier = "(?:\\\\.|[\\w-]|[^\0-\\xa0])+",
-
-	// Attribute selectors: https://www.w3.org/TR/selectors/#attribute-selectors
-	attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace +
-		// Operator (capture 2)
-		"*([*^$|!~]?=)" + whitespace +
-		// "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]"
-		"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + whitespace +
-		"*\\]",
-
-	pseudos = ":(" + identifier + ")(?:\\((" +
-		// To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:
-		// 1. quoted (capture 3; capture 4 or capture 5)
-		"('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" +
-		// 2. simple (capture 6)
-		"((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" +
-		// 3. anything else (capture 2)
-		".*" +
-		")\\)|)",
-
-	// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
-	rwhitespace = new RegExp( whitespace + "+", "g" ),
-	rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ),
-
-	rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),
-	rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*" ),
-
-	rattributeQuotes = new RegExp( "=" + whitespace + "*([^\\]'\"]*?)" + whitespace + "*\\]", "g" ),
-
-	rpseudo = new RegExp( pseudos ),
-	ridentifier = new RegExp( "^" + identifier + "$" ),
-
-	matchExpr = {
-		"ID": new RegExp( "^#(" + identifier + ")" ),
-		"CLASS": new RegExp( "^\\.(" + identifier + ")" ),
-		"TAG": new RegExp( "^(" + identifier + "|[*])" ),
-		"ATTR": new RegExp( "^" + attributes ),
-		"PSEUDO": new RegExp( "^" + pseudos ),
-		"CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace +
-			"*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace +
-			"*(\\d+)|))" + whitespace + "*\\)|)", "i" ),
-		"bool": new RegExp( "^(?:" + booleans + ")$", "i" ),
-		// For use in libraries implementing .is()
-		// We use this for POS matching in `select`
-		"needsContext": new RegExp( "^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" +
-			whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" )
-	},
-
-	rinputs = /^(?:input|select|textarea|button)$/i,
-	rheader = /^h\d$/i,
-
-	rnative = /^[^{]+\{\s*\[native \w/,
-
-	// Easily-parseable/retrievable ID or TAG or CLASS selectors
-	rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
-
-	rsibling = /[+~]/,
-
-	// CSS escapes
-	// https://www.w3.org/TR/CSS21/syndata.html#escaped-characters
-	runescape = new RegExp( "\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)", "ig" ),
-	funescape = function( _, escaped, escapedWhitespace ) {
-		var high = "0x" + escaped - 0x10000;
-		// NaN means non-codepoint
-		// Support: Firefox<24
-		// Workaround erroneous numeric interpretation of +"0x"
-		return high !== high || escapedWhitespace ?
-			escaped :
-			high < 0 ?
-				// BMP codepoint
-				String.fromCharCode( high + 0x10000 ) :
-				// Supplemental Plane codepoint (surrogate pair)
-				String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );
-	},
-
-	// CSS string/identifier serialization
-	// https://drafts.csswg.org/cssom/#common-serializing-idioms
-	rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,
-	fcssescape = function( ch, asCodePoint ) {
-		if ( asCodePoint ) {
-
-			// U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER
-			if ( ch === "\0" ) {
-				return "\uFFFD";
-			}
-
-			// Control characters and (dependent upon position) numbers get escaped as code points
-			return ch.slice( 0, -1 ) + "\\" + ch.charCodeAt( ch.length - 1 ).toString( 16 ) + " ";
-		}
-
-		// Other potentially-special ASCII characters get backslash-escaped
-		return "\\" + ch;
-	},
-
-	// Used for iframes
-	// See setDocument()
-	// Removing the function wrapper causes a "Permission Denied"
-	// error in IE
-	unloadHandler = function() {
-		setDocument();
-	},
-
-	disabledAncestor = addCombinator(
-		function( elem ) {
-			return elem.disabled === true && ("form" in elem || "label" in elem);
-		},
-		{ dir: "parentNode", next: "legend" }
-	);
-
-// Optimize for push.apply( _, NodeList )
-try {
-	push.apply(
-		(arr = slice.call( preferredDoc.childNodes )),
-		preferredDoc.childNodes
-	);
-	// Support: Android<4.0
-	// Detect silently failing push.apply
-	arr[ preferredDoc.childNodes.length ].nodeType;
-} catch ( e ) {
-	push = { apply: arr.length ?
-
-		// Leverage slice if possible
-		function( target, els ) {
-			push_native.apply( target, slice.call(els) );
-		} :
-
-		// Support: IE<9
-		// Otherwise append directly
-		function( target, els ) {
-			var j = target.length,
-				i = 0;
-			// Can't trust NodeList.length
-			while ( (target[j++] = els[i++]) ) {}
-			target.length = j - 1;
-		}
-	};
-}
-
-function Sizzle( selector, context, results, seed ) {
-	var m, i, elem, nid, match, groups, newSelector,
-		newContext = context && context.ownerDocument,
-
-		// nodeType defaults to 9, since context defaults to document
-		nodeType = context ? context.nodeType : 9;
-
-	results = results || [];
-
-	// Return early from calls with invalid selector or context
-	if ( typeof selector !== "string" || !selector ||
-		nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {
-
-		return results;
-	}
-
-	// Try to shortcut find operations (as opposed to filters) in HTML documents
-	if ( !seed ) {
-
-		if ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) {
-			setDocument( context );
-		}
-		context = context || document;
-
-		if ( documentIsHTML ) {
-
-			// If the selector is sufficiently simple, try using a "get*By*" DOM method
-			// (excepting DocumentFragment context, where the methods don't exist)
-			if ( nodeType !== 11 && (match = rquickExpr.exec( selector )) ) {
-
-				// ID selector
-				if ( (m = match[1]) ) {
-
-					// Document context
-					if ( nodeType === 9 ) {
-						if ( (elem = context.getElementById( m )) ) {
-
-							// Support: IE, Opera, Webkit
-							// TODO: identify versions
-							// getElementById can match elements by name instead of ID
-							if ( elem.id === m ) {
-								results.push( elem );
-								return results;
-							}
-						} else {
-							return results;
-						}
-
-					// Element context
-					} else {
-
-						// Support: IE, Opera, Webkit
-						// TODO: identify versions
-						// getElementById can match elements by name instead of ID
-						if ( newContext && (elem = newContext.getElementById( m )) &&
-							contains( context, elem ) &&
-							elem.id === m ) {
-
-							results.push( elem );
-							return results;
-						}
-					}
-
-				// Type selector
-				} else if ( match[2] ) {
-					push.apply( results, context.getElementsByTagName( selector ) );
-					return results;
-
-				// Class selector
-				} else if ( (m = match[3]) && support.getElementsByClassName &&
-					context.getElementsByClassName ) {
-
-					push.apply( results, context.getElementsByClassName( m ) );
-					return results;
-				}
-			}
-
-			// Take advantage of querySelectorAll
-			if ( support.qsa &&
-				!compilerCache[ selector + " " ] &&
-				(!rbuggyQSA || !rbuggyQSA.test( selector )) ) {
-
-				if ( nodeType !== 1 ) {
-					newContext = context;
-					newSelector = selector;
-
-				// qSA looks outside Element context, which is not what we want
-				// Thanks to Andrew Dupont for this workaround technique
-				// Support: IE <=8
-				// Exclude object elements
-				} else if ( context.nodeName.toLowerCase() !== "object" ) {
-
-					// Capture the context ID, setting it first if necessary
-					if ( (nid = context.getAttribute( "id" )) ) {
-						nid = nid.replace( rcssescape, fcssescape );
-					} else {
-						context.setAttribute( "id", (nid = expando) );
-					}
-
-					// Prefix every selector in the list
-					groups = tokenize( selector );
-					i = groups.length;
-					while ( i-- ) {
-						groups[i] = "#" + nid + " " + toSelector( groups[i] );
-					}
-					newSelector = groups.join( "," );
-
-					// Expand context for sibling selectors
-					newContext = rsibling.test( selector ) && testContext( context.parentNode ) ||
-						context;
-				}
-
-				if ( newSelector ) {
-					try {
-						push.apply( results,
-							newContext.querySelectorAll( newSelector )
-						);
-						return results;
-					} catch ( qsaError ) {
-					} finally {
-						if ( nid === expando ) {
-							context.removeAttribute( "id" );
-						}
-					}
-				}
-			}
-		}
-	}
-
-	// All others
-	return select( selector.replace( rtrim, "$1" ), context, results, seed );
-}
-
-/**
- * Create key-value caches of limited size
- * @returns {function(string, object)} Returns the Object data after storing it on itself with
- *	property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
- *	deleting the oldest entry
- */
-function createCache() {
-	var keys = [];
-
-	function cache( key, value ) {
-		// Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
-		if ( keys.push( key + " " ) > Expr.cacheLength ) {
-			// Only keep the most recent entries
-			delete cache[ keys.shift() ];
-		}
-		return (cache[ key + " " ] = value);
-	}
-	return cache;
-}
-
-/**
- * Mark a function for special use by Sizzle
- * @param {Function} fn The function to mark
- */
-function markFunction( fn ) {
-	fn[ expando ] = true;
-	return fn;
-}
-
-/**
- * Support testing using an element
- * @param {Function} fn Passed the created element and returns a boolean result
- */
-function assert( fn ) {
-	var el = document.createElement("fieldset");
-
-	try {
-		return !!fn( el );
-	} catch (e) {
-		return false;
-	} finally {
-		// Remove from its parent by default
-		if ( el.parentNode ) {
-			el.parentNode.removeChild( el );
-		}
-		// release memory in IE
-		el = null;
-	}
-}
-
-/**
- * Adds the same handler for all of the specified attrs
- * @param {String} attrs Pipe-separated list of attributes
- * @param {Function} handler The method that will be applied
- */
-function addHandle( attrs, handler ) {
-	var arr = attrs.split("|"),
-		i = arr.length;
-
-	while ( i-- ) {
-		Expr.attrHandle[ arr[i] ] = handler;
-	}
-}
-
-/**
- * Checks document order of two siblings
- * @param {Element} a
- * @param {Element} b
- * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b
- */
-function siblingCheck( a, b ) {
-	var cur = b && a,
-		diff = cur && a.nodeType === 1 && b.nodeType === 1 &&
-			a.sourceIndex - b.sourceIndex;
-
-	// Use IE sourceIndex if available on both nodes
-	if ( diff ) {
-		return diff;
-	}
-
-	// Check if b follows a
-	if ( cur ) {
-		while ( (cur = cur.nextSibling) ) {
-			if ( cur === b ) {
-				return -1;
-			}
-		}
-	}
-
-	return a ? 1 : -1;
-}
-
-/**
- * Returns a function to use in pseudos for input types
- * @param {String} type
- */
-function createInputPseudo( type ) {
-	return function( elem ) {
-		var name = elem.nodeName.toLowerCase();
-		return name === "input" && elem.type === type;
-	};
-}
-
-/**
- * Returns a function to use in pseudos for buttons
- * @param {String} type
- */
-function createButtonPseudo( type ) {
-	return function( elem ) {
-		var name = elem.nodeName.toLowerCase();
-		return (name === "input" || name === "button") && elem.type === type;
-	};
-}
-
-/**
- * Returns a function to use in pseudos for :enabled/:disabled
- * @param {Boolean} disabled true for :disabled; false for :enabled
- */
-function createDisabledPseudo( disabled ) {
-
-	// Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable
-	return function( elem ) {
-
-		// Only certain elements can match :enabled or :disabled
-		// https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled
-		// https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled
-		if ( "form" in elem ) {
-
-			// Check for inherited disabledness on relevant non-disabled elements:
-			// * listed form-associated elements in a disabled fieldset
-			//   https://html.spec.whatwg.org/multipage/forms.html#category-listed
-			//   https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled
-			// * option elements in a disabled optgroup
-			//   https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled
-			// All such elements have a "form" property.
-			if ( elem.parentNode && elem.disabled === false ) {
-
-				// Option elements defer to a parent optgroup if present
-				if ( "label" in elem ) {
-					if ( "label" in elem.parentNode ) {
-						return elem.parentNode.disabled === disabled;
-					} else {
-						return elem.disabled === disabled;
-					}
-				}
-
-				// Support: IE 6 - 11
-				// Use the isDisabled shortcut property to check for disabled fieldset ancestors
-				return elem.isDisabled === disabled ||
-
-					// Where there is no isDisabled, check manually
-					/* jshint -W018 */
-					elem.isDisabled !== !disabled &&
-						disabledAncestor( elem ) === disabled;
-			}
-
-			return elem.disabled === disabled;
-
-		// Try to winnow out elements that can't be disabled before trusting the disabled property.
-		// Some victims get caught in our net (label, legend, menu, track), but it shouldn't
-		// even exist on them, let alone have a boolean value.
-		} else if ( "label" in elem ) {
-			return elem.disabled === disabled;
-		}
-
-		// Remaining elements are neither :enabled nor :disabled
-		return false;
-	};
-}
-
-/**
- * Returns a function to use in pseudos for positionals
- * @param {Function} fn
- */
-function createPositionalPseudo( fn ) {
-	return markFunction(function( argument ) {
-		argument = +argument;
-		return markFunction(function( seed, matches ) {
-			var j,
-				matchIndexes = fn( [], seed.length, argument ),
-				i = matchIndexes.length;
-
-			// Match elements found at the specified indexes
-			while ( i-- ) {
-				if ( seed[ (j = matchIndexes[i]) ] ) {
-					seed[j] = !(matches[j] = seed[j]);
-				}
-			}
-		});
-	});
-}
-
-/**
- * Checks a node for validity as a Sizzle context
- * @param {Element|Object=} context
- * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
- */
-function testContext( context ) {
-	return context && typeof context.getElementsByTagName !== "undefined" && context;
-}
-
-// Expose support vars for convenience
-support = Sizzle.support = {};
-
-/**
- * Detects XML nodes
- * @param {Element|Object} elem An element or a document
- * @returns {Boolean} True iff elem is a non-HTML XML node
- */
-isXML = Sizzle.isXML = function( elem ) {
-	// documentElement is verified for cases where it doesn't yet exist
-	// (such as loading iframes in IE - #4833)
-	var documentElement = elem && (elem.ownerDocument || elem).documentElement;
-	return documentElement ? documentElement.nodeName !== "HTML" : false;
-};
-
-/**
- * Sets document-related variables once based on the current document
- * @param {Element|Object} [doc] An element or document object to use to set the document
- * @returns {Object} Returns the current document
- */
-setDocument = Sizzle.setDocument = function( node ) {
-	var hasCompare, subWindow,
-		doc = node ? node.ownerDocument || node : preferredDoc;
-
-	// Return early if doc is invalid or already selected
-	if ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) {
-		return document;
-	}
-
-	// Update global variables
-	document = doc;
-	docElem = document.documentElement;
-	documentIsHTML = !isXML( document );
-
-	// Support: IE 9-11, Edge
-	// Accessing iframe documents after unload throws "permission denied" errors (jQuery #13936)
-	if ( preferredDoc !== document &&
-		(subWindow = document.defaultView) && subWindow.top !== subWindow ) {
-
-		// Support: IE 11, Edge
-		if ( subWindow.addEventListener ) {
-			subWindow.addEventListener( "unload", unloadHandler, false );
-
-		// Support: IE 9 - 10 only
-		} else if ( subWindow.attachEvent ) {
-			subWindow.attachEvent( "onunload", unloadHandler );
-		}
-	}
-
-	/* Attributes
-	---------------------------------------------------------------------- */
-
-	// Support: IE<8
-	// Verify that getAttribute really returns attributes and not properties
-	// (excepting IE8 booleans)
-	support.attributes = assert(function( el ) {
-		el.className = "i";
-		return !el.getAttribute("className");
-	});
-
-	/* getElement(s)By*
-	---------------------------------------------------------------------- */
-
-	// Check if getElementsByTagName("*") returns only elements
-	support.getElementsByTagName = assert(function( el ) {
-		el.appendChild( document.createComment("") );
-		return !el.getElementsByTagName("*").length;
-	});
-
-	// Support: IE<9
-	support.getElementsByClassName = rnative.test( document.getElementsByClassName );
-
-	// Support: IE<10
-	// Check if getElementById returns elements by name
-	// The broken getElementById methods don't pick up programmatically-set names,
-	// so use a roundabout getElementsByName test
-	support.getById = assert(function( el ) {
-		docElem.appendChild( el ).id = expando;
-		return !document.getElementsByName || !document.getElementsByName( expando ).length;
-	});
-
-	// ID filter and find
-	if ( support.getById ) {
-		Expr.filter["ID"] = function( id ) {
-			var attrId = id.replace( runescape, funescape );
-			return function( elem ) {
-				return elem.getAttribute("id") === attrId;
-			};
-		};
-		Expr.find["ID"] = function( id, context ) {
-			if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
-				var elem = context.getElementById( id );
-				return elem ? [ elem ] : [];
-			}
-		};
-	} else {
-		Expr.filter["ID"] =  function( id ) {
-			var attrId = id.replace( runescape, funescape );
-			return function( elem ) {
-				var node = typeof elem.getAttributeNode !== "undefined" &&
-					elem.getAttributeNode("id");
-				return node && node.value === attrId;
-			};
-		};
-
-		// Support: IE 6 - 7 only
-		// getElementById is not reliable as a find shortcut
-		Expr.find["ID"] = function( id, context ) {
-			if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
-				var node, i, elems,
-					elem = context.getElementById( id );
-
-				if ( elem ) {
-
-					// Verify the id attribute
-					node = elem.getAttributeNode("id");
-					if ( node && node.value === id ) {
-						return [ elem ];
-					}
-
-					// Fall back on getElementsByName
-					elems = context.getElementsByName( id );
-					i = 0;
-					while ( (elem = elems[i++]) ) {
-						node = elem.getAttributeNode("id");
-						if ( node && node.value === id ) {
-							return [ elem ];
-						}
-					}
-				}
-
-				return [];
-			}
-		};
-	}
-
-	// Tag
-	Expr.find["TAG"] = support.getElementsByTagName ?
-		function( tag, context ) {
-			if ( typeof context.getElementsByTagName !== "undefined" ) {
-				return context.getElementsByTagName( tag );
-
-			// DocumentFragment nodes don't have gEBTN
-			} else if ( support.qsa ) {
-				return context.querySelectorAll( tag );
-			}
-		} :
-
-		function( tag, context ) {
-			var elem,
-				tmp = [],
-				i = 0,
-				// By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too
-				results = context.getElementsByTagName( tag );
-
-			// Filter out possible comments
-			if ( tag === "*" ) {
-				while ( (elem = results[i++]) ) {
-					if ( elem.nodeType === 1 ) {
-						tmp.push( elem );
-					}
-				}
-
-				return tmp;
-			}
-			return results;
-		};
-
-	// Class
-	Expr.find["CLASS"] = support.getElementsByClassName && function( className, context ) {
-		if ( typeof context.getElementsByClassName !== "undefined" && documentIsHTML ) {
-			return context.getElementsByClassName( className );
-		}
-	};
-
-	/* QSA/matchesSelector
-	---------------------------------------------------------------------- */
-
-	// QSA and matchesSelector support
-
-	// matchesSelector(:active) reports false when true (IE9/Opera 11.5)
-	rbuggyMatches = [];
-
-	// qSa(:focus) reports false when true (Chrome 21)
-	// We allow this because of a bug in IE8/9 that throws an error
-	// whenever `document.activeElement` is accessed on an iframe
-	// So, we allow :focus to pass through QSA all the time to avoid the IE error
-	// See https://bugs.jquery.com/ticket/13378
-	rbuggyQSA = [];
-
-	if ( (support.qsa = rnative.test( document.querySelectorAll )) ) {
-		// Build QSA regex
-		// Regex strategy adopted from Diego Perini
-		assert(function( el ) {
-			// Select is set to empty string on purpose
-			// This is to test IE's treatment of not explicitly
-			// setting a boolean content attribute,
-			// since its presence should be enough
-			// https://bugs.jquery.com/ticket/12359
-			docElem.appendChild( el ).innerHTML = "<a id='" + expando + "'></a>" +
-				"<select id='" + expando + "-\r\\' msallowcapture=''>" +
-				"<option selected=''></option></select>";
-
-			// Support: IE8, Opera 11-12.16
-			// Nothing should be selected when empty strings follow ^= or $= or *=
-			// The test attribute must be unknown in Opera but "safe" for WinRT
-			// https://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section
-			if ( el.querySelectorAll("[msallowcapture^='']").length ) {
-				rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" );
-			}
-
-			// Support: IE8
-			// Boolean attributes and "value" are not treated correctly
-			if ( !el.querySelectorAll("[selected]").length ) {
-				rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" );
-			}
-
-			// Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+
-			if ( !el.querySelectorAll( "[id~=" + expando + "-]" ).length ) {
-				rbuggyQSA.push("~=");
-			}
-
-			// Webkit/Opera - :checked should return selected option elements
-			// https://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
-			// IE8 throws error here and will not see later tests
-			if ( !el.querySelectorAll(":checked").length ) {
-				rbuggyQSA.push(":checked");
-			}
-
-			// Support: Safari 8+, iOS 8+
-			// https://bugs.webkit.org/show_bug.cgi?id=136851
-			// In-page `selector#id sibling-combinator selector` fails
-			if ( !el.querySelectorAll( "a#" + expando + "+*" ).length ) {
-				rbuggyQSA.push(".#.+[+~]");
-			}
-		});
-
-		assert(function( el ) {
-			el.innerHTML = "<a href='' disabled='disabled'></a>" +
-				"<select disabled='disabled'><option/></select>";
-
-			// Support: Windows 8 Native Apps
-			// The type and name attributes are restricted during .innerHTML assignment
-			var input = document.createElement("input");
-			input.setAttribute( "type", "hidden" );
-			el.appendChild( input ).setAttribute( "name", "D" );
-
-			// Support: IE8
-			// Enforce case-sensitivity of name attribute
-			if ( el.querySelectorAll("[name=d]").length ) {
-				rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" );
-			}
-
-			// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
-			// IE8 throws error here and will not see later tests
-			if ( el.querySelectorAll(":enabled").length !== 2 ) {
-				rbuggyQSA.push( ":enabled", ":disabled" );
-			}
-
-			// Support: IE9-11+
-			// IE's :disabled selector does not pick up the children of disabled fieldsets
-			docElem.appendChild( el ).disabled = true;
-			if ( el.querySelectorAll(":disabled").length !== 2 ) {
-				rbuggyQSA.push( ":enabled", ":disabled" );
-			}
-
-			// Opera 10-11 does not throw on post-comma invalid pseudos
-			el.querySelectorAll("*,:x");
-			rbuggyQSA.push(",.*:");
-		});
-	}
-
-	if ( (support.matchesSelector = rnative.test( (matches = docElem.matches ||
-		docElem.webkitMatchesSelector ||
-		docElem.mozMatchesSelector ||
-		docElem.oMatchesSelector ||
-		docElem.msMatchesSelector) )) ) {
-
-		assert(function( el ) {
-			// Check to see if it's possible to do matchesSelector
-			// on a disconnected node (IE 9)
-			support.disconnectedMatch = matches.call( el, "*" );
-
-			// This should fail with an exception
-			// Gecko does not error, returns false instead
-			matches.call( el, "[s!='']:x" );
-			rbuggyMatches.push( "!=", pseudos );
-		});
-	}
-
-	rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join("|") );
-	rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join("|") );
-
-	/* Contains
-	---------------------------------------------------------------------- */
-	hasCompare = rnative.test( docElem.compareDocumentPosition );
-
-	// Element contains another
-	// Purposefully self-exclusive
-	// As in, an element does not contain itself
-	contains = hasCompare || rnative.test( docElem.contains ) ?
-		function( a, b ) {
-			var adown = a.nodeType === 9 ? a.documentElement : a,
-				bup = b && b.parentNode;
-			return a === bup || !!( bup && bup.nodeType === 1 && (
-				adown.contains ?
-					adown.contains( bup ) :
-					a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16
-			));
-		} :
-		function( a, b ) {
-			if ( b ) {
-				while ( (b = b.parentNode) ) {
-					if ( b === a ) {
-						return true;
-					}
-				}
-			}
-			return false;
-		};
-
-	/* Sorting
-	---------------------------------------------------------------------- */
-
-	// Document order sorting
-	sortOrder = hasCompare ?
-	function( a, b ) {
-
-		// Flag for duplicate removal
-		if ( a === b ) {
-			hasDuplicate = true;
-			return 0;
-		}
-
-		// Sort on method existence if only one input has compareDocumentPosition
-		var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
-		if ( compare ) {
-			return compare;
-		}
-
-		// Calculate position if both inputs belong to the same document
-		compare = ( a.ownerDocument || a ) === ( b.ownerDocument || b ) ?
-			a.compareDocumentPosition( b ) :
-
-			// Otherwise we know they are disconnected
-			1;
-
-		// Disconnected nodes
-		if ( compare & 1 ||
-			(!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) {
-
-			// Choose the first element that is related to our preferred document
-			if ( a === document || a.ownerDocument === preferredDoc && contains(preferredDoc, a) ) {
-				return -1;
-			}
-			if ( b === document || b.ownerDocument === preferredDoc && contains(preferredDoc, b) ) {
-				return 1;
-			}
-
-			// Maintain original order
-			return sortInput ?
-				( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
-				0;
-		}
-
-		return compare & 4 ? -1 : 1;
-	} :
-	function( a, b ) {
-		// Exit early if the nodes are identical
-		if ( a === b ) {
-			hasDuplicate = true;
-			return 0;
-		}
-
-		var cur,
-			i = 0,
-			aup = a.parentNode,
-			bup = b.parentNode,
-			ap = [ a ],
-			bp = [ b ];
-
-		// Parentless nodes are either documents or disconnected
-		if ( !aup || !bup ) {
-			return a === document ? -1 :
-				b === document ? 1 :
-				aup ? -1 :
-				bup ? 1 :
-				sortInput ?
-				( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
-				0;
-
-		// If the nodes are siblings, we can do a quick check
-		} else if ( aup === bup ) {
-			return siblingCheck( a, b );
-		}
-
-		// Otherwise we need full lists of their ancestors for comparison
-		cur = a;
-		while ( (cur = cur.parentNode) ) {
-			ap.unshift( cur );
-		}
-		cur = b;
-		while ( (cur = cur.parentNode) ) {
-			bp.unshift( cur );
-		}
-
-		// Walk down the tree looking for a discrepancy
-		while ( ap[i] === bp[i] ) {
-			i++;
-		}
-
-		return i ?
-			// Do a sibling check if the nodes have a common ancestor
-			siblingCheck( ap[i], bp[i] ) :
-
-			// Otherwise nodes in our document sort first
-			ap[i] === preferredDoc ? -1 :
-			bp[i] === preferredDoc ? 1 :
-			0;
-	};
-
-	return document;
-};
-
-Sizzle.matches = function( expr, elements ) {
-	return Sizzle( expr, null, null, elements );
-};
-
-Sizzle.matchesSelector = function( elem, expr ) {
-	// Set document vars if needed
-	if ( ( elem.ownerDocument || elem ) !== document ) {
-		setDocument( elem );
-	}
-
-	// Make sure that attribute selectors are quoted
-	expr = expr.replace( rattributeQuotes, "='$1']" );
-
-	if ( support.matchesSelector && documentIsHTML &&
-		!compilerCache[ expr + " " ] &&
-		( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&
-		( !rbuggyQSA     || !rbuggyQSA.test( expr ) ) ) {
-
-		try {
-			var ret = matches.call( elem, expr );
-
-			// IE 9's matchesSelector returns false on disconnected nodes
-			if ( ret || support.disconnectedMatch ||
-					// As well, disconnected nodes are said to be in a document
-					// fragment in IE 9
-					elem.document && elem.document.nodeType !== 11 ) {
-				return ret;
-			}
-		} catch (e) {}
-	}
-
-	return Sizzle( expr, document, null, [ elem ] ).length > 0;
-};
-
-Sizzle.contains = function( context, elem ) {
-	// Set document vars if needed
-	if ( ( context.ownerDocument || context ) !== document ) {
-		setDocument( context );
-	}
-	return contains( context, elem );
-};
-
-Sizzle.attr = function( elem, name ) {
-	// Set document vars if needed
-	if ( ( elem.ownerDocument || elem ) !== document ) {
-		setDocument( elem );
-	}
-
-	var fn = Expr.attrHandle[ name.toLowerCase() ],
-		// Don't get fooled by Object.prototype properties (jQuery #13807)
-		val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?
-			fn( elem, name, !documentIsHTML ) :
-			undefined;
-
-	return val !== undefined ?
-		val :
-		support.attributes || !documentIsHTML ?
-			elem.getAttribute( name ) :
-			(val = elem.getAttributeNode(name)) && val.specified ?
-				val.value :
-				null;
-};
-
-Sizzle.escape = function( sel ) {
-	return (sel + "").replace( rcssescape, fcssescape );
-};
-
-Sizzle.error = function( msg ) {
-	throw new Error( "Syntax error, unrecognized expression: " + msg );
-};
-
-/**
- * Document sorting and removing duplicates
- * @param {ArrayLike} results
- */
-Sizzle.uniqueSort = function( results ) {
-	var elem,
-		duplicates = [],
-		j = 0,
-		i = 0;
-
-	// Unless we *know* we can detect duplicates, assume their presence
-	hasDuplicate = !support.detectDuplicates;
-	sortInput = !support.sortStable && results.slice( 0 );
-	results.sort( sortOrder );
-
-	if ( hasDuplicate ) {
-		while ( (elem = results[i++]) ) {
-			if ( elem === results[ i ] ) {
-				j = duplicates.push( i );
-			}
-		}
-		while ( j-- ) {
-			results.splice( duplicates[ j ], 1 );
-		}
-	}
-
-	// Clear input after sorting to release objects
-	// See https://github.com/jquery/sizzle/pull/225
-	sortInput = null;
-
-	return results;
-};
-
-/**
- * Utility function for retrieving the text value of an array of DOM nodes
- * @param {Array|Element} elem
- */
-getText = Sizzle.getText = function( elem ) {
-	var node,
-		ret = "",
-		i = 0,
-		nodeType = elem.nodeType;
-
-	if ( !nodeType ) {
-		// If no nodeType, this is expected to be an array
-		while ( (node = elem[i++]) ) {
-			// Do not traverse comment nodes
-			ret += getText( node );
-		}
-	} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
-		// Use textContent for elements
-		// innerText usage removed for consistency of new lines (jQuery #11153)
-		if ( typeof elem.textContent === "string" ) {
-			return elem.textContent;
-		} else {
-			// Traverse its children
-			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
-				ret += getText( elem );
-			}
-		}
-	} else if ( nodeType === 3 || nodeType === 4 ) {
-		return elem.nodeValue;
-	}
-	// Do not include comment or processing instruction nodes
-
-	return ret;
-};
-
-Expr = Sizzle.selectors = {
-
-	// Can be adjusted by the user
-	cacheLength: 50,
-
-	createPseudo: markFunction,
-
-	match: matchExpr,
-
-	attrHandle: {},
-
-	find: {},
-
-	relative: {
-		">": { dir: "parentNode", first: true },
-		" ": { dir: "parentNode" },
-		"+": { dir: "previousSibling", first: true },
-		"~": { dir: "previousSibling" }
-	},
-
-	preFilter: {
-		"ATTR": function( match ) {
-			match[1] = match[1].replace( runescape, funescape );
-
-			// Move the given value to match[3] whether quoted or unquoted
-			match[3] = ( match[3] || match[4] || match[5] || "" ).replace( runescape, funescape );
-
-			if ( match[2] === "~=" ) {
-				match[3] = " " + match[3] + " ";
-			}
-
-			return match.slice( 0, 4 );
-		},
-
-		"CHILD": function( match ) {
-			/* matches from matchExpr["CHILD"]
-				1 type (only|nth|...)
-				2 what (child|of-type)
-				3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
-				4 xn-component of xn+y argument ([+-]?\d*n|)
-				5 sign of xn-component
-				6 x of xn-component
-				7 sign of y-component
-				8 y of y-component
-			*/
-			match[1] = match[1].toLowerCase();
-
-			if ( match[1].slice( 0, 3 ) === "nth" ) {
-				// nth-* requires argument
-				if ( !match[3] ) {
-					Sizzle.error( match[0] );
-				}
-
-				// numeric x and y parameters for Expr.filter.CHILD
-				// remember that false/true cast respectively to 0/1
-				match[4] = +( match[4] ? match[5] + (match[6] || 1) : 2 * ( match[3] === "even" || match[3] === "odd" ) );
-				match[5] = +( ( match[7] + match[8] ) || match[3] === "odd" );
-
-			// other types prohibit arguments
-			} else if ( match[3] ) {
-				Sizzle.error( match[0] );
-			}
-
-			return match;
-		},
-
-		"PSEUDO": function( match ) {
-			var excess,
-				unquoted = !match[6] && match[2];
-
-			if ( matchExpr["CHILD"].test( match[0] ) ) {
-				return null;
-			}
-
-			// Accept quoted arguments as-is
-			if ( match[3] ) {
-				match[2] = match[4] || match[5] || "";
-
-			// Strip excess characters from unquoted arguments
-			} else if ( unquoted && rpseudo.test( unquoted ) &&
-				// Get excess from tokenize (recursively)
-				(excess = tokenize( unquoted, true )) &&
-				// advance to the next closing parenthesis
-				(excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) {
-
-				// excess is a negative index
-				match[0] = match[0].slice( 0, excess );
-				match[2] = unquoted.slice( 0, excess );
-			}
-
-			// Return only captures needed by the pseudo filter method (type and argument)
-			return match.slice( 0, 3 );
-		}
-	},
-
-	filter: {
-
-		"TAG": function( nodeNameSelector ) {
-			var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();
-			return nodeNameSelector === "*" ?
-				function() { return true; } :
-				function( elem ) {
-					return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
-				};
-		},
-
-		"CLASS": function( className ) {
-			var pattern = classCache[ className + " " ];
-
-			return pattern ||
-				(pattern = new RegExp( "(^|" + whitespace + ")" + className + "(" + whitespace + "|$)" )) &&
-				classCache( className, function( elem ) {
-					return pattern.test( typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== "undefined" && elem.getAttribute("class") || "" );
-				});
-		},
-
-		"ATTR": function( name, operator, check ) {
-			return function( elem ) {
-				var result = Sizzle.attr( elem, name );
-
-				if ( result == null ) {
-					return operator === "!=";
-				}
-				if ( !operator ) {
-					return true;
-				}
-
-				result += "";
-
-				return operator === "=" ? result === check :
-					operator === "!=" ? result !== check :
-					operator === "^=" ? check && result.indexOf( check ) === 0 :
-					operator === "*=" ? check && result.indexOf( check ) > -1 :
-					operator === "$=" ? check && result.slice( -check.length ) === check :
-					operator === "~=" ? ( " " + result.replace( rwhitespace, " " ) + " " ).indexOf( check ) > -1 :
-					operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" :
-					false;
-			};
-		},
-
-		"CHILD": function( type, what, argument, first, last ) {
-			var simple = type.slice( 0, 3 ) !== "nth",
-				forward = type.slice( -4 ) !== "last",
-				ofType = what === "of-type";
-
-			return first === 1 && last === 0 ?
-
-				// Shortcut for :nth-*(n)
-				function( elem ) {
-					return !!elem.parentNode;
-				} :
-
-				function( elem, context, xml ) {
-					var cache, uniqueCache, outerCache, node, nodeIndex, start,
-						dir = simple !== forward ? "nextSibling" : "previousSibling",
-						parent = elem.parentNode,
-						name = ofType && elem.nodeName.toLowerCase(),
-						useCache = !xml && !ofType,
-						diff = false;
-
-					if ( parent ) {
-
-						// :(first|last|only)-(child|of-type)
-						if ( simple ) {
-							while ( dir ) {
-								node = elem;
-								while ( (node = node[ dir ]) ) {
-									if ( ofType ?
-										node.nodeName.toLowerCase() === name :
-										node.nodeType === 1 ) {
-
-										return false;
-									}
-								}
-								// Reverse direction for :only-* (if we haven't yet done so)
-								start = dir = type === "only" && !start && "nextSibling";
-							}
-							return true;
-						}
-
-						start = [ forward ? parent.firstChild : parent.lastChild ];
-
-						// non-xml :nth-child(...) stores cache data on `parent`
-						if ( forward && useCache ) {
-
-							// Seek `elem` from a previously-cached index
-
-							// ...in a gzip-friendly way
-							node = parent;
-							outerCache = node[ expando ] || (node[ expando ] = {});
-
-							// Support: IE <9 only
-							// Defend against cloned attroperties (jQuery gh-1709)
-							uniqueCache = outerCache[ node.uniqueID ] ||
-								(outerCache[ node.uniqueID ] = {});
-
-							cache = uniqueCache[ type ] || [];
-							nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
-							diff = nodeIndex && cache[ 2 ];
-							node = nodeIndex && parent.childNodes[ nodeIndex ];
-
-							while ( (node = ++nodeIndex && node && node[ dir ] ||
-
-								// Fallback to seeking `elem` from the start
-								(diff = nodeIndex = 0) || start.pop()) ) {
-
-								// When found, cache indexes on `parent` and break
-								if ( node.nodeType === 1 && ++diff && node === elem ) {
-									uniqueCache[ type ] = [ dirruns, nodeIndex, diff ];
-									break;
-								}
-							}
-
-						} else {
-							// Use previously-cached element index if available
-							if ( useCache ) {
-								// ...in a gzip-friendly way
-								node = elem;
-								outerCache = node[ expando ] || (node[ expando ] = {});
-
-								// Support: IE <9 only
-								// Defend against cloned attroperties (jQuery gh-1709)
-								uniqueCache = outerCache[ node.uniqueID ] ||
-									(outerCache[ node.uniqueID ] = {});
-
-								cache = uniqueCache[ type ] || [];
-								nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
-								diff = nodeIndex;
-							}
-
-							// xml :nth-child(...)
-							// or :nth-last-child(...) or :nth(-last)?-of-type(...)
-							if ( diff === false ) {
-								// Use the same loop as above to seek `elem` from the start
-								while ( (node = ++nodeIndex && node && node[ dir ] ||
-									(diff = nodeIndex = 0) || start.pop()) ) {
-
-									if ( ( ofType ?
-										node.nodeName.toLowerCase() === name :
-										node.nodeType === 1 ) &&
-										++diff ) {
-
-										// Cache the index of each encountered element
-										if ( useCache ) {
-											outerCache = node[ expando ] || (node[ expando ] = {});
-
-											// Support: IE <9 only
-											// Defend against cloned attroperties (jQuery gh-1709)
-											uniqueCache = outerCache[ node.uniqueID ] ||
-												(outerCache[ node.uniqueID ] = {});
-
-											uniqueCache[ type ] = [ dirruns, diff ];
-										}
-
-										if ( node === elem ) {
-											break;
-										}
-									}
-								}
-							}
-						}
-
-						// Incorporate the offset, then check against cycle size
-						diff -= last;
-						return diff === first || ( diff % first === 0 && diff / first >= 0 );
-					}
-				};
-		},
-
-		"PSEUDO": function( pseudo, argument ) {
-			// pseudo-class names are case-insensitive
-			// https://www.w3.org/TR/selectors/#pseudo-classes
-			// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
-			// Remember that setFilters inherits from pseudos
-			var args,
-				fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||
-					Sizzle.error( "unsupported pseudo: " + pseudo );
-
-			// The user may use createPseudo to indicate that
-			// arguments are needed to create the filter function
-			// just as Sizzle does
-			if ( fn[ expando ] ) {
-				return fn( argument );
-			}
-
-			// But maintain support for old signatures
-			if ( fn.length > 1 ) {
-				args = [ pseudo, pseudo, "", argument ];
-				return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?
-					markFunction(function( seed, matches ) {
-						var idx,
-							matched = fn( seed, argument ),
-							i = matched.length;
-						while ( i-- ) {
-							idx = indexOf( seed, matched[i] );
-							seed[ idx ] = !( matches[ idx ] = matched[i] );
-						}
-					}) :
-					function( elem ) {
-						return fn( elem, 0, args );
-					};
-			}
-
-			return fn;
-		}
-	},
-
-	pseudos: {
-		// Potentially complex pseudos
-		"not": markFunction(function( selector ) {
-			// Trim the selector passed to compile
-			// to avoid treating leading and trailing
-			// spaces as combinators
-			var input = [],
-				results = [],
-				matcher = compile( selector.replace( rtrim, "$1" ) );
-
-			return matcher[ expando ] ?
-				markFunction(function( seed, matches, context, xml ) {
-					var elem,
-						unmatched = matcher( seed, null, xml, [] ),
-						i = seed.length;
-
-					// Match elements unmatched by `matcher`
-					while ( i-- ) {
-						if ( (elem = unmatched[i]) ) {
-							seed[i] = !(matches[i] = elem);
-						}
-					}
-				}) :
-				function( elem, context, xml ) {
-					input[0] = elem;
-					matcher( input, null, xml, results );
-					// Don't keep the element (issue #299)
-					input[0] = null;
-					return !results.pop();
-				};
-		}),
-
-		"has": markFunction(function( selector ) {
-			return function( elem ) {
-				return Sizzle( selector, elem ).length > 0;
-			};
-		}),
-
-		"contains": markFunction(function( text ) {
-			text = text.replace( runescape, funescape );
-			return function( elem ) {
-				return ( elem.textContent || elem.innerText || getText( elem ) ).indexOf( text ) > -1;
-			};
-		}),
-
-		// "Whether an element is represented by a :lang() selector
-		// is based solely on the element's language value
-		// being equal to the identifier C,
-		// or beginning with the identifier C immediately followed by "-".
-		// The matching of C against the element's language value is performed case-insensitively.
-		// The identifier C does not have to be a valid language name."
-		// https://www.w3.org/TR/selectors/#lang-pseudo
-		"lang": markFunction( function( lang ) {
-			// lang value must be a valid identifier
-			if ( !ridentifier.test(lang || "") ) {
-				Sizzle.error( "unsupported lang: " + lang );
-			}
-			lang = lang.replace( runescape, funescape ).toLowerCase();
-			return function( elem ) {
-				var elemLang;
-				do {
-					if ( (elemLang = documentIsHTML ?
-						elem.lang :
-						elem.getAttribute("xml:lang") || elem.getAttribute("lang")) ) {
-
-						elemLang = elemLang.toLowerCase();
-						return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0;
-					}
-				} while ( (elem = elem.parentNode) && elem.nodeType === 1 );
-				return false;
-			};
-		}),
-
-		// Miscellaneous
-		"target": function( elem ) {
-			var hash = window.location && window.location.hash;
-			return hash && hash.slice( 1 ) === elem.id;
-		},
-
-		"root": function( elem ) {
-			return elem === docElem;
-		},
-
-		"focus": function( elem ) {
-			return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);
-		},
-
-		// Boolean properties
-		"enabled": createDisabledPseudo( false ),
-		"disabled": createDisabledPseudo( true ),
-
-		"checked": function( elem ) {
-			// In CSS3, :checked should return both checked and selected elements
-			// https://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
-			var nodeName = elem.nodeName.toLowerCase();
-			return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected);
-		},
-
-		"selected": function( elem ) {
-			// Accessing this property makes selected-by-default
-			// options in Safari work properly
-			if ( elem.parentNode ) {
-				elem.parentNode.selectedIndex;
-			}
-
-			return elem.selected === true;
-		},
-
-		// Contents
-		"empty": function( elem ) {
-			// https://www.w3.org/TR/selectors/#empty-pseudo
-			// :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),
-			//   but not by others (comment: 8; processing instruction: 7; etc.)
-			// nodeType < 6 works because attributes (2) do not appear as children
-			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
-				if ( elem.nodeType < 6 ) {
-					return false;
-				}
-			}
-			return true;
-		},
-
-		"parent": function( elem ) {
-			return !Expr.pseudos["empty"]( elem );
-		},
-
-		// Element/input types
-		"header": function( elem ) {
-			return rheader.test( elem.nodeName );
-		},
-
-		"input": function( elem ) {
-			return rinputs.test( elem.nodeName );
-		},
-
-		"button": function( elem ) {
-			var name = elem.nodeName.toLowerCase();
-			return name === "input" && elem.type === "button" || name === "button";
-		},
-
-		"text": function( elem ) {
-			var attr;
-			return elem.nodeName.toLowerCase() === "input" &&
-				elem.type === "text" &&
-
-				// Support: IE<8
-				// New HTML5 attribute values (e.g., "search") appear with elem.type === "text"
-				( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === "text" );
-		},
-
-		// Position-in-collection
-		"first": createPositionalPseudo(function() {
-			return [ 0 ];
-		}),
-
-		"last": createPositionalPseudo(function( matchIndexes, length ) {
-			return [ length - 1 ];
-		}),
-
-		"eq": createPositionalPseudo(function( matchIndexes, length, argument ) {
-			return [ argument < 0 ? argument + length : argument ];
-		}),
-
-		"even": createPositionalPseudo(function( matchIndexes, length ) {
-			var i = 0;
-			for ( ; i < length; i += 2 ) {
-				matchIndexes.push( i );
-			}
-			return matchIndexes;
-		}),
-
-		"odd": createPositionalPseudo(function( matchIndexes, length ) {
-			var i = 1;
-			for ( ; i < length; i += 2 ) {
-				matchIndexes.push( i );
-			}
-			return matchIndexes;
-		}),
-
-		"lt": createPositionalPseudo(function( matchIndexes, length, argument ) {
-			var i = argument < 0 ? argument + length : argument;
-			for ( ; --i >= 0; ) {
-				matchIndexes.push( i );
-			}
-			return matchIndexes;
-		}),
-
-		"gt": createPositionalPseudo(function( matchIndexes, length, argument ) {
-			var i = argument < 0 ? argument + length : argument;
-			for ( ; ++i < length; ) {
-				matchIndexes.push( i );
-			}
-			return matchIndexes;
-		})
-	}
-};
-
-Expr.pseudos["nth"] = Expr.pseudos["eq"];
-
-// Add button/input type pseudos
-for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {
-	Expr.pseudos[ i ] = createInputPseudo( i );
-}
-for ( i in { submit: true, reset: true } ) {
-	Expr.pseudos[ i ] = createButtonPseudo( i );
-}
-
-// Easy API for creating new setFilters
-function setFilters() {}
-setFilters.prototype = Expr.filters = Expr.pseudos;
-Expr.setFilters = new setFilters();
-
-tokenize = Sizzle.tokenize = function( selector, parseOnly ) {
-	var matched, match, tokens, type,
-		soFar, groups, preFilters,
-		cached = tokenCache[ selector + " " ];
-
-	if ( cached ) {
-		return parseOnly ? 0 : cached.slice( 0 );
-	}
-
-	soFar = selector;
-	groups = [];
-	preFilters = Expr.preFilter;
-
-	while ( soFar ) {
-
-		// Comma and first run
-		if ( !matched || (match = rcomma.exec( soFar )) ) {
-			if ( match ) {
-				// Don't consume trailing commas as valid
-				soFar = soFar.slice( match[0].length ) || soFar;
-			}
-			groups.push( (tokens = []) );
-		}
-
-		matched = false;
-
-		// Combinators
-		if ( (match = rcombinators.exec( soFar )) ) {
-			matched = match.shift();
-			tokens.push({
-				value: matched,
-				// Cast descendant combinators to space
-				type: match[0].replace( rtrim, " " )
-			});
-			soFar = soFar.slice( matched.length );
-		}
-
-		// Filters
-		for ( type in Expr.filter ) {
-			if ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] ||
-				(match = preFilters[ type ]( match ))) ) {
-				matched = match.shift();
-				tokens.push({
-					value: matched,
-					type: type,
-					matches: match
-				});
-				soFar = soFar.slice( matched.length );
-			}
-		}
-
-		if ( !matched ) {
-			break;
-		}
-	}
-
-	// Return the length of the invalid excess
-	// if we're just parsing
-	// Otherwise, throw an error or return tokens
-	return parseOnly ?
-		soFar.length :
-		soFar ?
-			Sizzle.error( selector ) :
-			// Cache the tokens
-			tokenCache( selector, groups ).slice( 0 );
-};
-
-function toSelector( tokens ) {
-	var i = 0,
-		len = tokens.length,
-		selector = "";
-	for ( ; i < len; i++ ) {
-		selector += tokens[i].value;
-	}
-	return selector;
-}
-
-function addCombinator( matcher, combinator, base ) {
-	var dir = combinator.dir,
-		skip = combinator.next,
-		key = skip || dir,
-		checkNonElements = base && key === "parentNode",
-		doneName = done++;
-
-	return combinator.first ?
-		// Check against closest ancestor/preceding element
-		function( elem, context, xml ) {
-			while ( (elem = elem[ dir ]) ) {
-				if ( elem.nodeType === 1 || checkNonElements ) {
-					return matcher( elem, context, xml );
-				}
-			}
-			return false;
-		} :
-
-		// Check against all ancestor/preceding elements
-		function( elem, context, xml ) {
-			var oldCache, uniqueCache, outerCache,
-				newCache = [ dirruns, doneName ];
-
-			// We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching
-			if ( xml ) {
-				while ( (elem = elem[ dir ]) ) {
-					if ( elem.nodeType === 1 || checkNonElements ) {
-						if ( matcher( elem, context, xml ) ) {
-							return true;
-						}
-					}
-				}
-			} else {
-				while ( (elem = elem[ dir ]) ) {
-					if ( elem.nodeType === 1 || checkNonElements ) {
-						outerCache = elem[ expando ] || (elem[ expando ] = {});
-
-						// Support: IE <9 only
-						// Defend against cloned attroperties (jQuery gh-1709)
-						uniqueCache = outerCache[ elem.uniqueID ] || (outerCache[ elem.uniqueID ] = {});
-
-						if ( skip && skip === elem.nodeName.toLowerCase() ) {
-							elem = elem[ dir ] || elem;
-						} else if ( (oldCache = uniqueCache[ key ]) &&
-							oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {
-
-							// Assign to newCache so results back-propagate to previous elements
-							return (newCache[ 2 ] = oldCache[ 2 ]);
-						} else {
-							// Reuse newcache so results back-propagate to previous elements
-							uniqueCache[ key ] = newCache;
-
-							// A match means we're done; a fail means we have to keep checking
-							if ( (newCache[ 2 ] = matcher( elem, context, xml )) ) {
-								return true;
-							}
-						}
-					}
-				}
-			}
-			return false;
-		};
-}
-
-function elementMatcher( matchers ) {
-	return matchers.length > 1 ?
-		function( elem, context, xml ) {
-			var i = matchers.length;
-			while ( i-- ) {
-				if ( !matchers[i]( elem, context, xml ) ) {
-					return false;
-				}
-			}
-			return true;
-		} :
-		matchers[0];
-}
-
-function multipleContexts( selector, contexts, results ) {
-	var i = 0,
-		len = contexts.length;
-	for ( ; i < len; i++ ) {
-		Sizzle( selector, contexts[i], results );
-	}
-	return results;
-}
-
-function condense( unmatched, map, filter, context, xml ) {
-	var elem,
-		newUnmatched = [],
-		i = 0,
-		len = unmatched.length,
-		mapped = map != null;
-
-	for ( ; i < len; i++ ) {
-		if ( (elem = unmatched[i]) ) {
-			if ( !filter || filter( elem, context, xml ) ) {
-				newUnmatched.push( elem );
-				if ( mapped ) {
-					map.push( i );
-				}
-			}
-		}
-	}
-
-	return newUnmatched;
-}
-
-function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {
-	if ( postFilter && !postFilter[ expando ] ) {
-		postFilter = setMatcher( postFilter );
-	}
-	if ( postFinder && !postFinder[ expando ] ) {
-		postFinder = setMatcher( postFinder, postSelector );
-	}
-	return markFunction(function( seed, results, context, xml ) {
-		var temp, i, elem,
-			preMap = [],
-			postMap = [],
-			preexisting = results.length,
-
-			// Get initial elements from seed or context
-			elems = seed || multipleContexts( selector || "*", context.nodeType ? [ context ] : context, [] ),
-
-			// Prefilter to get matcher input, preserving a map for seed-results synchronization
-			matcherIn = preFilter && ( seed || !selector ) ?
-				condense( elems, preMap, preFilter, context, xml ) :
-				elems,
-
-			matcherOut = matcher ?
-				// If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
-				postFinder || ( seed ? preFilter : preexisting || postFilter ) ?
-
-					// ...intermediate processing is necessary
-					[] :
-
-					// ...otherwise use results directly
-					results :
-				matcherIn;
-
-		// Find primary matches
-		if ( matcher ) {
-			matcher( matcherIn, matcherOut, context, xml );
-		}
-
-		// Apply postFilter
-		if ( postFilter ) {
-			temp = condense( matcherOut, postMap );
-			postFilter( temp, [], context, xml );
-
-			// Un-match failing elements by moving them back to matcherIn
-			i = temp.length;
-			while ( i-- ) {
-				if ( (elem = temp[i]) ) {
-					matcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem);
-				}
-			}
-		}
-
-		if ( seed ) {
-			if ( postFinder || preFilter ) {
-				if ( postFinder ) {
-					// Get the final matcherOut by condensing this intermediate into postFinder contexts
-					temp = [];
-					i = matcherOut.length;
-					while ( i-- ) {
-						if ( (elem = matcherOut[i]) ) {
-							// Restore matcherIn since elem is not yet a final match
-							temp.push( (matcherIn[i] = elem) );
-						}
-					}
-					postFinder( null, (matcherOut = []), temp, xml );
-				}
-
-				// Move matched elements from seed to results to keep them synchronized
-				i = matcherOut.length;
-				while ( i-- ) {
-					if ( (elem = matcherOut[i]) &&
-						(temp = postFinder ? indexOf( seed, elem ) : preMap[i]) > -1 ) {
-
-						seed[temp] = !(results[temp] = elem);
-					}
-				}
-			}
-
-		// Add elements to results, through postFinder if defined
-		} else {
-			matcherOut = condense(
-				matcherOut === results ?
-					matcherOut.splice( preexisting, matcherOut.length ) :
-					matcherOut
-			);
-			if ( postFinder ) {
-				postFinder( null, results, matcherOut, xml );
-			} else {
-				push.apply( results, matcherOut );
-			}
-		}
-	});
-}
-
-function matcherFromTokens( tokens ) {
-	var checkContext, matcher, j,
-		len = tokens.length,
-		leadingRelative = Expr.relative[ tokens[0].type ],
-		implicitRelative = leadingRelative || Expr.relative[" "],
-		i = leadingRelative ? 1 : 0,
-
-		// The foundational matcher ensures that elements are reachable from top-level context(s)
-		matchContext = addCombinator( function( elem ) {
-			return elem === checkContext;
-		}, implicitRelative, true ),
-		matchAnyContext = addCombinator( function( elem ) {
-			return indexOf( checkContext, elem ) > -1;
-		}, implicitRelative, true ),
-		matchers = [ function( elem, context, xml ) {
-			var ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || (
-				(checkContext = context).nodeType ?
-					matchContext( elem, context, xml ) :
-					matchAnyContext( elem, context, xml ) );
-			// Avoid hanging onto element (issue #299)
-			checkContext = null;
-			return ret;
-		} ];
-
-	for ( ; i < len; i++ ) {
-		if ( (matcher = Expr.relative[ tokens[i].type ]) ) {
-			matchers = [ addCombinator(elementMatcher( matchers ), matcher) ];
-		} else {
-			matcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches );
-
-			// Return special upon seeing a positional matcher
-			if ( matcher[ expando ] ) {
-				// Find the next relative operator (if any) for proper handling
-				j = ++i;
-				for ( ; j < len; j++ ) {
-					if ( Expr.relative[ tokens[j].type ] ) {
-						break;
-					}
-				}
-				return setMatcher(
-					i > 1 && elementMatcher( matchers ),
-					i > 1 && toSelector(
-						// If the preceding token was a descendant combinator, insert an implicit any-element `*`
-						tokens.slice( 0, i - 1 ).concat({ value: tokens[ i - 2 ].type === " " ? "*" : "" })
-					).replace( rtrim, "$1" ),
-					matcher,
-					i < j && matcherFromTokens( tokens.slice( i, j ) ),
-					j < len && matcherFromTokens( (tokens = tokens.slice( j )) ),
-					j < len && toSelector( tokens )
-				);
-			}
-			matchers.push( matcher );
-		}
-	}
-
-	return elementMatcher( matchers );
-}
-
-function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
-	var bySet = setMatchers.length > 0,
-		byElement = elementMatchers.length > 0,
-		superMatcher = function( seed, context, xml, results, outermost ) {
-			var elem, j, matcher,
-				matchedCount = 0,
-				i = "0",
-				unmatched = seed && [],
-				setMatched = [],
-				contextBackup = outermostContext,
-				// We must always have either seed elements or outermost context
-				elems = seed || byElement && Expr.find["TAG"]( "*", outermost ),
-				// Use integer dirruns iff this is the outermost matcher
-				dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1),
-				len = elems.length;
-
-			if ( outermost ) {
-				outermostContext = context === document || context || outermost;
-			}
-
-			// Add elements passing elementMatchers directly to results
-			// Support: IE<9, Safari
-			// Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id
-			for ( ; i !== len && (elem = elems[i]) != null; i++ ) {
-				if ( byElement && elem ) {
-					j = 0;
-					if ( !context && elem.ownerDocument !== document ) {
-						setDocument( elem );
-						xml = !documentIsHTML;
-					}
-					while ( (matcher = elementMatchers[j++]) ) {
-						if ( matcher( elem, context || document, xml) ) {
-							results.push( elem );
-							break;
-						}
-					}
-					if ( outermost ) {
-						dirruns = dirrunsUnique;
-					}
-				}
-
-				// Track unmatched elements for set filters
-				if ( bySet ) {
-					// They will have gone through all possible matchers
-					if ( (elem = !matcher && elem) ) {
-						matchedCount--;
-					}
-
-					// Lengthen the array for every element, matched or not
-					if ( seed ) {
-						unmatched.push( elem );
-					}
-				}
-			}
-
-			// `i` is now the count of elements visited above, and adding it to `matchedCount`
-			// makes the latter nonnegative.
-			matchedCount += i;
-
-			// Apply set filters to unmatched elements
-			// NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`
-			// equals `i`), unless we didn't visit _any_ elements in the above loop because we have
-			// no element matchers and no seed.
-			// Incrementing an initially-string "0" `i` allows `i` to remain a string only in that
-			// case, which will result in a "00" `matchedCount` that differs from `i` but is also
-			// numerically zero.
-			if ( bySet && i !== matchedCount ) {
-				j = 0;
-				while ( (matcher = setMatchers[j++]) ) {
-					matcher( unmatched, setMatched, context, xml );
-				}
-
-				if ( seed ) {
-					// Reintegrate element matches to eliminate the need for sorting
-					if ( matchedCount > 0 ) {
-						while ( i-- ) {
-							if ( !(unmatched[i] || setMatched[i]) ) {
-								setMatched[i] = pop.call( results );
-							}
-						}
-					}
-
-					// Discard index placeholder values to get only actual matches
-					setMatched = condense( setMatched );
-				}
-
-				// Add matches to results
-				push.apply( results, setMatched );
-
-				// Seedless set matches succeeding multiple successful matchers stipulate sorting
-				if ( outermost && !seed && setMatched.length > 0 &&
-					( matchedCount + setMatchers.length ) > 1 ) {
-
-					Sizzle.uniqueSort( results );
-				}
-			}
-
-			// Override manipulation of globals by nested matchers
-			if ( outermost ) {
-				dirruns = dirrunsUnique;
-				outermostContext = contextBackup;
-			}
-
-			return unmatched;
-		};
-
-	return bySet ?
-		markFunction( superMatcher ) :
-		superMatcher;
-}
-
-compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) {
-	var i,
-		setMatchers = [],
-		elementMatchers = [],
-		cached = compilerCache[ selector + " " ];
-
-	if ( !cached ) {
-		// Generate a function of recursive functions that can be used to check each element
-		if ( !match ) {
-			match = tokenize( selector );
-		}
-		i = match.length;
-		while ( i-- ) {
-			cached = matcherFromTokens( match[i] );
-			if ( cached[ expando ] ) {
-				setMatchers.push( cached );
-			} else {
-				elementMatchers.push( cached );
-			}
-		}
-
-		// Cache the compiled function
-		cached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) );
-
-		// Save selector and tokenization
-		cached.selector = selector;
-	}
-	return cached;
-};
-
-/**
- * A low-level selection function that works with Sizzle's compiled
- *  selector functions
- * @param {String|Function} selector A selector or a pre-compiled
- *  selector function built with Sizzle.compile
- * @param {Element} context
- * @param {Array} [results]
- * @param {Array} [seed] A set of elements to match against
- */
-select = Sizzle.select = function( selector, context, results, seed ) {
-	var i, tokens, token, type, find,
-		compiled = typeof selector === "function" && selector,
-		match = !seed && tokenize( (selector = compiled.selector || selector) );
-
-	results = results || [];
-
-	// Try to minimize operations if there is only one selector in the list and no seed
-	// (the latter of which guarantees us context)
-	if ( match.length === 1 ) {
-
-		// Reduce context if the leading compound selector is an ID
-		tokens = match[0] = match[0].slice( 0 );
-		if ( tokens.length > 2 && (token = tokens[0]).type === "ID" &&
-				context.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[1].type ] ) {
-
-			context = ( Expr.find["ID"]( token.matches[0].replace(runescape, funescape), context ) || [] )[0];
-			if ( !context ) {
-				return results;
-
-			// Precompiled matchers will still verify ancestry, so step up a level
-			} else if ( compiled ) {
-				context = context.parentNode;
-			}
-
-			selector = selector.slice( tokens.shift().value.length );
-		}
-
-		// Fetch a seed set for right-to-left matching
-		i = matchExpr["needsContext"].test( selector ) ? 0 : tokens.length;
-		while ( i-- ) {
-			token = tokens[i];
-
-			// Abort if we hit a combinator
-			if ( Expr.relative[ (type = token.type) ] ) {
-				break;
-			}
-			if ( (find = Expr.find[ type ]) ) {
-				// Search, expanding context for leading sibling combinators
-				if ( (seed = find(
-					token.matches[0].replace( runescape, funescape ),
-					rsibling.test( tokens[0].type ) && testContext( context.parentNode ) || context
-				)) ) {
-
-					// If seed is empty or no tokens remain, we can return early
-					tokens.splice( i, 1 );
-					selector = seed.length && toSelector( tokens );
-					if ( !selector ) {
-						push.apply( results, seed );
-						return results;
-					}
-
-					break;
-				}
-			}
-		}
-	}
-
-	// Compile and execute a filtering function if one is not provided
-	// Provide `match` to avoid retokenization if we modified the selector above
-	( compiled || compile( selector, match ) )(
-		seed,
-		context,
-		!documentIsHTML,
-		results,
-		!context || rsibling.test( selector ) && testContext( context.parentNode ) || context
-	);
-	return results;
-};
-
-// One-time assignments
-
-// Sort stability
-support.sortStable = expando.split("").sort( sortOrder ).join("") === expando;
-
-// Support: Chrome 14-35+
-// Always assume duplicates if they aren't passed to the comparison function
-support.detectDuplicates = !!hasDuplicate;
-
-// Initialize against the default document
-setDocument();
-
-// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)
-// Detached nodes confoundingly follow *each other*
-support.sortDetached = assert(function( el ) {
-	// Should return 1, but returns 4 (following)
-	return el.compareDocumentPosition( document.createElement("fieldset") ) & 1;
-});
-
-// Support: IE<8
-// Prevent attribute/property "interpolation"
-// https://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
-if ( !assert(function( el ) {
-	el.innerHTML = "<a href='#'></a>";
-	return el.firstChild.getAttribute("href") === "#" ;
-}) ) {
-	addHandle( "type|href|height|width", function( elem, name, isXML ) {
-		if ( !isXML ) {
-			return elem.getAttribute( name, name.toLowerCase() === "type" ? 1 : 2 );
-		}
-	});
-}
-
-// Support: IE<9
-// Use defaultValue in place of getAttribute("value")
-if ( !support.attributes || !assert(function( el ) {
-	el.innerHTML = "<input/>";
-	el.firstChild.setAttribute( "value", "" );
-	return el.firstChild.getAttribute( "value" ) === "";
-}) ) {
-	addHandle( "value", function( elem, name, isXML ) {
-		if ( !isXML && elem.nodeName.toLowerCase() === "input" ) {
-			return elem.defaultValue;
-		}
-	});
-}
-
-// Support: IE<9
-// Use getAttributeNode to fetch booleans when getAttribute lies
-if ( !assert(function( el ) {
-	return el.getAttribute("disabled") == null;
-}) ) {
-	addHandle( booleans, function( elem, name, isXML ) {
-		var val;
-		if ( !isXML ) {
-			return elem[ name ] === true ? name.toLowerCase() :
-					(val = elem.getAttributeNode( name )) && val.specified ?
-					val.value :
-				null;
-		}
-	});
-}
-
-return Sizzle;
-
-})( window );
-
-
-
-jQuery.find = Sizzle;
-jQuery.expr = Sizzle.selectors;
-
-// Deprecated
-jQuery.expr[ ":" ] = jQuery.expr.pseudos;
-jQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort;
-jQuery.text = Sizzle.getText;
-jQuery.isXMLDoc = Sizzle.isXML;
-jQuery.contains = Sizzle.contains;
-jQuery.escapeSelector = Sizzle.escape;
-
-
-
-
-var dir = function( elem, dir, until ) {
-	var matched = [],
-		truncate = until !== undefined;
-
-	while ( ( elem = elem[ dir ] ) && elem.nodeType !== 9 ) {
-		if ( elem.nodeType === 1 ) {
-			if ( truncate && jQuery( elem ).is( until ) ) {
-				break;
-			}
-			matched.push( elem );
-		}
-	}
-	return matched;
-};
-
-
-var siblings = function( n, elem ) {
-	var matched = [];
-
-	for ( ; n; n = n.nextSibling ) {
-		if ( n.nodeType === 1 && n !== elem ) {
-			matched.push( n );
-		}
-	}
-
-	return matched;
-};
-
-
-var rneedsContext = jQuery.expr.match.needsContext;
-
-
-
-function nodeName( elem, name ) {
-
-  return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
-
-};
-var rsingleTag = ( /^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i );
-
-
-
-var risSimple = /^.[^:#\[\.,]*$/;
-
-// Implement the identical functionality for filter and not
-function winnow( elements, qualifier, not ) {
-	if ( jQuery.isFunction( qualifier ) ) {
-		return jQuery.grep( elements, function( elem, i ) {
-			return !!qualifier.call( elem, i, elem ) !== not;
-		} );
-	}
-
-	// Single element
-	if ( qualifier.nodeType ) {
-		return jQuery.grep( elements, function( elem ) {
-			return ( elem === qualifier ) !== not;
-		} );
-	}
-
-	// Arraylike of elements (jQuery, arguments, Array)
-	if ( typeof qualifier !== "string" ) {
-		return jQuery.grep( elements, function( elem ) {
-			return ( indexOf.call( qualifier, elem ) > -1 ) !== not;
-		} );
-	}
-
-	// Simple selector that can be filtered directly, removing non-Elements
-	if ( risSimple.test( qualifier ) ) {
-		return jQuery.filter( qualifier, elements, not );
-	}
-
-	// Complex selector, compare the two sets, removing non-Elements
-	qualifier = jQuery.filter( qualifier, elements );
-	return jQuery.grep( elements, function( elem ) {
-		return ( indexOf.call( qualifier, elem ) > -1 ) !== not && elem.nodeType === 1;
-	} );
-}
-
-jQuery.filter = function( expr, elems, not ) {
-	var elem = elems[ 0 ];
-
-	if ( not ) {
-		expr = ":not(" + expr + ")";
-	}
-
-	if ( elems.length === 1 && elem.nodeType === 1 ) {
-		return jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : [];
-	}
-
-	return jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) {
-		return elem.nodeType === 1;
-	} ) );
-};
-
-jQuery.fn.extend( {
-	find: function( selector ) {
-		var i, ret,
-			len = this.length,
-			self = this;
-
-		if ( typeof selector !== "string" ) {
-			return this.pushStack( jQuery( selector ).filter( function() {
-				for ( i = 0; i < len; i++ ) {
-					if ( jQuery.contains( self[ i ], this ) ) {
-						return true;
-					}
-				}
-			} ) );
-		}
-
-		ret = this.pushStack( [] );
-
-		for ( i = 0; i < len; i++ ) {
-			jQuery.find( selector, self[ i ], ret );
-		}
-
-		return len > 1 ? jQuery.uniqueSort( ret ) : ret;
-	},
-	filter: function( selector ) {
-		return this.pushStack( winnow( this, selector || [], false ) );
-	},
-	not: function( selector ) {
-		return this.pushStack( winnow( this, selector || [], true ) );
-	},
-	is: function( selector ) {
-		return !!winnow(
-			this,
-
-			// If this is a positional/relative selector, check membership in the returned set
-			// so $("p:first").is("p:last") won't return true for a doc with two "p".
-			typeof selector === "string" && rneedsContext.test( selector ) ?
-				jQuery( selector ) :
-				selector || [],
-			false
-		).length;
-	}
-} );
-
-
-// Initialize a jQuery object
-
-
-// A central reference to the root jQuery(document)
-var rootjQuery,
-
-	// A simple way to check for HTML strings
-	// Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
-	// Strict HTML recognition (#11290: must start with <)
-	// Shortcut simple #id case for speed
-	rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/,
-
-	init = jQuery.fn.init = function( selector, context, root ) {
-		var match, elem;
-
-		// HANDLE: $(""), $(null), $(undefined), $(false)
-		if ( !selector ) {
-			return this;
-		}
-
-		// Method init() accepts an alternate rootjQuery
-		// so migrate can support jQuery.sub (gh-2101)
-		root = root || rootjQuery;
-
-		// Handle HTML strings
-		if ( typeof selector === "string" ) {
-			if ( selector[ 0 ] === "<" &&
-				selector[ selector.length - 1 ] === ">" &&
-				selector.length >= 3 ) {
-
-				// Assume that strings that start and end with <> are HTML and skip the regex check
-				match = [ null, selector, null ];
-
-			} else {
-				match = rquickExpr.exec( selector );
-			}
-
-			// Match html or make sure no context is specified for #id
-			if ( match && ( match[ 1 ] || !context ) ) {
-
-				// HANDLE: $(html) -> $(array)
-				if ( match[ 1 ] ) {
-					context = context instanceof jQuery ? context[ 0 ] : context;
-
-					// Option to run scripts is true for back-compat
-					// Intentionally let the error be thrown if parseHTML is not present
-					jQuery.merge( this, jQuery.parseHTML(
-						match[ 1 ],
-						context && context.nodeType ? context.ownerDocument || context : document,
-						true
-					) );
-
-					// HANDLE: $(html, props)
-					if ( rsingleTag.test( match[ 1 ] ) && jQuery.isPlainObject( context ) ) {
-						for ( match in context ) {
-
-							// Properties of context are called as methods if possible
-							if ( jQuery.isFunction( this[ match ] ) ) {
-								this[ match ]( context[ match ] );
-
-							// ...and otherwise set as attributes
-							} else {
-								this.attr( match, context[ match ] );
-							}
-						}
-					}
-
-					return this;
-
-				// HANDLE: $(#id)
-				} else {
-					elem = document.getElementById( match[ 2 ] );
-
-					if ( elem ) {
-
-						// Inject the element directly into the jQuery object
-						this[ 0 ] = elem;
-						this.length = 1;
-					}
-					return this;
-				}
-
-			// HANDLE: $(expr, $(...))
-			} else if ( !context || context.jquery ) {
-				return ( context || root ).find( selector );
-
-			// HANDLE: $(expr, context)
-			// (which is just equivalent to: $(context).find(expr)
-			} else {
-				return this.constructor( context ).find( selector );
-			}
-
-		// HANDLE: $(DOMElement)
-		} else if ( selector.nodeType ) {
-			this[ 0 ] = selector;
-			this.length = 1;
-			return this;
-
-		// HANDLE: $(function)
-		// Shortcut for document ready
-		} else if ( jQuery.isFunction( selector ) ) {
-			return root.ready !== undefined ?
-				root.ready( selector ) :
-
-				// Execute immediately if ready is not present
-				selector( jQuery );
-		}
-
-		return jQuery.makeArray( selector, this );
-	};
-
-// Give the init function the jQuery prototype for later instantiation
-init.prototype = jQuery.fn;
-
-// Initialize central reference
-rootjQuery = jQuery( document );
-
-
-var rparentsprev = /^(?:parents|prev(?:Until|All))/,
-
-	// Methods guaranteed to produce a unique set when starting from a unique set
-	guaranteedUnique = {
-		children: true,
-		contents: true,
-		next: true,
-		prev: true
-	};
-
-jQuery.fn.extend( {
-	has: function( target ) {
-		var targets = jQuery( target, this ),
-			l = targets.length;
-
-		return this.filter( function() {
-			var i = 0;
-			for ( ; i < l; i++ ) {
-				if ( jQuery.contains( this, targets[ i ] ) ) {
-					return true;
-				}
-			}
-		} );
-	},
-
-	closest: function( selectors, context ) {
-		var cur,
-			i = 0,
-			l = this.length,
-			matched = [],
-			targets = typeof selectors !== "string" && jQuery( selectors );
-
-		// Positional selectors never match, since there's no _selection_ context
-		if ( !rneedsContext.test( selectors ) ) {
-			for ( ; i < l; i++ ) {
-				for ( cur = this[ i ]; cur && cur !== context; cur = cur.parentNode ) {
-
-					// Always skip document fragments
-					if ( cur.nodeType < 11 && ( targets ?
-						targets.index( cur ) > -1 :
-
-						// Don't pass non-elements to Sizzle
-						cur.nodeType === 1 &&
-							jQuery.find.matchesSelector( cur, selectors ) ) ) {
-
-						matched.push( cur );
-						break;
-					}
-				}
-			}
-		}
-
-		return this.pushStack( matched.length > 1 ? jQuery.uniqueSort( matched ) : matched );
-	},
-
-	// Determine the position of an element within the set
-	index: function( elem ) {
-
-		// No argument, return index in parent
-		if ( !elem ) {
-			return ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1;
-		}
-
-		// Index in selector
-		if ( typeof elem === "string" ) {
-			return indexOf.call( jQuery( elem ), this[ 0 ] );
-		}
-
-		// Locate the position of the desired element
-		return indexOf.call( this,
-
-			// If it receives a jQuery object, the first element is used
-			elem.jquery ? elem[ 0 ] : elem
-		);
-	},
-
-	add: function( selector, context ) {
-		return this.pushStack(
-			jQuery.uniqueSort(
-				jQuery.merge( this.get(), jQuery( selector, context ) )
-			)
-		);
-	},
-
-	addBack: function( selector ) {
-		return this.add( selector == null ?
-			this.prevObject : this.prevObject.filter( selector )
-		);
-	}
-} );
-
-function sibling( cur, dir ) {
-	while ( ( cur = cur[ dir ] ) && cur.nodeType !== 1 ) {}
-	return cur;
-}
-
-jQuery.each( {
-	parent: function( elem ) {
-		var parent = elem.parentNode;
-		return parent && parent.nodeType !== 11 ? parent : null;
-	},
-	parents: function( elem ) {
-		return dir( elem, "parentNode" );
-	},
-	parentsUntil: function( elem, i, until ) {
-		return dir( elem, "parentNode", until );
-	},
-	next: function( elem ) {
-		return sibling( elem, "nextSibling" );
-	},
-	prev: function( elem ) {
-		return sibling( elem, "previousSibling" );
-	},
-	nextAll: function( elem ) {
-		return dir( elem, "nextSibling" );
-	},
-	prevAll: function( elem ) {
-		return dir( elem, "previousSibling" );
-	},
-	nextUntil: function( elem, i, until ) {
-		return dir( elem, "nextSibling", until );
-	},
-	prevUntil: function( elem, i, until ) {
-		return dir( elem, "previousSibling", until );
-	},
-	siblings: function( elem ) {
-		return siblings( ( elem.parentNode || {} ).firstChild, elem );
-	},
-	children: function( elem ) {
-		return siblings( elem.firstChild );
-	},
-	contents: function( elem ) {
-        if ( nodeName( elem, "iframe" ) ) {
-            return elem.contentDocument;
-        }
-
-        // Support: IE 9 - 11 only, iOS 7 only, Android Browser <=4.3 only
-        // Treat the template element as a regular one in browsers that
-        // don't support it.
-        if ( nodeName( elem, "template" ) ) {
-            elem = elem.content || elem;
-        }
-
-        return jQuery.merge( [], elem.childNodes );
-	}
-}, function( name, fn ) {
-	jQuery.fn[ name ] = function( until, selector ) {
-		var matched = jQuery.map( this, fn, until );
-
-		if ( name.slice( -5 ) !== "Until" ) {
-			selector = until;
-		}
-
-		if ( selector && typeof selector === "string" ) {
-			matched = jQuery.filter( selector, matched );
-		}
-
-		if ( this.length > 1 ) {
-
-			// Remove duplicates
-			if ( !guaranteedUnique[ name ] ) {
-				jQuery.uniqueSort( matched );
-			}
-
-			// Reverse order for parents* and prev-derivatives
-			if ( rparentsprev.test( name ) ) {
-				matched.reverse();
-			}
-		}
-
-		return this.pushStack( matched );
-	};
-} );
-var rnothtmlwhite = ( /[^\x20\t\r\n\f]+/g );
-
-
-
-// Convert String-formatted options into Object-formatted ones
-function createOptions( options ) {
-	var object = {};
-	jQuery.each( options.match( rnothtmlwhite ) || [], function( _, flag ) {
-		object[ flag ] = true;
-	} );
-	return object;
-}
-
-/*
- * Create a callback list using the following parameters:
- *
- *	options: an optional list of space-separated options that will change how
- *			the callback list behaves or a more traditional option object
- *
- * By default a callback list will act like an event callback list and can be
- * "fired" multiple times.
- *
- * Possible options:
- *
- *	once:			will ensure the callback list can only be fired once (like a Deferred)
- *
- *	memory:			will keep track of previous values and will call any callback added
- *					after the list has been fired right away with the latest "memorized"
- *					values (like a Deferred)
- *
- *	unique:			will ensure a callback can only be added once (no duplicate in the list)
- *
- *	stopOnFalse:	interrupt callings when a callback returns false
- *
- */
-jQuery.Callbacks = function( options ) {
-
-	// Convert options from String-formatted to Object-formatted if needed
-	// (we check in cache first)
-	options = typeof options === "string" ?
-		createOptions( options ) :
-		jQuery.extend( {}, options );
-
-	var // Flag to know if list is currently firing
-		firing,
-
-		// Last fire value for non-forgettable lists
-		memory,
-
-		// Flag to know if list was already fired
-		fired,
-
-		// Flag to prevent firing
-		locked,
-
-		// Actual callback list
-		list = [],
-
-		// Queue of execution data for repeatable lists
-		queue = [],
-
-		// Index of currently firing callback (modified by add/remove as needed)
-		firingIndex = -1,
-
-		// Fire callbacks
-		fire = function() {
-
-			// Enforce single-firing
-			locked = locked || options.once;
-
-			// Execute callbacks for all pending executions,
-			// respecting firingIndex overrides and runtime changes
-			fired = firing = true;
-			for ( ; queue.length; firingIndex = -1 ) {
-				memory = queue.shift();
-				while ( ++firingIndex < list.length ) {
-
-					// Run callback and check for early termination
-					if ( list[ firingIndex ].apply( memory[ 0 ], memory[ 1 ] ) === false &&
-						options.stopOnFalse ) {
-
-						// Jump to end and forget the data so .add doesn't re-fire
-						firingIndex = list.length;
-						memory = false;
-					}
-				}
-			}
-
-			// Forget the data if we're done with it
-			if ( !options.memory ) {
-				memory = false;
-			}
-
-			firing = false;
-
-			// Clean up if we're done firing for good
-			if ( locked ) {
-
-				// Keep an empty list if we have data for future add calls
-				if ( memory ) {
-					list = [];
-
-				// Otherwise, this object is spent
-				} else {
-					list = "";
-				}
-			}
-		},
-
-		// Actual Callbacks object
-		self = {
-
-			// Add a callback or a collection of callbacks to the list
-			add: function() {
-				if ( list ) {
-
-					// If we have memory from a past run, we should fire after adding
-					if ( memory && !firing ) {
-						firingIndex = list.length - 1;
-						queue.push( memory );
-					}
-
-					( function add( args ) {
-						jQuery.each( args, function( _, arg ) {
-							if ( jQuery.isFunction( arg ) ) {
-								if ( !options.unique || !self.has( arg ) ) {
-									list.push( arg );
-								}
-							} else if ( arg && arg.length && jQuery.type( arg ) !== "string" ) {
-
-								// Inspect recursively
-								add( arg );
-							}
-						} );
-					} )( arguments );
-
-					if ( memory && !firing ) {
-						fire();
-					}
-				}
-				return this;
-			},
-
-			// Remove a callback from the list
-			remove: function() {
-				jQuery.each( arguments, function( _, arg ) {
-					var index;
-					while ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {
-						list.splice( index, 1 );
-
-						// Handle firing indexes
-						if ( index <= firingIndex ) {
-							firingIndex--;
-						}
-					}
-				} );
-				return this;
-			},
-
-			// Check if a given callback is in the list.
-			// If no argument is given, return whether or not list has callbacks attached.
-			has: function( fn ) {
-				return fn ?
-					jQuery.inArray( fn, list ) > -1 :
-					list.length > 0;
-			},
-
-			// Remove all callbacks from the list
-			empty: function() {
-				if ( list ) {
-					list = [];
-				}
-				return this;
-			},
-
-			// Disable .fire and .add
-			// Abort any current/pending executions
-			// Clear all callbacks and values
-			disable: function() {
-				locked = queue = [];
-				list = memory = "";
-				return this;
-			},
-			disabled: function() {
-				return !list;
-			},
-
-			// Disable .fire
-			// Also disable .add unless we have memory (since it would have no effect)
-			// Abort any pending executions
-			lock: function() {
-				locked = queue = [];
-				if ( !memory && !firing ) {
-					list = memory = "";
-				}
-				return this;
-			},
-			locked: function() {
-				return !!locked;
-			},
-
-			// Call all callbacks with the given context and arguments
-			fireWith: function( context, args ) {
-				if ( !locked ) {
-					args = args || [];
-					args = [ context, args.slice ? args.slice() : args ];
-					queue.push( args );
-					if ( !firing ) {
-						fire();
-					}
-				}
-				return this;
-			},
-
-			// Call all the callbacks with the given arguments
-			fire: function() {
-				self.fireWith( this, arguments );
-				return this;
-			},
-
-			// To know if the callbacks have already been called at least once
-			fired: function() {
-				return !!fired;
-			}
-		};
-
-	return self;
-};
-
-
-function Identity( v ) {
-	return v;
-}
-function Thrower( ex ) {
-	throw ex;
-}
-
-function adoptValue( value, resolve, reject, noValue ) {
-	var method;
-
-	try {
-
-		// Check for promise aspect first to privilege synchronous behavior
-		if ( value && jQuery.isFunction( ( method = value.promise ) ) ) {
-			method.call( value ).done( resolve ).fail( reject );
-
-		// Other thenables
-		} else if ( value && jQuery.isFunction( ( method = value.then ) ) ) {
-			method.call( value, resolve, reject );
-
-		// Other non-thenables
-		} else {
-
-			// Control `resolve` arguments by letting Array#slice cast boolean `noValue` to integer:
-			// * false: [ value ].slice( 0 ) => resolve( value )
-			// * true: [ value ].slice( 1 ) => resolve()
-			resolve.apply( undefined, [ value ].slice( noValue ) );
-		}
-
-	// For Promises/A+, convert exceptions into rejections
-	// Since jQuery.when doesn't unwrap thenables, we can skip the extra checks appearing in
-	// Deferred#then to conditionally suppress rejection.
-	} catch ( value ) {
-
-		// Support: Android 4.0 only
-		// Strict mode functions invoked without .call/.apply get global-object context
-		reject.apply( undefined, [ value ] );
-	}
-}
-
-jQuery.extend( {
-
-	Deferred: function( func ) {
-		var tuples = [
-
-				// action, add listener, callbacks,
-				// ... .then handlers, argument index, [final state]
-				[ "notify", "progress", jQuery.Callbacks( "memory" ),
-					jQuery.Callbacks( "memory" ), 2 ],
-				[ "resolve", "done", jQuery.Callbacks( "once memory" ),
-					jQuery.Callbacks( "once memory" ), 0, "resolved" ],
-				[ "reject", "fail", jQuery.Callbacks( "once memory" ),
-					jQuery.Callbacks( "once memory" ), 1, "rejected" ]
-			],
-			state = "pending",
-			promise = {
-				state: function() {
-					return state;
-				},
-				always: function() {
-					deferred.done( arguments ).fail( arguments );
-					return this;
-				},
-				"catch": function( fn ) {
-					return promise.then( null, fn );
-				},
-
-				// Keep pipe for back-compat
-				pipe: function( /* fnDone, fnFail, fnProgress */ ) {
-					var fns = arguments;
-
-					return jQuery.Deferred( function( newDefer ) {
-						jQuery.each( tuples, function( i, tuple ) {
-
-							// Map tuples (progress, done, fail) to arguments (done, fail, progress)
-							var fn = jQuery.isFunction( fns[ tuple[ 4 ] ] ) && fns[ tuple[ 4 ] ];
-
-							// deferred.progress(function() { bind to newDefer or newDefer.notify })
-							// deferred.done(function() { bind to newDefer or newDefer.resolve })
-							// deferred.fail(function() { bind to newDefer or newDefer.reject })
-							deferred[ tuple[ 1 ] ]( function() {
-								var returned = fn && fn.apply( this, arguments );
-								if ( returned && jQuery.isFunction( returned.promise ) ) {
-									returned.promise()
-										.progress( newDefer.notify )
-										.done( newDefer.resolve )
-										.fail( newDefer.reject );
-								} else {
-									newDefer[ tuple[ 0 ] + "With" ](
-										this,
-										fn ? [ returned ] : arguments
-									);
-								}
-							} );
-						} );
-						fns = null;
-					} ).promise();
-				},
-				then: function( onFulfilled, onRejected, onProgress ) {
-					var maxDepth = 0;
-					function resolve( depth, deferred, handler, special ) {
-						return function() {
-							var that = this,
-								args = arguments,
-								mightThrow = function() {
-									var returned, then;
-
-									// Support: Promises/A+ section 2.3.3.3.3
-									// https://promisesaplus.com/#point-59
-									// Ignore double-resolution attempts
-									if ( depth < maxDepth ) {
-										return;
-									}
-
-									returned = handler.apply( that, args );
-
-									// Support: Promises/A+ section 2.3.1
-									// https://promisesaplus.com/#point-48
-									if ( returned === deferred.promise() ) {
-										throw new TypeError( "Thenable self-resolution" );
-									}
-
-									// Support: Promises/A+ sections 2.3.3.1, 3.5
-									// https://promisesaplus.com/#point-54
-									// https://promisesaplus.com/#point-75
-									// Retrieve `then` only once
-									then = returned &&
-
-										// Support: Promises/A+ section 2.3.4
-										// https://promisesaplus.com/#point-64
-										// Only check objects and functions for thenability
-										( typeof returned === "object" ||
-											typeof returned === "function" ) &&
-										returned.then;
-
-									// Handle a returned thenable
-									if ( jQuery.isFunction( then ) ) {
-
-										// Special processors (notify) just wait for resolution
-										if ( special ) {
-											then.call(
-												returned,
-												resolve( maxDepth, deferred, Identity, special ),
-												resolve( maxDepth, deferred, Thrower, special )
-											);
-
-										// Normal processors (resolve) also hook into progress
-										} else {
-
-											// ...and disregard older resolution values
-											maxDepth++;
-
-											then.call(
-												returned,
-												resolve( maxDepth, deferred, Identity, special ),
-												resolve( maxDepth, deferred, Thrower, special ),
-												resolve( maxDepth, deferred, Identity,
-													deferred.notifyWith )
-											);
-										}
-
-									// Handle all other returned values
-									} else {
-
-										// Only substitute handlers pass on context
-										// and multiple values (non-spec behavior)
-										if ( handler !== Identity ) {
-											that = undefined;
-											args = [ returned ];
-										}
-
-										// Process the value(s)
-										// Default process is resolve
-										( special || deferred.resolveWith )( that, args );
-									}
-								},
-
-								// Only normal processors (resolve) catch and reject exceptions
-								process = special ?
-									mightThrow :
-									function() {
-										try {
-											mightThrow();
-										} catch ( e ) {
-
-											if ( jQuery.Deferred.exceptionHook ) {
-												jQuery.Deferred.exceptionHook( e,
-													process.stackTrace );
-											}
-
-											// Support: Promises/A+ section 2.3.3.3.4.1
-											// https://promisesaplus.com/#point-61
-											// Ignore post-resolution exceptions
-											if ( depth + 1 >= maxDepth ) {
-
-												// Only substitute handlers pass on context
-												// and multiple values (non-spec behavior)
-												if ( handler !== Thrower ) {
-													that = undefined;
-													args = [ e ];
-												}
-
-												deferred.rejectWith( that, args );
-											}
-										}
-									};
-
-							// Support: Promises/A+ section 2.3.3.3.1
-							// https://promisesaplus.com/#point-57
-							// Re-resolve promises immediately to dodge false rejection from
-							// subsequent errors
-							if ( depth ) {
-								process();
-							} else {
-
-								// Call an optional hook to record the stack, in case of exception
-								// since it's otherwise lost when execution goes async
-								if ( jQuery.Deferred.getStackHook ) {
-									process.stackTrace = jQuery.Deferred.getStackHook();
-								}
-								window.setTimeout( process );
-							}
-						};
-					}
-
-					return jQuery.Deferred( function( newDefer ) {
-
-						// progress_handlers.add( ... )
-						tuples[ 0 ][ 3 ].add(
-							resolve(
-								0,
-								newDefer,
-								jQuery.isFunction( onProgress ) ?
-									onProgress :
-									Identity,
-								newDefer.notifyWith
-							)
-						);
-
-						// fulfilled_handlers.add( ... )
-						tuples[ 1 ][ 3 ].add(
-							resolve(
-								0,
-								newDefer,
-								jQuery.isFunction( onFulfilled ) ?
-									onFulfilled :
-									Identity
-							)
-						);
-
-						// rejected_handlers.add( ... )
-						tuples[ 2 ][ 3 ].add(
-							resolve(
-								0,
-								newDefer,
-								jQuery.isFunction( onRejected ) ?
-									onRejected :
-									Thrower
-							)
-						);
-					} ).promise();
-				},
-
-				// Get a promise for this deferred
-				// If obj is provided, the promise aspect is added to the object
-				promise: function( obj ) {
-					return obj != null ? jQuery.extend( obj, promise ) : promise;
-				}
-			},
-			deferred = {};
-
-		// Add list-specific methods
-		jQuery.each( tuples, function( i, tuple ) {
-			var list = tuple[ 2 ],
-				stateString = tuple[ 5 ];
-
-			// promise.progress = list.add
-			// promise.done = list.add
-			// promise.fail = list.add
-			promise[ tuple[ 1 ] ] = list.add;
-
-			// Handle state
-			if ( stateString ) {
-				list.add(
-					function() {
-
-						// state = "resolved" (i.e., fulfilled)
-						// state = "rejected"
-						state = stateString;
-					},
-
-					// rejected_callbacks.disable
-					// fulfilled_callbacks.disable
-					tuples[ 3 - i ][ 2 ].disable,
-
-					// progress_callbacks.lock
-					tuples[ 0 ][ 2 ].lock
-				);
-			}
-
-			// progress_handlers.fire
-			// fulfilled_handlers.fire
-			// rejected_handlers.fire
-			list.add( tuple[ 3 ].fire );
-
-			// deferred.notify = function() { deferred.notifyWith(...) }
-			// deferred.resolve = function() { deferred.resolveWith(...) }
-			// deferred.reject = function() { deferred.rejectWith(...) }
-			deferred[ tuple[ 0 ] ] = function() {
-				deferred[ tuple[ 0 ] + "With" ]( this === deferred ? undefined : this, arguments );
-				return this;
-			};
-
-			// deferred.notifyWith = list.fireWith
-			// deferred.resolveWith = list.fireWith
-			// deferred.rejectWith = list.fireWith
-			deferred[ tuple[ 0 ] + "With" ] = list.fireWith;
-		} );
-
-		// Make the deferred a promise
-		promise.promise( deferred );
-
-		// Call given func if any
-		if ( func ) {
-			func.call( deferred, deferred );
-		}
-
-		// All done!
-		return deferred;
-	},
-
-	// Deferred helper
-	when: function( singleValue ) {
-		var
-
-			// count of uncompleted subordinates
-			remaining = arguments.length,
-
-			// count of unprocessed arguments
-			i = remaining,
-
-			// subordinate fulfillment data
-			resolveContexts = Array( i ),
-			resolveValues = slice.call( arguments ),
-
-			// the master Deferred
-			master = jQuery.Deferred(),
-
-			// subordinate callback factory
-			updateFunc = function( i ) {
-				return function( value ) {
-					resolveContexts[ i ] = this;
-					resolveValues[ i ] = arguments.length > 1 ? slice.call( arguments ) : value;
-					if ( !( --remaining ) ) {
-						master.resolveWith( resolveContexts, resolveValues );
-					}
-				};
-			};
-
-		// Single- and empty arguments are adopted like Promise.resolve
-		if ( remaining <= 1 ) {
-			adoptValue( singleValue, master.done( updateFunc( i ) ).resolve, master.reject,
-				!remaining );
-
-			// Use .then() to unwrap secondary thenables (cf. gh-3000)
-			if ( master.state() === "pending" ||
-				jQuery.isFunction( resolveValues[ i ] && resolveValues[ i ].then ) ) {
-
-				return master.then();
-			}
-		}
-
-		// Multiple arguments are aggregated like Promise.all array elements
-		while ( i-- ) {
-			adoptValue( resolveValues[ i ], updateFunc( i ), master.reject );
-		}
-
-		return master.promise();
-	}
-} );
-
-
-// These usually indicate a programmer mistake during development,
-// warn about them ASAP rather than swallowing them by default.
-var rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;
-
-jQuery.Deferred.exceptionHook = function( error, stack ) {
-
-	// Support: IE 8 - 9 only
-	// Console exists when dev tools are open, which can happen at any time
-	if ( window.console && window.console.warn && error && rerrorNames.test( error.name ) ) {
-		window.console.warn( "jQuery.Deferred exception: " + error.message, error.stack, stack );
-	}
-};
-
-
-
-
-jQuery.readyException = function( error ) {
-	window.setTimeout( function() {
-		throw error;
-	} );
-};
-
-
-
-
-// The deferred used on DOM ready
-var readyList = jQuery.Deferred();
-
-jQuery.fn.ready = function( fn ) {
-
-	readyList
-		.then( fn )
-
-		// Wrap jQuery.readyException in a function so that the lookup
-		// happens at the time of error handling instead of callback
-		// registration.
-		.catch( function( error ) {
-			jQuery.readyException( error );
-		} );
-
-	return this;
-};
-
-jQuery.extend( {
-
-	// Is the DOM ready to be used? Set to true once it occurs.
-	isReady: false,
-
-	// A counter to track how many items to wait for before
-	// the ready event fires. See #6781
-	readyWait: 1,
-
-	// Handle when the DOM is ready
-	ready: function( wait ) {
-
-		// Abort if there are pending holds or we're already ready
-		if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {
-			return;
-		}
-
-		// Remember that the DOM is ready
-		jQuery.isReady = true;
-
-		// If a normal DOM Ready event fired, decrement, and wait if need be
-		if ( wait !== true && --jQuery.readyWait > 0 ) {
-			return;
-		}
-
-		// If there are functions bound, to execute
-		readyList.resolveWith( document, [ jQuery ] );
-	}
-} );
-
-jQuery.ready.then = readyList.then;
-
-// The ready event handler and self cleanup method
-function completed() {
-	document.removeEventListener( "DOMContentLoaded", completed );
-	window.removeEventListener( "load", completed );
-	jQuery.ready();
-}
-
-// Catch cases where $(document).ready() is called
-// after the browser event has already occurred.
-// Support: IE <=9 - 10 only
-// Older IE sometimes signals "interactive" too soon
-if ( document.readyState === "complete" ||
-	( document.readyState !== "loading" && !document.documentElement.doScroll ) ) {
-
-	// Handle it asynchronously to allow scripts the opportunity to delay ready
-	window.setTimeout( jQuery.ready );
-
-} else {
-
-	// Use the handy event callback
-	document.addEventListener( "DOMContentLoaded", completed );
-
-	// A fallback to window.onload, that will always work
-	window.addEventListener( "load", completed );
-}
-
-
-
-
-// Multifunctional method to get and set values of a collection
-// The value/s can optionally be executed if it's a function
-var access = function( elems, fn, key, value, chainable, emptyGet, raw ) {
-	var i = 0,
-		len = elems.length,
-		bulk = key == null;
-
-	// Sets many values
-	if ( jQuery.type( key ) === "object" ) {
-		chainable = true;
-		for ( i in key ) {
-			access( elems, fn, i, key[ i ], true, emptyGet, raw );
-		}
-
-	// Sets one value
-	} else if ( value !== undefined ) {
-		chainable = true;
-
-		if ( !jQuery.isFunction( value ) ) {
-			raw = true;
-		}
-
-		if ( bulk ) {
-
-			// Bulk operations run against the entire set
-			if ( raw ) {
-				fn.call( elems, value );
-				fn = null;
-
-			// ...except when executing function values
-			} else {
-				bulk = fn;
-				fn = function( elem, key, value ) {
-					return bulk.call( jQuery( elem ), value );
-				};
-			}
-		}
-
-		if ( fn ) {
-			for ( ; i < len; i++ ) {
-				fn(
-					elems[ i ], key, raw ?
-					value :
-					value.call( elems[ i ], i, fn( elems[ i ], key ) )
-				);
-			}
-		}
-	}
-
-	if ( chainable ) {
-		return elems;
-	}
-
-	// Gets
-	if ( bulk ) {
-		return fn.call( elems );
-	}
-
-	return len ? fn( elems[ 0 ], key ) : emptyGet;
-};
-var acceptData = function( owner ) {
-
-	// Accepts only:
-	//  - Node
-	//    - Node.ELEMENT_NODE
-	//    - Node.DOCUMENT_NODE
-	//  - Object
-	//    - Any
-	return owner.nodeType === 1 || owner.nodeType === 9 || !( +owner.nodeType );
-};
-
-
-
-
-function Data() {
-	this.expando = jQuery.expando + Data.uid++;
-}
-
-Data.uid = 1;
-
-Data.prototype = {
-
-	cache: function( owner ) {
-
-		// Check if the owner object already has a cache
-		var value = owner[ this.expando ];
-
-		// If not, create one
-		if ( !value ) {
-			value = {};
-
-			// We can accept data for non-element nodes in modern browsers,
-			// but we should not, see #8335.
-			// Always return an empty object.
-			if ( acceptData( owner ) ) {
-
-				// If it is a node unlikely to be stringify-ed or looped over
-				// use plain assignment
-				if ( owner.nodeType ) {
-					owner[ this.expando ] = value;
-
-				// Otherwise secure it in a non-enumerable property
-				// configurable must be true to allow the property to be
-				// deleted when data is removed
-				} else {
-					Object.defineProperty( owner, this.expando, {
-						value: value,
-						configurable: true
-					} );
-				}
-			}
-		}
-
-		return value;
-	},
-	set: function( owner, data, value ) {
-		var prop,
-			cache = this.cache( owner );
-
-		// Handle: [ owner, key, value ] args
-		// Always use camelCase key (gh-2257)
-		if ( typeof data === "string" ) {
-			cache[ jQuery.camelCase( data ) ] = value;
-
-		// Handle: [ owner, { properties } ] args
-		} else {
-
-			// Copy the properties one-by-one to the cache object
-			for ( prop in data ) {
-				cache[ jQuery.camelCase( prop ) ] = data[ prop ];
-			}
-		}
-		return cache;
-	},
-	get: function( owner, key ) {
-		return key === undefined ?
-			this.cache( owner ) :
-
-			// Always use camelCase key (gh-2257)
-			owner[ this.expando ] && owner[ this.expando ][ jQuery.camelCase( key ) ];
-	},
-	access: function( owner, key, value ) {
-
-		// In cases where either:
-		//
-		//   1. No key was specified
-		//   2. A string key was specified, but no value provided
-		//
-		// Take the "read" path and allow the get method to determine
-		// which value to return, respectively either:
-		//
-		//   1. The entire cache object
-		//   2. The data stored at the key
-		//
-		if ( key === undefined ||
-				( ( key && typeof key === "string" ) && value === undefined ) ) {
-
-			return this.get( owner, key );
-		}
-
-		// When the key is not a string, or both a key and value
-		// are specified, set or extend (existing objects) with either:
-		//
-		//   1. An object of properties
-		//   2. A key and value
-		//
-		this.set( owner, key, value );
-
-		// Since the "set" path can have two possible entry points
-		// return the expected data based on which path was taken[*]
-		return value !== undefined ? value : key;
-	},
-	remove: function( owner, key ) {
-		var i,
-			cache = owner[ this.expando ];
-
-		if ( cache === undefined ) {
-			return;
-		}
-
-		if ( key !== undefined ) {
-
-			// Support array or space separated string of keys
-			if ( Array.isArray( key ) ) {
-
-				// If key is an array of keys...
-				// We always set camelCase keys, so remove that.
-				key = key.map( jQuery.camelCase );
-			} else {
-				key = jQuery.camelCase( key );
-
-				// If a key with the spaces exists, use it.
-				// Otherwise, create an array by matching non-whitespace
-				key = key in cache ?
-					[ key ] :
-					( key.match( rnothtmlwhite ) || [] );
-			}
-
-			i = key.length;
-
-			while ( i-- ) {
-				delete cache[ key[ i ] ];
-			}
-		}
-
-		// Remove the expando if there's no more data
-		if ( key === undefined || jQuery.isEmptyObject( cache ) ) {
-
-			// Support: Chrome <=35 - 45
-			// Webkit & Blink performance suffers when deleting properties
-			// from DOM nodes, so set to undefined instead
-			// https://bugs.chromium.org/p/chromium/issues/detail?id=378607 (bug restricted)
-			if ( owner.nodeType ) {
-				owner[ this.expando ] = undefined;
-			} else {
-				delete owner[ this.expando ];
-			}
-		}
-	},
-	hasData: function( owner ) {
-		var cache = owner[ this.expando ];
-		return cache !== undefined && !jQuery.isEmptyObject( cache );
-	}
-};
-var dataPriv = new Data();
-
-var dataUser = new Data();
-
-
-
-//	Implementation Summary
-//
-//	1. Enforce API surface and semantic compatibility with 1.9.x branch
-//	2. Improve the module's maintainability by reducing the storage
-//		paths to a single mechanism.
-//	3. Use the same single mechanism to support "private" and "user" data.
-//	4. _Never_ expose "private" data to user code (TODO: Drop _data, _removeData)
-//	5. Avoid exposing implementation details on user objects (eg. expando properties)
-//	6. Provide a clear path for implementation upgrade to WeakMap in 2014
-
-var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,
-	rmultiDash = /[A-Z]/g;
-
-function getData( data ) {
-	if ( data === "true" ) {
-		return true;
-	}
-
-	if ( data === "false" ) {
-		return false;
-	}
-
-	if ( data === "null" ) {
-		return null;
-	}
-
-	// Only convert to a number if it doesn't change the string
-	if ( data === +data + "" ) {
-		return +data;
-	}
-
-	if ( rbrace.test( data ) ) {
-		return JSON.parse( data );
-	}
-
-	return data;
-}
-
-function dataAttr( elem, key, data ) {
-	var name;
-
-	// If nothing was found internally, try to fetch any
-	// data from the HTML5 data-* attribute
-	if ( data === undefined && elem.nodeType === 1 ) {
-		name = "data-" + key.replace( rmultiDash, "-$&" ).toLowerCase();
-		data = elem.getAttribute( name );
-
-		if ( typeof data === "string" ) {
-			try {
-				data = getData( data );
-			} catch ( e ) {}
-
-			// Make sure we set the data so it isn't changed later
-			dataUser.set( elem, key, data );
-		} else {
-			data = undefined;
-		}
-	}
-	return data;
-}
-
-jQuery.extend( {
-	hasData: function( elem ) {
-		return dataUser.hasData( elem ) || dataPriv.hasData( elem );
-	},
-
-	data: function( elem, name, data ) {
-		return dataUser.access( elem, name, data );
-	},
-
-	removeData: function( elem, name ) {
-		dataUser.remove( elem, name );
-	},
-
-	// TODO: Now that all calls to _data and _removeData have been replaced
-	// with direct calls to dataPriv methods, these can be deprecated.
-	_data: function( elem, name, data ) {
-		return dataPriv.access( elem, name, data );
-	},
-
-	_removeData: function( elem, name ) {
-		dataPriv.remove( elem, name );
-	}
-} );
-
-jQuery.fn.extend( {
-	data: function( key, value ) {
-		var i, name, data,
-			elem = this[ 0 ],
-			attrs = elem && elem.attributes;
-
-		// Gets all values
-		if ( key === undefined ) {
-			if ( this.length ) {
-				data = dataUser.get( elem );
-
-				if ( elem.nodeType === 1 && !dataPriv.get( elem, "hasDataAttrs" ) ) {
-					i = attrs.length;
-					while ( i-- ) {
-
-						// Support: IE 11 only
-						// The attrs elements can be null (#14894)
-						if ( attrs[ i ] ) {
-							name = attrs[ i ].name;
-							if ( name.indexOf( "data-" ) === 0 ) {
-								name = jQuery.camelCase( name.slice( 5 ) );
-								dataAttr( elem, name, data[ name ] );
-							}
-						}
-					}
-					dataPriv.set( elem, "hasDataAttrs", true );
-				}
-			}
-
-			return data;
-		}
-
-		// Sets multiple values
-		if ( typeof key === "object" ) {
-			return this.each( function() {
-				dataUser.set( this, key );
-			} );
-		}
-
-		return access( this, function( value ) {
-			var data;
-
-			// The calling jQuery object (element matches) is not empty
-			// (and therefore has an element appears at this[ 0 ]) and the
-			// `value` parameter was not undefined. An empty jQuery object
-			// will result in `undefined` for elem = this[ 0 ] which will
-			// throw an exception if an attempt to read a data cache is made.
-			if ( elem && value === undefined ) {
-
-				// Attempt to get data from the cache
-				// The key will always be camelCased in Data
-				data = dataUser.get( elem, key );
-				if ( data !== undefined ) {
-					return data;
-				}
-
-				// Attempt to "discover" the data in
-				// HTML5 custom data-* attrs
-				data = dataAttr( elem, key );
-				if ( data !== undefined ) {
-					return data;
-				}
-
-				// We tried really hard, but the data doesn't exist.
-				return;
-			}
-
-			// Set the data...
-			this.each( function() {
-
-				// We always store the camelCased key
-				dataUser.set( this, key, value );
-			} );
-		}, null, value, arguments.length > 1, null, true );
-	},
-
-	removeData: function( key ) {
-		return this.each( function() {
-			dataUser.remove( this, key );
-		} );
-	}
-} );
-
-
-jQuery.extend( {
-	queue: function( elem, type, data ) {
-		var queue;
-
-		if ( elem ) {
-			type = ( type || "fx" ) + "queue";
-			queue = dataPriv.get( elem, type );
-
-			// Speed up dequeue by getting out quickly if this is just a lookup
-			if ( data ) {
-				if ( !queue || Array.isArray( data ) ) {
-					queue = dataPriv.access( elem, type, jQuery.makeArray( data ) );
-				} else {
-					queue.push( data );
-				}
-			}
-			return queue || [];
-		}
-	},
-
-	dequeue: function( elem, type ) {
-		type = type || "fx";
-
-		var queue = jQuery.queue( elem, type ),
-			startLength = queue.length,
-			fn = queue.shift(),
-			hooks = jQuery._queueHooks( elem, type ),
-			next = function() {
-				jQuery.dequeue( elem, type );
-			};
-
-		// If the fx queue is dequeued, always remove the progress sentinel
-		if ( fn === "inprogress" ) {
-			fn = queue.shift();
-			startLength--;
-		}
-
-		if ( fn ) {
-
-			// Add a progress sentinel to prevent the fx queue from being
-			// automatically dequeued
-			if ( type === "fx" ) {
-				queue.unshift( "inprogress" );
-			}
-
-			// Clear up the last queue stop function
-			delete hooks.stop;
-			fn.call( elem, next, hooks );
-		}
-
-		if ( !startLength && hooks ) {
-			hooks.empty.fire();
-		}
-	},
-
-	// Not public - generate a queueHooks object, or return the current one
-	_queueHooks: function( elem, type ) {
-		var key = type + "queueHooks";
-		return dataPriv.get( elem, key ) || dataPriv.access( elem, key, {
-			empty: jQuery.Callbacks( "once memory" ).add( function() {
-				dataPriv.remove( elem, [ type + "queue", key ] );
-			} )
-		} );
-	}
-} );
-
-jQuery.fn.extend( {
-	queue: function( type, data ) {
-		var setter = 2;
-
-		if ( typeof type !== "string" ) {
-			data = type;
-			type = "fx";
-			setter--;
-		}
-
-		if ( arguments.length < setter ) {
-			return jQuery.queue( this[ 0 ], type );
-		}
-
-		return data === undefined ?
-			this :
-			this.each( function() {
-				var queue = jQuery.queue( this, type, data );
-
-				// Ensure a hooks for this queue
-				jQuery._queueHooks( this, type );
-
-				if ( type === "fx" && queue[ 0 ] !== "inprogress" ) {
-					jQuery.dequeue( this, type );
-				}
-			} );
-	},
-	dequeue: function( type ) {
-		return this.each( function() {
-			jQuery.dequeue( this, type );
-		} );
-	},
-	clearQueue: function( type ) {
-		return this.queue( type || "fx", [] );
-	},
-
-	// Get a promise resolved when queues of a certain type
-	// are emptied (fx is the type by default)
-	promise: function( type, obj ) {
-		var tmp,
-			count = 1,
-			defer = jQuery.Deferred(),
-			elements = this,
-			i = this.length,
-			resolve = function() {
-				if ( !( --count ) ) {
-					defer.resolveWith( elements, [ elements ] );
-				}
-			};
-
-		if ( typeof type !== "string" ) {
-			obj = type;
-			type = undefined;
-		}
-		type = type || "fx";
-
-		while ( i-- ) {
-			tmp = dataPriv.get( elements[ i ], type + "queueHooks" );
-			if ( tmp && tmp.empty ) {
-				count++;
-				tmp.empty.add( resolve );
-			}
-		}
-		resolve();
-		return defer.promise( obj );
-	}
-} );
-var pnum = ( /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/ ).source;
-
-var rcssNum = new RegExp( "^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i" );
-
-
-var cssExpand = [ "Top", "Right", "Bottom", "Left" ];
-
-var isHiddenWithinTree = function( elem, el ) {
-
-		// isHiddenWithinTree might be called from jQuery#filter function;
-		// in that case, element will be second argument
-		elem = el || elem;
-
-		// Inline style trumps all
-		return elem.style.display === "none" ||
-			elem.style.display === "" &&
-
-			// Otherwise, check computed style
-			// Support: Firefox <=43 - 45
-			// Disconnected elements can have computed display: none, so first confirm that elem is
-			// in the document.
-			jQuery.contains( elem.ownerDocument, elem ) &&
-
-			jQuery.css( elem, "display" ) === "none";
-	};
-
-var swap = function( elem, options, callback, args ) {
-	var ret, name,
-		old = {};
-
-	// Remember the old values, and insert the new ones
-	for ( name in options ) {
-		old[ name ] = elem.style[ name ];
-		elem.style[ name ] = options[ name ];
-	}
-
-	ret = callback.apply( elem, args || [] );
-
-	// Revert the old values
-	for ( name in options ) {
-		elem.style[ name ] = old[ name ];
-	}
-
-	return ret;
-};
-
-
-
-
-function adjustCSS( elem, prop, valueParts, tween ) {
-	var adjusted,
-		scale = 1,
-		maxIterations = 20,
-		currentValue = tween ?
-			function() {
-				return tween.cur();
-			} :
-			function() {
-				return jQuery.css( elem, prop, "" );
-			},
-		initial = currentValue(),
-		unit = valueParts && valueParts[ 3 ] || ( jQuery.cssNumber[ prop ] ? "" : "px" ),
-
-		// Starting value computation is required for potential unit mismatches
-		initialInUnit = ( jQuery.cssNumber[ prop ] || unit !== "px" && +initial ) &&
-			rcssNum.exec( jQuery.css( elem, prop ) );
-
-	if ( initialInUnit && initialInUnit[ 3 ] !== unit ) {
-
-		// Trust units reported by jQuery.css
-		unit = unit || initialInUnit[ 3 ];
-
-		// Make sure we update the tween properties later on
-		valueParts = valueParts || [];
-
-		// Iteratively approximate from a nonzero starting point
-		initialInUnit = +initial || 1;
-
-		do {
-
-			// If previous iteration zeroed out, double until we get *something*.
-			// Use string for doubling so we don't accidentally see scale as unchanged below
-			scale = scale || ".5";
-
-			// Adjust and apply
-			initialInUnit = initialInUnit / scale;
-			jQuery.style( elem, prop, initialInUnit + unit );
-
-		// Update scale, tolerating zero or NaN from tween.cur()
-		// Break the loop if scale is unchanged or perfect, or if we've just had enough.
-		} while (
-			scale !== ( scale = currentValue() / initial ) && scale !== 1 && --maxIterations
-		);
-	}
-
-	if ( valueParts ) {
-		initialInUnit = +initialInUnit || +initial || 0;
-
-		// Apply relative offset (+=/-=) if specified
-		adjusted = valueParts[ 1 ] ?
-			initialInUnit + ( valueParts[ 1 ] + 1 ) * valueParts[ 2 ] :
-			+valueParts[ 2 ];
-		if ( tween ) {
-			tween.unit = unit;
-			tween.start = initialInUnit;
-			tween.end = adjusted;
-		}
-	}
-	return adjusted;
-}
-
-
-var defaultDisplayMap = {};
-
-function getDefaultDisplay( elem ) {
-	var temp,
-		doc = elem.ownerDocument,
-		nodeName = elem.nodeName,
-		display = defaultDisplayMap[ nodeName ];
-
-	if ( display ) {
-		return display;
-	}
-
-	temp = doc.body.appendChild( doc.createElement( nodeName ) );
-	display = jQuery.css( temp, "display" );
-
-	temp.parentNode.removeChild( temp );
-
-	if ( display === "none" ) {
-		display = "block";
-	}
-	defaultDisplayMap[ nodeName ] = display;
-
-	return display;
-}
-
-function showHide( elements, show ) {
-	var display, elem,
-		values = [],
-		index = 0,
-		length = elements.length;
-
-	// Determine new display value for elements that need to change
-	for ( ; index < length; index++ ) {
-		elem = elements[ index ];
-		if ( !elem.style ) {
-			continue;
-		}
-
-		display = elem.style.display;
-		if ( show ) {
-
-			// Since we force visibility upon cascade-hidden elements, an immediate (and slow)
-			// check is required in this first loop unless we have a nonempty display value (either
-			// inline or about-to-be-restored)
-			if ( display === "none" ) {
-				values[ index ] = dataPriv.get( elem, "display" ) || null;
-				if ( !values[ index ] ) {
-					elem.style.display = "";
-				}
-			}
-			if ( elem.style.display === "" && isHiddenWithinTree( elem ) ) {
-				values[ index ] = getDefaultDisplay( elem );
-			}
-		} else {
-			if ( display !== "none" ) {
-				values[ index ] = "none";
-
-				// Remember what we're overwriting
-				dataPriv.set( elem, "display", display );
-			}
-		}
-	}
-
-	// Set the display of the elements in a second loop to avoid constant reflow
-	for ( index = 0; index < length; index++ ) {
-		if ( values[ index ] != null ) {
-			elements[ index ].style.display = values[ index ];
-		}
-	}
-
-	return elements;
-}
-
-jQuery.fn.extend( {
-	show: function() {
-		return showHide( this, true );
-	},
-	hide: function() {
-		return showHide( this );
-	},
-	toggle: function( state ) {
-		if ( typeof state === "boolean" ) {
-			return state ? this.show() : this.hide();
-		}
-
-		return this.each( function() {
-			if ( isHiddenWithinTree( this ) ) {
-				jQuery( this ).show();
-			} else {
-				jQuery( this ).hide();
-			}
-		} );
-	}
-} );
-var rcheckableType = ( /^(?:checkbox|radio)$/i );
-
-var rtagName = ( /<([a-z][^\/\0>\x20\t\r\n\f]+)/i );
-
-var rscriptType = ( /^$|\/(?:java|ecma)script/i );
-
-
-
-// We have to close these tags to support XHTML (#13200)
-var wrapMap = {
-
-	// Support: IE <=9 only
-	option: [ 1, "<select multiple='multiple'>", "</select>" ],
-
-	// XHTML parsers do not magically insert elements in the
-	// same way that tag soup parsers do. So we cannot shorten
-	// this by omitting <tbody> or other required elements.
-	thead: [ 1, "<table>", "</table>" ],
-	col: [ 2, "<table><colgroup>", "</colgroup></table>" ],
-	tr: [ 2, "<table><tbody>", "</tbody></table>" ],
-	td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
-
-	_default: [ 0, "", "" ]
-};
-
-// Support: IE <=9 only
-wrapMap.optgroup = wrapMap.option;
-
-wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
-wrapMap.th = wrapMap.td;
-
-
-function getAll( context, tag ) {
-
-	// Support: IE <=9 - 11 only
-	// Use typeof to avoid zero-argument method invocation on host objects (#15151)
-	var ret;
-
-	if ( typeof context.getElementsByTagName !== "undefined" ) {
-		ret = context.getElementsByTagName( tag || "*" );
-
-	} else if ( typeof context.querySelectorAll !== "undefined" ) {
-		ret = context.querySelectorAll( tag || "*" );
-
-	} else {
-		ret = [];
-	}
-
-	if ( tag === undefined || tag && nodeName( context, tag ) ) {
-		return jQuery.merge( [ context ], ret );
-	}
-
-	return ret;
-}
-
-
-// Mark scripts as having already been evaluated
-function setGlobalEval( elems, refElements ) {
-	var i = 0,
-		l = elems.length;
-
-	for ( ; i < l; i++ ) {
-		dataPriv.set(
-			elems[ i ],
-			"globalEval",
-			!refElements || dataPriv.get( refElements[ i ], "globalEval" )
-		);
-	}
-}
-
-
-var rhtml = /<|&#?\w+;/;
-
-function buildFragment( elems, context, scripts, selection, ignored ) {
-	var elem, tmp, tag, wrap, contains, j,
-		fragment = context.createDocumentFragment(),
-		nodes = [],
-		i = 0,
-		l = elems.length;
-
-	for ( ; i < l; i++ ) {
-		elem = elems[ i ];
-
-		if ( elem || elem === 0 ) {
-
-			// Add nodes directly
-			if ( jQuery.type( elem ) === "object" ) {
-
-				// Support: Android <=4.0 only, PhantomJS 1 only
-				// push.apply(_, arraylike) throws on ancient WebKit
-				jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem );
-
-			// Convert non-html into a text node
-			} else if ( !rhtml.test( elem ) ) {
-				nodes.push( context.createTextNode( elem ) );
-
-			// Convert html into DOM nodes
-			} else {
-				tmp = tmp || fragment.appendChild( context.createElement( "div" ) );
-
-				// Deserialize a standard representation
-				tag = ( rtagName.exec( elem ) || [ "", "" ] )[ 1 ].toLowerCase();
-				wrap = wrapMap[ tag ] || wrapMap._default;
-				tmp.innerHTML = wrap[ 1 ] + jQuery.htmlPrefilter( elem ) + wrap[ 2 ];
-
-				// Descend through wrappers to the right content
-				j = wrap[ 0 ];
-				while ( j-- ) {
-					tmp = tmp.lastChild;
-				}
-
-				// Support: Android <=4.0 only, PhantomJS 1 only
-				// push.apply(_, arraylike) throws on ancient WebKit
-				jQuery.merge( nodes, tmp.childNodes );
-
-				// Remember the top-level container
-				tmp = fragment.firstChild;
-
-				// Ensure the created nodes are orphaned (#12392)
-				tmp.textContent = "";
-			}
-		}
-	}
-
-	// Remove wrapper from fragment
-	fragment.textContent = "";
-
-	i = 0;
-	while ( ( elem = nodes[ i++ ] ) ) {
-
-		// Skip elements already in the context collection (trac-4087)
-		if ( selection && jQuery.inArray( elem, selection ) > -1 ) {
-			if ( ignored ) {
-				ignored.push( elem );
-			}
-			continue;
-		}
-
-		contains = jQuery.contains( elem.ownerDocument, elem );
-
-		// Append to fragment
-		tmp = getAll( fragment.appendChild( elem ), "script" );
-
-		// Preserve script evaluation history
-		if ( contains ) {
-			setGlobalEval( tmp );
-		}
-
-		// Capture executables
-		if ( scripts ) {
-			j = 0;
-			while ( ( elem = tmp[ j++ ] ) ) {
-				if ( rscriptType.test( elem.type || "" ) ) {
-					scripts.push( elem );
-				}
-			}
-		}
-	}
-
-	return fragment;
-}
-
-
-( function() {
-	var fragment = document.createDocumentFragment(),
-		div = fragment.appendChild( document.createElement( "div" ) ),
-		input = document.createElement( "input" );
-
-	// Support: Android 4.0 - 4.3 only
-	// Check state lost if the name is set (#11217)
-	// Support: Windows Web Apps (WWA)
-	// `name` and `type` must use .setAttribute for WWA (#14901)
-	input.setAttribute( "type", "radio" );
-	input.setAttribute( "checked", "checked" );
-	input.setAttribute( "name", "t" );
-
-	div.appendChild( input );
-
-	// Support: Android <=4.1 only
-	// Older WebKit doesn't clone checked state correctly in fragments
-	support.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked;
-
-	// Support: IE <=11 only
-	// Make sure textarea (and checkbox) defaultValue is properly cloned
-	div.innerHTML = "<textarea>x</textarea>";
-	support.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue;
-} )();
-var documentElement = document.documentElement;
-
-
-
-var
-	rkeyEvent = /^key/,
-	rmouseEvent = /^(?:mouse|pointer|contextmenu|drag|drop)|click/,
-	rtypenamespace = /^([^.]*)(?:\.(.+)|)/;
-
-function returnTrue() {
-	return true;
-}
-
-function returnFalse() {
-	return false;
-}
-
-// Support: IE <=9 only
-// See #13393 for more info
-function safeActiveElement() {
-	try {
-		return document.activeElement;
-	} catch ( err ) { }
-}
-
-function on( elem, types, selector, data, fn, one ) {
-	var origFn, type;
-
-	// Types can be a map of types/handlers
-	if ( typeof types === "object" ) {
-
-		// ( types-Object, selector, data )
-		if ( typeof selector !== "string" ) {
-
-			// ( types-Object, data )
-			data = data || selector;
-			selector = undefined;
-		}
-		for ( type in types ) {
-			on( elem, type, selector, data, types[ type ], one );
-		}
-		return elem;
-	}
-
-	if ( data == null && fn == null ) {
-
-		// ( types, fn )
-		fn = selector;
-		data = selector = undefined;
-	} else if ( fn == null ) {
-		if ( typeof selector === "string" ) {
-
-			// ( types, selector, fn )
-			fn = data;
-			data = undefined;
-		} else {
-
-			// ( types, data, fn )
-			fn = data;
-			data = selector;
-			selector = undefined;
-		}
-	}
-	if ( fn === false ) {
-		fn = returnFalse;
-	} else if ( !fn ) {
-		return elem;
-	}
-
-	if ( one === 1 ) {
-		origFn = fn;
-		fn = function( event ) {
-
-			// Can use an empty set, since event contains the info
-			jQuery().off( event );
-			return origFn.apply( this, arguments );
-		};
-
-		// Use same guid so caller can remove using origFn
-		fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );
-	}
-	return elem.each( function() {
-		jQuery.event.add( this, types, fn, data, selector );
-	} );
-}
-
-/*
- * Helper functions for managing events -- not part of the public interface.
- * Props to Dean Edwards' addEvent library for many of the ideas.
- */
-jQuery.event = {
-
-	global: {},
-
-	add: function( elem, types, handler, data, selector ) {
-
-		var handleObjIn, eventHandle, tmp,
-			events, t, handleObj,
-			special, handlers, type, namespaces, origType,
-			elemData = dataPriv.get( elem );
-
-		// Don't attach events to noData or text/comment nodes (but allow plain objects)
-		if ( !elemData ) {
-			return;
-		}
-
-		// Caller can pass in an object of custom data in lieu of the handler
-		if ( handler.handler ) {
-			handleObjIn = handler;
-			handler = handleObjIn.handler;
-			selector = handleObjIn.selector;
-		}
-
-		// Ensure that invalid selectors throw exceptions at attach time
-		// Evaluate against documentElement in case elem is a non-element node (e.g., document)
-		if ( selector ) {
-			jQuery.find.matchesSelector( documentElement, selector );
-		}
-
-		// Make sure that the handler has a unique ID, used to find/remove it later
-		if ( !handler.guid ) {
-			handler.guid = jQuery.guid++;
-		}
-
-		// Init the element's event structure and main handler, if this is the first
-		if ( !( events = elemData.events ) ) {
-			events = elemData.events = {};
-		}
-		if ( !( eventHandle = elemData.handle ) ) {
-			eventHandle = elemData.handle = function( e ) {
-
-				// Discard the second event of a jQuery.event.trigger() and
-				// when an event is called after a page has unloaded
-				return typeof jQuery !== "undefined" && jQuery.event.triggered !== e.type ?
-					jQuery.event.dispatch.apply( elem, arguments ) : undefined;
-			};
-		}
-
-		// Handle multiple events separated by a space
-		types = ( types || "" ).match( rnothtmlwhite ) || [ "" ];
-		t = types.length;
-		while ( t-- ) {
-			tmp = rtypenamespace.exec( types[ t ] ) || [];
-			type = origType = tmp[ 1 ];
-			namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort();
-
-			// There *must* be a type, no attaching namespace-only handlers
-			if ( !type ) {
-				continue;
-			}
-
-			// If event changes its type, use the special event handlers for the changed type
-			special = jQuery.event.special[ type ] || {};
-
-			// If selector defined, determine special event api type, otherwise given type
-			type = ( selector ? special.delegateType : special.bindType ) || type;
-
-			// Update special based on newly reset type
-			special = jQuery.event.special[ type ] || {};
-
-			// handleObj is passed to all event handlers
-			handleObj = jQuery.extend( {
-				type: type,
-				origType: origType,
-				data: data,
-				handler: handler,
-				guid: handler.guid,
-				selector: selector,
-				needsContext: selector && jQuery.expr.match.needsContext.test( selector ),
-				namespace: namespaces.join( "." )
-			}, handleObjIn );
-
-			// Init the event handler queue if we're the first
-			if ( !( handlers = events[ type ] ) ) {
-				handlers = events[ type ] = [];
-				handlers.delegateCount = 0;
-
-				// Only use addEventListener if the special events handler returns false
-				if ( !special.setup ||
-					special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
-
-					if ( elem.addEventListener ) {
-						elem.addEventListener( type, eventHandle );
-					}
-				}
-			}
-
-			if ( special.add ) {
-				special.add.call( elem, handleObj );
-
-				if ( !handleObj.handler.guid ) {
-					handleObj.handler.guid = handler.guid;
-				}
-			}
-
-			// Add to the element's handler list, delegates in front
-			if ( selector ) {
-				handlers.splice( handlers.delegateCount++, 0, handleObj );
-			} else {
-				handlers.push( handleObj );
-			}
-
-			// Keep track of which events have ever been used, for event optimization
-			jQuery.event.global[ type ] = true;
-		}
-
-	},
-
-	// Detach an event or set of events from an element
-	remove: function( elem, types, handler, selector, mappedTypes ) {
-
-		var j, origCount, tmp,
-			events, t, handleObj,
-			special, handlers, type, namespaces, origType,
-			elemData = dataPriv.hasData( elem ) && dataPriv.get( elem );
-
-		if ( !elemData || !( events = elemData.events ) ) {
-			return;
-		}
-
-		// Once for each type.namespace in types; type may be omitted
-		types = ( types || "" ).match( rnothtmlwhite ) || [ "" ];
-		t = types.length;
-		while ( t-- ) {
-			tmp = rtypenamespace.exec( types[ t ] ) || [];
-			type = origType = tmp[ 1 ];
-			namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort();
-
-			// Unbind all events (on this namespace, if provided) for the element
-			if ( !type ) {
-				for ( type in events ) {
-					jQuery.event.remove( elem, type + types[ t ], handler, selector, true );
-				}
-				continue;
-			}
-
-			special = jQuery.event.special[ type ] || {};
-			type = ( selector ? special.delegateType : special.bindType ) || type;
-			handlers = events[ type ] || [];
-			tmp = tmp[ 2 ] &&
-				new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" );
-
-			// Remove matching events
-			origCount = j = handlers.length;
-			while ( j-- ) {
-				handleObj = handlers[ j ];
-
-				if ( ( mappedTypes || origType === handleObj.origType ) &&
-					( !handler || handler.guid === handleObj.guid ) &&
-					( !tmp || tmp.test( handleObj.namespace ) ) &&
-					( !selector || selector === handleObj.selector ||
-						selector === "**" && handleObj.selector ) ) {
-					handlers.splice( j, 1 );
-
-					if ( handleObj.selector ) {
-						handlers.delegateCount--;
-					}
-					if ( special.remove ) {
-						special.remove.call( elem, handleObj );
-					}
-				}
-			}
-
-			// Remove generic event handler if we removed something and no more handlers exist
-			// (avoids potential for endless recursion during removal of special event handlers)
-			if ( origCount && !handlers.length ) {
-				if ( !special.teardown ||
-					special.teardown.call( elem, namespaces, elemData.handle ) === false ) {
-
-					jQuery.removeEvent( elem, type, elemData.handle );
-				}
-
-				delete events[ type ];
-			}
-		}
-
-		// Remove data and the expando if it's no longer used
-		if ( jQuery.isEmptyObject( events ) ) {
-			dataPriv.remove( elem, "handle events" );
-		}
-	},
-
-	dispatch: function( nativeEvent ) {
-
-		// Make a writable jQuery.Event from the native event object
-		var event = jQuery.event.fix( nativeEvent );
-
-		var i, j, ret, matched, handleObj, handlerQueue,
-			args = new Array( arguments.length ),
-			handlers = ( dataPriv.get( this, "events" ) || {} )[ event.type ] || [],
-			special = jQuery.event.special[ event.type ] || {};
-
-		// Use the fix-ed jQuery.Event rather than the (read-only) native event
-		args[ 0 ] = event;
-
-		for ( i = 1; i < arguments.length; i++ ) {
-			args[ i ] = arguments[ i ];
-		}
-
-		event.delegateTarget = this;
-
-		// Call the preDispatch hook for the mapped type, and let it bail if desired
-		if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {
-			return;
-		}
-
-		// Determine handlers
-		handlerQueue = jQuery.event.handlers.call( this, event, handlers );
-
-		// Run delegates first; they may want to stop propagation beneath us
-		i = 0;
-		while ( ( matched = handlerQueue[ i++ ] ) && !event.isPropagationStopped() ) {
-			event.currentTarget = matched.elem;
-
-			j = 0;
-			while ( ( handleObj = matched.handlers[ j++ ] ) &&
-				!event.isImmediatePropagationStopped() ) {
-
-				// Triggered event must either 1) have no namespace, or 2) have namespace(s)
-				// a subset or equal to those in the bound event (both can have no namespace).
-				if ( !event.rnamespace || event.rnamespace.test( handleObj.namespace ) ) {
-
-					event.handleObj = handleObj;
-					event.data = handleObj.data;
-
-					ret = ( ( jQuery.event.special[ handleObj.origType ] || {} ).handle ||
-						handleObj.handler ).apply( matched.elem, args );
-
-					if ( ret !== undefined ) {
-						if ( ( event.result = ret ) === false ) {
-							event.preventDefault();
-							event.stopPropagation();
-						}
-					}
-				}
-			}
-		}
-
-		// Call the postDispatch hook for the mapped type
-		if ( special.postDispatch ) {
-			special.postDispatch.call( this, event );
-		}
-
-		return event.result;
-	},
-
-	handlers: function( event, handlers ) {
-		var i, handleObj, sel, matchedHandlers, matchedSelectors,
-			handlerQueue = [],
-			delegateCount = handlers.delegateCount,
-			cur = event.target;
-
-		// Find delegate handlers
-		if ( delegateCount &&
-
-			// Support: IE <=9
-			// Black-hole SVG <use> instance trees (trac-13180)
-			cur.nodeType &&
-
-			// Support: Firefox <=42
-			// Suppress spec-violating clicks indicating a non-primary pointer button (trac-3861)
-			// https://www.w3.org/TR/DOM-Level-3-Events/#event-type-click
-			// Support: IE 11 only
-			// ...but not arrow key "clicks" of radio inputs, which can have `button` -1 (gh-2343)
-			!( event.type === "click" && event.button >= 1 ) ) {
-
-			for ( ; cur !== this; cur = cur.parentNode || this ) {
-
-				// Don't check non-elements (#13208)
-				// Don't process clicks on disabled elements (#6911, #8165, #11382, #11764)
-				if ( cur.nodeType === 1 && !( event.type === "click" && cur.disabled === true ) ) {
-					matchedHandlers = [];
-					matchedSelectors = {};
-					for ( i = 0; i < delegateCount; i++ ) {
-						handleObj = handlers[ i ];
-
-						// Don't conflict with Object.prototype properties (#13203)
-						sel = handleObj.selector + " ";
-
-						if ( matchedSelectors[ sel ] === undefined ) {
-							matchedSelectors[ sel ] = handleObj.needsContext ?
-								jQuery( sel, this ).index( cur ) > -1 :
-								jQuery.find( sel, this, null, [ cur ] ).length;
-						}
-						if ( matchedSelectors[ sel ] ) {
-							matchedHandlers.push( handleObj );
-						}
-					}
-					if ( matchedHandlers.length ) {
-						handlerQueue.push( { elem: cur, handlers: matchedHandlers } );
-					}
-				}
-			}
-		}
-
-		// Add the remaining (directly-bound) handlers
-		cur = this;
-		if ( delegateCount < handlers.length ) {
-			handlerQueue.push( { elem: cur, handlers: handlers.slice( delegateCount ) } );
-		}
-
-		return handlerQueue;
-	},
-
-	addProp: function( name, hook ) {
-		Object.defineProperty( jQuery.Event.prototype, name, {
-			enumerable: true,
-			configurable: true,
-
-			get: jQuery.isFunction( hook ) ?
-				function() {
-					if ( this.originalEvent ) {
-							return hook( this.originalEvent );
-					}
-				} :
-				function() {
-					if ( this.originalEvent ) {
-							return this.originalEvent[ name ];
-					}
-				},
-
-			set: function( value ) {
-				Object.defineProperty( this, name, {
-					enumerable: true,
-					configurable: true,
-					writable: true,
-					value: value
-				} );
-			}
-		} );
-	},
-
-	fix: function( originalEvent ) {
-		return originalEvent[ jQuery.expando ] ?
-			originalEvent :
-			new jQuery.Event( originalEvent );
-	},
-
-	special: {
-		load: {
-
-			// Prevent triggered image.load events from bubbling to window.load
-			noBubble: true
-		},
-		focus: {
-
-			// Fire native event if possible so blur/focus sequence is correct
-			trigger: function() {
-				if ( this !== safeActiveElement() && this.focus ) {
-					this.focus();
-					return false;
-				}
-			},
-			delegateType: "focusin"
-		},
-		blur: {
-			trigger: function() {
-				if ( this === safeActiveElement() && this.blur ) {
-					this.blur();
-					return false;
-				}
-			},
-			delegateType: "focusout"
-		},
-		click: {
-
-			// For checkbox, fire native event so checked state will be right
-			trigger: function() {
-				if ( this.type === "checkbox" && this.click && nodeName( this, "input" ) ) {
-					this.click();
-					return false;
-				}
-			},
-
-			// For cross-browser consistency, don't fire native .click() on links
-			_default: function( event ) {
-				return nodeName( event.target, "a" );
-			}
-		},
-
-		beforeunload: {
-			postDispatch: function( event ) {
-
-				// Support: Firefox 20+
-				// Firefox doesn't alert if the returnValue field is not set.
-				if ( event.result !== undefined && event.originalEvent ) {
-					event.originalEvent.returnValue = event.result;
-				}
-			}
-		}
-	}
-};
-
-jQuery.removeEvent = function( elem, type, handle ) {
-
-	// This "if" is needed for plain objects
-	if ( elem.removeEventListener ) {
-		elem.removeEventListener( type, handle );
-	}
-};
-
-jQuery.Event = function( src, props ) {
-
-	// Allow instantiation without the 'new' keyword
-	if ( !( this instanceof jQuery.Event ) ) {
-		return new jQuery.Event( src, props );
-	}
-
-	// Event object
-	if ( src && src.type ) {
-		this.originalEvent = src;
-		this.type = src.type;
-
-		// Events bubbling up the document may have been marked as prevented
-		// by a handler lower down the tree; reflect the correct value.
-		this.isDefaultPrevented = src.defaultPrevented ||
-				src.defaultPrevented === undefined &&
-
-				// Support: Android <=2.3 only
-				src.returnValue === false ?
-			returnTrue :
-			returnFalse;
-
-		// Create target properties
-		// Support: Safari <=6 - 7 only
-		// Target should not be a text node (#504, #13143)
-		this.target = ( src.target && src.target.nodeType === 3 ) ?
-			src.target.parentNode :
-			src.target;
-
-		this.currentTarget = src.currentTarget;
-		this.relatedTarget = src.relatedTarget;
-
-	// Event type
-	} else {
-		this.type = src;
-	}
-
-	// Put explicitly provided properties onto the event object
-	if ( props ) {
-		jQuery.extend( this, props );
-	}
-
-	// Create a timestamp if incoming event doesn't have one
-	this.timeStamp = src && src.timeStamp || jQuery.now();
-
-	// Mark it as fixed
-	this[ jQuery.expando ] = true;
-};
-
-// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
-// https://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
-jQuery.Event.prototype = {
-	constructor: jQuery.Event,
-	isDefaultPrevented: returnFalse,
-	isPropagationStopped: returnFalse,
-	isImmediatePropagationStopped: returnFalse,
-	isSimulated: false,
-
-	preventDefault: function() {
-		var e = this.originalEvent;
-
-		this.isDefaultPrevented = returnTrue;
-
-		if ( e && !this.isSimulated ) {
-			e.preventDefault();
-		}
-	},
-	stopPropagation: function() {
-		var e = this.originalEvent;
-
-		this.isPropagationStopped = returnTrue;
-
-		if ( e && !this.isSimulated ) {
-			e.stopPropagation();
-		}
-	},
-	stopImmediatePropagation: function() {
-		var e = this.originalEvent;
-
-		this.isImmediatePropagationStopped = returnTrue;
-
-		if ( e && !this.isSimulated ) {
-			e.stopImmediatePropagation();
-		}
-
-		this.stopPropagation();
-	}
-};
-
-// Includes all common event props including KeyEvent and MouseEvent specific props
-jQuery.each( {
-	altKey: true,
-	bubbles: true,
-	cancelable: true,
-	changedTouches: true,
-	ctrlKey: true,
-	detail: true,
-	eventPhase: true,
-	metaKey: true,
-	pageX: true,
-	pageY: true,
-	shiftKey: true,
-	view: true,
-	"char": true,
-	charCode: true,
-	key: true,
-	keyCode: true,
-	button: true,
-	buttons: true,
-	clientX: true,
-	clientY: true,
-	offsetX: true,
-	offsetY: true,
-	pointerId: true,
-	pointerType: true,
-	screenX: true,
-	screenY: true,
-	targetTouches: true,
-	toElement: true,
-	touches: true,
-
-	which: function( event ) {
-		var button = event.button;
-
-		// Add which for key events
-		if ( event.which == null && rkeyEvent.test( event.type ) ) {
-			return event.charCode != null ? event.charCode : event.keyCode;
-		}
-
-		// Add which for click: 1 === left; 2 === middle; 3 === right
-		if ( !event.which && button !== undefined && rmouseEvent.test( event.type ) ) {
-			if ( button & 1 ) {
-				return 1;
-			}
-
-			if ( button & 2 ) {
-				return 3;
-			}
-
-			if ( button & 4 ) {
-				return 2;
-			}
-
-			return 0;
-		}
-
-		return event.which;
-	}
-}, jQuery.event.addProp );
-
-// Create mouseenter/leave events using mouseover/out and event-time checks
-// so that event delegation works in jQuery.
-// Do the same for pointerenter/pointerleave and pointerover/pointerout
-//
-// Support: Safari 7 only
-// Safari sends mouseenter too often; see:
-// https://bugs.chromium.org/p/chromium/issues/detail?id=470258
-// for the description of the bug (it existed in older Chrome versions as well).
-jQuery.each( {
-	mouseenter: "mouseover",
-	mouseleave: "mouseout",
-	pointerenter: "pointerover",
-	pointerleave: "pointerout"
-}, function( orig, fix ) {
-	jQuery.event.special[ orig ] = {
-		delegateType: fix,
-		bindType: fix,
-
-		handle: function( event ) {
-			var ret,
-				target = this,
-				related = event.relatedTarget,
-				handleObj = event.handleObj;
-
-			// For mouseenter/leave call the handler if related is outside the target.
-			// NB: No relatedTarget if the mouse left/entered the browser window
-			if ( !related || ( related !== target && !jQuery.contains( target, related ) ) ) {
-				event.type = handleObj.origType;
-				ret = handleObj.handler.apply( this, arguments );
-				event.type = fix;
-			}
-			return ret;
-		}
-	};
-} );
-
-jQuery.fn.extend( {
-
-	on: function( types, selector, data, fn ) {
-		return on( this, types, selector, data, fn );
-	},
-	one: function( types, selector, data, fn ) {
-		return on( this, types, selector, data, fn, 1 );
-	},
-	off: function( types, selector, fn ) {
-		var handleObj, type;
-		if ( types && types.preventDefault && types.handleObj ) {
-
-			// ( event )  dispatched jQuery.Event
-			handleObj = types.handleObj;
-			jQuery( types.delegateTarget ).off(
-				handleObj.namespace ?
-					handleObj.origType + "." + handleObj.namespace :
-					handleObj.origType,
-				handleObj.selector,
-				handleObj.handler
-			);
-			return this;
-		}
-		if ( typeof types === "object" ) {
-
-			// ( types-object [, selector] )
-			for ( type in types ) {
-				this.off( type, selector, types[ type ] );
-			}
-			return this;
-		}
-		if ( selector === false || typeof selector === "function" ) {
-
-			// ( types [, fn] )
-			fn = selector;
-			selector = undefined;
-		}
-		if ( fn === false ) {
-			fn = returnFalse;
-		}
-		return this.each( function() {
-			jQuery.event.remove( this, types, fn, selector );
-		} );
-	}
-} );
-
-
-var
-
-	/* eslint-disable max-len */
-
-	// See https://github.com/eslint/eslint/issues/3229
-	rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([a-z][^\/\0>\x20\t\r\n\f]*)[^>]*)\/>/gi,
-
-	/* eslint-enable */
-
-	// Support: IE <=10 - 11, Edge 12 - 13
-	// In IE/Edge using regex groups here causes severe slowdowns.
-	// See https://connect.microsoft.com/IE/feedback/details/1736512/
-	rnoInnerhtml = /<script|<style|<link/i,
-
-	// checked="checked" or checked
-	rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
-	rscriptTypeMasked = /^true\/(.*)/,
-	rcleanScript = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g;
-
-// Prefer a tbody over its parent table for containing new rows
-function manipulationTarget( elem, content ) {
-	if ( nodeName( elem, "table" ) &&
-		nodeName( content.nodeType !== 11 ? content : content.firstChild, "tr" ) ) {
-
-		return jQuery( ">tbody", elem )[ 0 ] || elem;
-	}
-
-	return elem;
-}
-
-// Replace/restore the type attribute of script elements for safe DOM manipulation
-function disableScript( elem ) {
-	elem.type = ( elem.getAttribute( "type" ) !== null ) + "/" + elem.type;
-	return elem;
-}
-function restoreScript( elem ) {
-	var match = rscriptTypeMasked.exec( elem.type );
-
-	if ( match ) {
-		elem.type = match[ 1 ];
-	} else {
-		elem.removeAttribute( "type" );
-	}
-
-	return elem;
-}
-
-function cloneCopyEvent( src, dest ) {
-	var i, l, type, pdataOld, pdataCur, udataOld, udataCur, events;
-
-	if ( dest.nodeType !== 1 ) {
-		return;
-	}
-
-	// 1. Copy private data: events, handlers, etc.
-	if ( dataPriv.hasData( src ) ) {
-		pdataOld = dataPriv.access( src );
-		pdataCur = dataPriv.set( dest, pdataOld );
-		events = pdataOld.events;
-
-		if ( events ) {
-			delete pdataCur.handle;
-			pdataCur.events = {};
-
-			for ( type in events ) {
-				for ( i = 0, l = events[ type ].length; i < l; i++ ) {
-					jQuery.event.add( dest, type, events[ type ][ i ] );
-				}
-			}
-		}
-	}
-
-	// 2. Copy user data
-	if ( dataUser.hasData( src ) ) {
-		udataOld = dataUser.access( src );
-		udataCur = jQuery.extend( {}, udataOld );
-
-		dataUser.set( dest, udataCur );
-	}
-}
-
-// Fix IE bugs, see support tests
-function fixInput( src, dest ) {
-	var nodeName = dest.nodeName.toLowerCase();
-
-	// Fails to persist the checked state of a cloned checkbox or radio button.
-	if ( nodeName === "input" && rcheckableType.test( src.type ) ) {
-		dest.checked = src.checked;
-
-	// Fails to return the selected option to the default selected state when cloning options
-	} else if ( nodeName === "input" || nodeName === "textarea" ) {
-		dest.defaultValue = src.defaultValue;
-	}
-}
-
-function domManip( collection, args, callback, ignored ) {
-
-	// Flatten any nested arrays
-	args = concat.apply( [], args );
-
-	var fragment, first, scripts, hasScripts, node, doc,
-		i = 0,
-		l = collection.length,
-		iNoClone = l - 1,
-		value = args[ 0 ],
-		isFunction = jQuery.isFunction( value );
-
-	// We can't cloneNode fragments that contain checked, in WebKit
-	if ( isFunction ||
-			( l > 1 && typeof value === "string" &&
-				!support.checkClone && rchecked.test( value ) ) ) {
-		return collection.each( function( index ) {
-			var self = collection.eq( index );
-			if ( isFunction ) {
-				args[ 0 ] = value.call( this, index, self.html() );
-			}
-			domManip( self, args, callback, ignored );
-		} );
-	}
-
-	if ( l ) {
-		fragment = buildFragment( args, collection[ 0 ].ownerDocument, false, collection, ignored );
-		first = fragment.firstChild;
-
-		if ( fragment.childNodes.length === 1 ) {
-			fragment = first;
-		}
-
-		// Require either new content or an interest in ignored elements to invoke the callback
-		if ( first || ignored ) {
-			scripts = jQuery.map( getAll( fragment, "script" ), disableScript );
-			hasScripts = scripts.length;
-
-			// Use the original fragment for the last item
-			// instead of the first because it can end up
-			// being emptied incorrectly in certain situations (#8070).
-			for ( ; i < l; i++ ) {
-				node = fragment;
-
-				if ( i !== iNoClone ) {
-					node = jQuery.clone( node, true, true );
-
-					// Keep references to cloned scripts for later restoration
-					if ( hasScripts ) {
-
-						// Support: Android <=4.0 only, PhantomJS 1 only
-						// push.apply(_, arraylike) throws on ancient WebKit
-						jQuery.merge( scripts, getAll( node, "script" ) );
-					}
-				}
-
-				callback.call( collection[ i ], node, i );
-			}
-
-			if ( hasScripts ) {
-				doc = scripts[ scripts.length - 1 ].ownerDocument;
-
-				// Reenable scripts
-				jQuery.map( scripts, restoreScript );
-
-				// Evaluate executable scripts on first document insertion
-				for ( i = 0; i < hasScripts; i++ ) {
-					node = scripts[ i ];
-					if ( rscriptType.test( node.type || "" ) &&
-						!dataPriv.access( node, "globalEval" ) &&
-						jQuery.contains( doc, node ) ) {
-
-						if ( node.src ) {
-
-							// Optional AJAX dependency, but won't run scripts if not present
-							if ( jQuery._evalUrl ) {
-								jQuery._evalUrl( node.src );
-							}
-						} else {
-							DOMEval( node.textContent.replace( rcleanScript, "" ), doc );
-						}
-					}
-				}
-			}
-		}
-	}
-
-	return collection;
-}
-
-function remove( elem, selector, keepData ) {
-	var node,
-		nodes = selector ? jQuery.filter( selector, elem ) : elem,
-		i = 0;
-
-	for ( ; ( node = nodes[ i ] ) != null; i++ ) {
-		if ( !keepData && node.nodeType === 1 ) {
-			jQuery.cleanData( getAll( node ) );
-		}
-
-		if ( node.parentNode ) {
-			if ( keepData && jQuery.contains( node.ownerDocument, node ) ) {
-				setGlobalEval( getAll( node, "script" ) );
-			}
-			node.parentNode.removeChild( node );
-		}
-	}
-
-	return elem;
-}
-
-jQuery.extend( {
-	htmlPrefilter: function( html ) {
-		return html.replace( rxhtmlTag, "<$1></$2>" );
-	},
-
-	clone: function( elem, dataAndEvents, deepDataAndEvents ) {
-		var i, l, srcElements, destElements,
-			clone = elem.cloneNode( true ),
-			inPage = jQuery.contains( elem.ownerDocument, elem );
-
-		// Fix IE cloning issues
-		if ( !support.noCloneChecked && ( elem.nodeType === 1 || elem.nodeType === 11 ) &&
-				!jQuery.isXMLDoc( elem ) ) {
-
-			// We eschew Sizzle here for performance reasons: https://jsperf.com/getall-vs-sizzle/2
-			destElements = getAll( clone );
-			srcElements = getAll( elem );
-
-			for ( i = 0, l = srcElements.length; i < l; i++ ) {
-				fixInput( srcElements[ i ], destElements[ i ] );
-			}
-		}
-
-		// Copy the events from the original to the clone
-		if ( dataAndEvents ) {
-			if ( deepDataAndEvents ) {
-				srcElements = srcElements || getAll( elem );
-				destElements = destElements || getAll( clone );
-
-				for ( i = 0, l = srcElements.length; i < l; i++ ) {
-					cloneCopyEvent( srcElements[ i ], destElements[ i ] );
-				}
-			} else {
-				cloneCopyEvent( elem, clone );
-			}
-		}
-
-		// Preserve script evaluation history
-		destElements = getAll( clone, "script" );
-		if ( destElements.length > 0 ) {
-			setGlobalEval( destElements, !inPage && getAll( elem, "script" ) );
-		}
-
-		// Return the cloned set
-		return clone;
-	},
-
-	cleanData: function( elems ) {
-		var data, elem, type,
-			special = jQuery.event.special,
-			i = 0;
-
-		for ( ; ( elem = elems[ i ] ) !== undefined; i++ ) {
-			if ( acceptData( elem ) ) {
-				if ( ( data = elem[ dataPriv.expando ] ) ) {
-					if ( data.events ) {
-						for ( type in data.events ) {
-							if ( special[ type ] ) {
-								jQuery.event.remove( elem, type );
-
-							// This is a shortcut to avoid jQuery.event.remove's overhead
-							} else {
-								jQuery.removeEvent( elem, type, data.handle );
-							}
-						}
-					}
-
-					// Support: Chrome <=35 - 45+
-					// Assign undefined instead of using delete, see Data#remove
-					elem[ dataPriv.expando ] = undefined;
-				}
-				if ( elem[ dataUser.expando ] ) {
-
-					// Support: Chrome <=35 - 45+
-					// Assign undefined instead of using delete, see Data#remove
-					elem[ dataUser.expando ] = undefined;
-				}
-			}
-		}
-	}
-} );
-
-jQuery.fn.extend( {
-	detach: function( selector ) {
-		return remove( this, selector, true );
-	},
-
-	remove: function( selector ) {
-		return remove( this, selector );
-	},
-
-	text: function( value ) {
-		return access( this, function( value ) {
-			return value === undefined ?
-				jQuery.text( this ) :
-				this.empty().each( function() {
-					if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
-						this.textContent = value;
-					}
-				} );
-		}, null, value, arguments.length );
-	},
-
-	append: function() {
-		return domManip( this, arguments, function( elem ) {
-			if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
-				var target = manipulationTarget( this, elem );
-				target.appendChild( elem );
-			}
-		} );
-	},
-
-	prepend: function() {
-		return domManip( this, arguments, function( elem ) {
-			if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
-				var target = manipulationTarget( this, elem );
-				target.insertBefore( elem, target.firstChild );
-			}
-		} );
-	},
-
-	before: function() {
-		return domManip( this, arguments, function( elem ) {
-			if ( this.parentNode ) {
-				this.parentNode.insertBefore( elem, this );
-			}
-		} );
-	},
-
-	after: function() {
-		return domManip( this, arguments, function( elem ) {
-			if ( this.parentNode ) {
-				this.parentNode.insertBefore( elem, this.nextSibling );
-			}
-		} );
-	},
-
-	empty: function() {
-		var elem,
-			i = 0;
-
-		for ( ; ( elem = this[ i ] ) != null; i++ ) {
-			if ( elem.nodeType === 1 ) {
-
-				// Prevent memory leaks
-				jQuery.cleanData( getAll( elem, false ) );
-
-				// Remove any remaining nodes
-				elem.textContent = "";
-			}
-		}
-
-		return this;
-	},
-
-	clone: function( dataAndEvents, deepDataAndEvents ) {
-		dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
-		deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
-
-		return this.map( function() {
-			return jQuery.clone( this, dataAndEvents, deepDataAndEvents );
-		} );
-	},
-
-	html: function( value ) {
-		return access( this, function( value ) {
-			var elem = this[ 0 ] || {},
-				i = 0,
-				l = this.length;
-
-			if ( value === undefined && elem.nodeType === 1 ) {
-				return elem.innerHTML;
-			}
-
-			// See if we can take a shortcut and just use innerHTML
-			if ( typeof value === "string" && !rnoInnerhtml.test( value ) &&
-				!wrapMap[ ( rtagName.exec( value ) || [ "", "" ] )[ 1 ].toLowerCase() ] ) {
-
-				value = jQuery.htmlPrefilter( value );
-
-				try {
-					for ( ; i < l; i++ ) {
-						elem = this[ i ] || {};
-
-						// Remove element nodes and prevent memory leaks
-						if ( elem.nodeType === 1 ) {
-							jQuery.cleanData( getAll( elem, false ) );
-							elem.innerHTML = value;
-						}
-					}
-
-					elem = 0;
-
-				// If using innerHTML throws an exception, use the fallback method
-				} catch ( e ) {}
-			}
-
-			if ( elem ) {
-				this.empty().append( value );
-			}
-		}, null, value, arguments.length );
-	},
-
-	replaceWith: function() {
-		var ignored = [];
-
-		// Make the changes, replacing each non-ignored context element with the new content
-		return domManip( this, arguments, function( elem ) {
-			var parent = this.parentNode;
-
-			if ( jQuery.inArray( this, ignored ) < 0 ) {
-				jQuery.cleanData( getAll( this ) );
-				if ( parent ) {
-					parent.replaceChild( elem, this );
-				}
-			}
-
-		// Force callback invocation
-		}, ignored );
-	}
-} );
-
-jQuery.each( {
-	appendTo: "append",
-	prependTo: "prepend",
-	insertBefore: "before",
-	insertAfter: "after",
-	replaceAll: "replaceWith"
-}, function( name, original ) {
-	jQuery.fn[ name ] = function( selector ) {
-		var elems,
-			ret = [],
-			insert = jQuery( selector ),
-			last = insert.length - 1,
-			i = 0;
-
-		for ( ; i <= last; i++ ) {
-			elems = i === last ? this : this.clone( true );
-			jQuery( insert[ i ] )[ original ]( elems );
-
-			// Support: Android <=4.0 only, PhantomJS 1 only
-			// .get() because push.apply(_, arraylike) throws on ancient WebKit
-			push.apply( ret, elems.get() );
-		}
-
-		return this.pushStack( ret );
-	};
-} );
-var rmargin = ( /^margin/ );
-
-var rnumnonpx = new RegExp( "^(" + pnum + ")(?!px)[a-z%]+$", "i" );
-
-var getStyles = function( elem ) {
-
-		// Support: IE <=11 only, Firefox <=30 (#15098, #14150)
-		// IE throws on elements created in popups
-		// FF meanwhile throws on frame elements through "defaultView.getComputedStyle"
-		var view = elem.ownerDocument.defaultView;
-
-		if ( !view || !view.opener ) {
-			view = window;
-		}
-
-		return view.getComputedStyle( elem );
-	};
-
-
-
-( function() {
-
-	// Executing both pixelPosition & boxSizingReliable tests require only one layout
-	// so they're executed at the same time to save the second computation.
-	function computeStyleTests() {
-
-		// This is a singleton, we need to execute it only once
-		if ( !div ) {
-			return;
-		}
-
-		div.style.cssText =
-			"box-sizing:border-box;" +
-			"position:relative;display:block;" +
-			"margin:auto;border:1px;padding:1px;" +
-			"top:1%;width:50%";
-		div.innerHTML = "";
-		documentElement.appendChild( container );
-
-		var divStyle = window.getComputedStyle( div );
-		pixelPositionVal = divStyle.top !== "1%";
-
-		// Support: Android 4.0 - 4.3 only, Firefox <=3 - 44
-		reliableMarginLeftVal = divStyle.marginLeft === "2px";
-		boxSizingReliableVal = divStyle.width === "4px";
-
-		// Support: Android 4.0 - 4.3 only
-		// Some styles come back with percentage values, even though they shouldn't
-		div.style.marginRight = "50%";
-		pixelMarginRightVal = divStyle.marginRight === "4px";
-
-		documentElement.removeChild( container );
-
-		// Nullify the div so it wouldn't be stored in the memory and
-		// it will also be a sign that checks already performed
-		div = null;
-	}
-
-	var pixelPositionVal, boxSizingReliableVal, pixelMarginRightVal, reliableMarginLeftVal,
-		container = document.createElement( "div" ),
-		div = document.createElement( "div" );
-
-	// Finish early in limited (non-browser) environments
-	if ( !div.style ) {
-		return;
-	}
-
-	// Support: IE <=9 - 11 only
-	// Style of cloned element affects source element cloned (#8908)
-	div.style.backgroundClip = "content-box";
-	div.cloneNode( true ).style.backgroundClip = "";
-	support.clearCloneStyle = div.style.backgroundClip === "content-box";
-
-	container.style.cssText = "border:0;width:8px;height:0;top:0;left:-9999px;" +
-		"padding:0;margin-top:1px;position:absolute";
-	container.appendChild( div );
-
-	jQuery.extend( support, {
-		pixelPosition: function() {
-			computeStyleTests();
-			return pixelPositionVal;
-		},
-		boxSizingReliable: function() {
-			computeStyleTests();
-			return boxSizingReliableVal;
-		},
-		pixelMarginRight: function() {
-			computeStyleTests();
-			return pixelMarginRightVal;
-		},
-		reliableMarginLeft: function() {
-			computeStyleTests();
-			return reliableMarginLeftVal;
-		}
-	} );
-} )();
-
-
-function curCSS( elem, name, computed ) {
-	var width, minWidth, maxWidth, ret,
-
-		// Support: Firefox 51+
-		// Retrieving style before computed somehow
-		// fixes an issue with getting wrong values
-		// on detached elements
-		style = elem.style;
-
-	computed = computed || getStyles( elem );
-
-	// getPropertyValue is needed for:
-	//   .css('filter') (IE 9 only, #12537)
-	//   .css('--customProperty) (#3144)
-	if ( computed ) {
-		ret = computed.getPropertyValue( name ) || computed[ name ];
-
-		if ( ret === "" && !jQuery.contains( elem.ownerDocument, elem ) ) {
-			ret = jQuery.style( elem, name );
-		}
-
-		// A tribute to the "awesome hack by Dean Edwards"
-		// Android Browser returns percentage for some values,
-		// but width seems to be reliably pixels.
-		// This is against the CSSOM draft spec:
-		// https://drafts.csswg.org/cssom/#resolved-values
-		if ( !support.pixelMarginRight() && rnumnonpx.test( ret ) && rmargin.test( name ) ) {
-
-			// Remember the original values
-			width = style.width;
-			minWidth = style.minWidth;
-			maxWidth = style.maxWidth;
-
-			// Put in the new values to get a computed value out
-			style.minWidth = style.maxWidth = style.width = ret;
-			ret = computed.width;
-
-			// Revert the changed values
-			style.width = width;
-			style.minWidth = minWidth;
-			style.maxWidth = maxWidth;
-		}
-	}
-
-	return ret !== undefined ?
-
-		// Support: IE <=9 - 11 only
-		// IE returns zIndex value as an integer.
-		ret + "" :
-		ret;
-}
-
-
-function addGetHookIf( conditionFn, hookFn ) {
-
-	// Define the hook, we'll check on the first run if it's really needed.
-	return {
-		get: function() {
-			if ( conditionFn() ) {
-
-				// Hook not needed (or it's not possible to use it due
-				// to missing dependency), remove it.
-				delete this.get;
-				return;
-			}
-
-			// Hook needed; redefine it so that the support test is not executed again.
-			return ( this.get = hookFn ).apply( this, arguments );
-		}
-	};
-}
-
-
-var
-
-	// Swappable if display is none or starts with table
-	// except "table", "table-cell", or "table-caption"
-	// See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display
-	rdisplayswap = /^(none|table(?!-c[ea]).+)/,
-	rcustomProp = /^--/,
-	cssShow = { position: "absolute", visibility: "hidden", display: "block" },
-	cssNormalTransform = {
-		letterSpacing: "0",
-		fontWeight: "400"
-	},
-
-	cssPrefixes = [ "Webkit", "Moz", "ms" ],
-	emptyStyle = document.createElement( "div" ).style;
-
-// Return a css property mapped to a potentially vendor prefixed property
-function vendorPropName( name ) {
-
-	// Shortcut for names that are not vendor prefixed
-	if ( name in emptyStyle ) {
-		return name;
-	}
-
-	// Check for vendor prefixed names
-	var capName = name[ 0 ].toUpperCase() + name.slice( 1 ),
-		i = cssPrefixes.length;
-
-	while ( i-- ) {
-		name = cssPrefixes[ i ] + capName;
-		if ( name in emptyStyle ) {
-			return name;
-		}
-	}
-}
-
-// Return a property mapped along what jQuery.cssProps suggests or to
-// a vendor prefixed property.
-function finalPropName( name ) {
-	var ret = jQuery.cssProps[ name ];
-	if ( !ret ) {
-		ret = jQuery.cssProps[ name ] = vendorPropName( name ) || name;
-	}
-	return ret;
-}
-
-function setPositiveNumber( elem, value, subtract ) {
-
-	// Any relative (+/-) values have already been
-	// normalized at this point
-	var matches = rcssNum.exec( value );
-	return matches ?
-
-		// Guard against undefined "subtract", e.g., when used as in cssHooks
-		Math.max( 0, matches[ 2 ] - ( subtract || 0 ) ) + ( matches[ 3 ] || "px" ) :
-		value;
-}
-
-function augmentWidthOrHeight( elem, name, extra, isBorderBox, styles ) {
-	var i,
-		val = 0;
-
-	// If we already have the right measurement, avoid augmentation
-	if ( extra === ( isBorderBox ? "border" : "content" ) ) {
-		i = 4;
-
-	// Otherwise initialize for horizontal or vertical properties
-	} else {
-		i = name === "width" ? 1 : 0;
-	}
-
-	for ( ; i < 4; i += 2 ) {
-
-		// Both box models exclude margin, so add it if we want it
-		if ( extra === "margin" ) {
-			val += jQuery.css( elem, extra + cssExpand[ i ], true, styles );
-		}
-
-		if ( isBorderBox ) {
-
-			// border-box includes padding, so remove it if we want content
-			if ( extra === "content" ) {
-				val -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
-			}
-
-			// At this point, extra isn't border nor margin, so remove border
-			if ( extra !== "margin" ) {
-				val -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
-			}
-		} else {
-
-			// At this point, extra isn't content, so add padding
-			val += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
-
-			// At this point, extra isn't content nor padding, so add border
-			if ( extra !== "padding" ) {
-				val += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
-			}
-		}
-	}
-
-	return val;
-}
-
-function getWidthOrHeight( elem, name, extra ) {
-
-	// Start with computed style
-	var valueIsBorderBox,
-		styles = getStyles( elem ),
-		val = curCSS( elem, name, styles ),
-		isBorderBox = jQuery.css( elem, "boxSizing", false, styles ) === "border-box";
-
-	// Computed unit is not pixels. Stop here and return.
-	if ( rnumnonpx.test( val ) ) {
-		return val;
-	}
-
-	// Check for style in case a browser which returns unreliable values
-	// for getComputedStyle silently falls back to the reliable elem.style
-	valueIsBorderBox = isBorderBox &&
-		( support.boxSizingReliable() || val === elem.style[ name ] );
-
-	// Fall back to offsetWidth/Height when value is "auto"
-	// This happens for inline elements with no explicit setting (gh-3571)
-	if ( val === "auto" ) {
-		val = elem[ "offset" + name[ 0 ].toUpperCase() + name.slice( 1 ) ];
-	}
-
-	// Normalize "", auto, and prepare for extra
-	val = parseFloat( val ) || 0;
-
-	// Use the active box-sizing model to add/subtract irrelevant styles
-	return ( val +
-		augmentWidthOrHeight(
-			elem,
-			name,
-			extra || ( isBorderBox ? "border" : "content" ),
-			valueIsBorderBox,
-			styles
-		)
-	) + "px";
-}
-
-jQuery.extend( {
-
-	// Add in style property hooks for overriding the default
-	// behavior of getting and setting a style property
-	cssHooks: {
-		opacity: {
-			get: function( elem, computed ) {
-				if ( computed ) {
-
-					// We should always get a number back from opacity
-					var ret = curCSS( elem, "opacity" );
-					return ret === "" ? "1" : ret;
-				}
-			}
-		}
-	},
-
-	// Don't automatically add "px" to these possibly-unitless properties
-	cssNumber: {
-		"animationIterationCount": true,
-		"columnCount": true,
-		"fillOpacity": true,
-		"flexGrow": true,
-		"flexShrink": true,
-		"fontWeight": true,
-		"lineHeight": true,
-		"opacity": true,
-		"order": true,
-		"orphans": true,
-		"widows": true,
-		"zIndex": true,
-		"zoom": true
-	},
-
-	// Add in properties whose names you wish to fix before
-	// setting or getting the value
-	cssProps: {
-		"float": "cssFloat"
-	},
-
-	// Get and set the style property on a DOM Node
-	style: function( elem, name, value, extra ) {
-
-		// Don't set styles on text and comment nodes
-		if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {
-			return;
-		}
-
-		// Make sure that we're working with the right name
-		var ret, type, hooks,
-			origName = jQuery.camelCase( name ),
-			isCustomProp = rcustomProp.test( name ),
-			style = elem.style;
-
-		// Make sure that we're working with the right name. We don't
-		// want to query the value if it is a CSS custom property
-		// since they are user-defined.
-		if ( !isCustomProp ) {
-			name = finalPropName( origName );
-		}
-
-		// Gets hook for the prefixed version, then unprefixed version
-		hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
-
-		// Check if we're setting a value
-		if ( value !== undefined ) {
-			type = typeof value;
-
-			// Convert "+=" or "-=" to relative numbers (#7345)
-			if ( type === "string" && ( ret = rcssNum.exec( value ) ) && ret[ 1 ] ) {
-				value = adjustCSS( elem, name, ret );
-
-				// Fixes bug #9237
-				type = "number";
-			}
-
-			// Make sure that null and NaN values aren't set (#7116)
-			if ( value == null || value !== value ) {
-				return;
-			}
-
-			// If a number was passed in, add the unit (except for certain CSS properties)
-			if ( type === "number" ) {
-				value += ret && ret[ 3 ] || ( jQuery.cssNumber[ origName ] ? "" : "px" );
-			}
-
-			// background-* props affect original clone's values
-			if ( !support.clearCloneStyle && value === "" && name.indexOf( "background" ) === 0 ) {
-				style[ name ] = "inherit";
-			}
-
-			// If a hook was provided, use that value, otherwise just set the specified value
-			if ( !hooks || !( "set" in hooks ) ||
-				( value = hooks.set( elem, value, extra ) ) !== undefined ) {
-
-				if ( isCustomProp ) {
-					style.setProperty( name, value );
-				} else {
-					style[ name ] = value;
-				}
-			}
-
-		} else {
-
-			// If a hook was provided get the non-computed value from there
-			if ( hooks && "get" in hooks &&
-				( ret = hooks.get( elem, false, extra ) ) !== undefined ) {
-
-				return ret;
-			}
-
-			// Otherwise just get the value from the style object
-			return style[ name ];
-		}
-	},
-
-	css: function( elem, name, extra, styles ) {
-		var val, num, hooks,
-			origName = jQuery.camelCase( name ),
-			isCustomProp = rcustomProp.test( name );
-
-		// Make sure that we're working with the right name. We don't
-		// want to modify the value if it is a CSS custom property
-		// since they are user-defined.
-		if ( !isCustomProp ) {
-			name = finalPropName( origName );
-		}
-
-		// Try prefixed name followed by the unprefixed name
-		hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
-
-		// If a hook was provided get the computed value from there
-		if ( hooks && "get" in hooks ) {
-			val = hooks.get( elem, true, extra );
-		}
-
-		// Otherwise, if a way to get the computed value exists, use that
-		if ( val === undefined ) {
-			val = curCSS( elem, name, styles );
-		}
-
-		// Convert "normal" to computed value
-		if ( val === "normal" && name in cssNormalTransform ) {
-			val = cssNormalTransform[ name ];
-		}
-
-		// Make numeric if forced or a qualifier was provided and val looks numeric
-		if ( extra === "" || extra ) {
-			num = parseFloat( val );
-			return extra === true || isFinite( num ) ? num || 0 : val;
-		}
-
-		return val;
-	}
-} );
-
-jQuery.each( [ "height", "width" ], function( i, name ) {
-	jQuery.cssHooks[ name ] = {
-		get: function( elem, computed, extra ) {
-			if ( computed ) {
-
-				// Certain elements can have dimension info if we invisibly show them
-				// but it must have a current display style that would benefit
-				return rdisplayswap.test( jQuery.css( elem, "display" ) ) &&
-
-					// Support: Safari 8+
-					// Table columns in Safari have non-zero offsetWidth & zero
-					// getBoundingClientRect().width unless display is changed.
-					// Support: IE <=11 only
-					// Running getBoundingClientRect on a disconnected node
-					// in IE throws an error.
-					( !elem.getClientRects().length || !elem.getBoundingClientRect().width ) ?
-						swap( elem, cssShow, function() {
-							return getWidthOrHeight( elem, name, extra );
-						} ) :
-						getWidthOrHeight( elem, name, extra );
-			}
-		},
-
-		set: function( elem, value, extra ) {
-			var matches,
-				styles = extra && getStyles( elem ),
-				subtract = extra && augmentWidthOrHeight(
-					elem,
-					name,
-					extra,
-					jQuery.css( elem, "boxSizing", false, styles ) === "border-box",
-					styles
-				);
-
-			// Convert to pixels if value adjustment is needed
-			if ( subtract && ( matches = rcssNum.exec( value ) ) &&
-				( matches[ 3 ] || "px" ) !== "px" ) {
-
-				elem.style[ name ] = value;
-				value = jQuery.css( elem, name );
-			}
-
-			return setPositiveNumber( elem, value, subtract );
-		}
-	};
-} );
-
-jQuery.cssHooks.marginLeft = addGetHookIf( support.reliableMarginLeft,
-	function( elem, computed ) {
-		if ( computed ) {
-			return ( parseFloat( curCSS( elem, "marginLeft" ) ) ||
-				elem.getBoundingClientRect().left -
-					swap( elem, { marginLeft: 0 }, function() {
-						return elem.getBoundingClientRect().left;
-					} )
-				) + "px";
-		}
-	}
-);
-
-// These hooks are used by animate to expand properties
-jQuery.each( {
-	margin: "",
-	padding: "",
-	border: "Width"
-}, function( prefix, suffix ) {
-	jQuery.cssHooks[ prefix + suffix ] = {
-		expand: function( value ) {
-			var i = 0,
-				expanded = {},
-
-				// Assumes a single number if not a string
-				parts = typeof value === "string" ? value.split( " " ) : [ value ];
-
-			for ( ; i < 4; i++ ) {
-				expanded[ prefix + cssExpand[ i ] + suffix ] =
-					parts[ i ] || parts[ i - 2 ] || parts[ 0 ];
-			}
-
-			return expanded;
-		}
-	};
-
-	if ( !rmargin.test( prefix ) ) {
-		jQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber;
-	}
-} );
-
-jQuery.fn.extend( {
-	css: function( name, value ) {
-		return access( this, function( elem, name, value ) {
-			var styles, len,
-				map = {},
-				i = 0;
-
-			if ( Array.isArray( name ) ) {
-				styles = getStyles( elem );
-				len = name.length;
-
-				for ( ; i < len; i++ ) {
-					map[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles );
-				}
-
-				return map;
-			}
-
-			return value !== undefined ?
-				jQuery.style( elem, name, value ) :
-				jQuery.css( elem, name );
-		}, name, value, arguments.length > 1 );
-	}
-} );
-
-
-function Tween( elem, options, prop, end, easing ) {
-	return new Tween.prototype.init( elem, options, prop, end, easing );
-}
-jQuery.Tween = Tween;
-
-Tween.prototype = {
-	constructor: Tween,
-	init: function( elem, options, prop, end, easing, unit ) {
-		this.elem = elem;
-		this.prop = prop;
-		this.easing = easing || jQuery.easing._default;
-		this.options = options;
-		this.start = this.now = this.cur();
-		this.end = end;
-		this.unit = unit || ( jQuery.cssNumber[ prop ] ? "" : "px" );
-	},
-	cur: function() {
-		var hooks = Tween.propHooks[ this.prop ];
-
-		return hooks && hooks.get ?
-			hooks.get( this ) :
-			Tween.propHooks._default.get( this );
-	},
-	run: function( percent ) {
-		var eased,
-			hooks = Tween.propHooks[ this.prop ];
-
-		if ( this.options.duration ) {
-			this.pos = eased = jQuery.easing[ this.easing ](
-				percent, this.options.duration * percent, 0, 1, this.options.duration
-			);
-		} else {
-			this.pos = eased = percent;
-		}
-		this.now = ( this.end - this.start ) * eased + this.start;
-
-		if ( this.options.step ) {
-			this.options.step.call( this.elem, this.now, this );
-		}
-
-		if ( hooks && hooks.set ) {
-			hooks.set( this );
-		} else {
-			Tween.propHooks._default.set( this );
-		}
-		return this;
-	}
-};
-
-Tween.prototype.init.prototype = Tween.prototype;
-
-Tween.propHooks = {
-	_default: {
-		get: function( tween ) {
-			var result;
-
-			// Use a property on the element directly when it is not a DOM element,
-			// or when there is no matching style property that exists.
-			if ( tween.elem.nodeType !== 1 ||
-				tween.elem[ tween.prop ] != null && tween.elem.style[ tween.prop ] == null ) {
-				return tween.elem[ tween.prop ];
-			}
-
-			// Passing an empty string as a 3rd parameter to .css will automatically
-			// attempt a parseFloat and fallback to a string if the parse fails.
-			// Simple values such as "10px" are parsed to Float;
-			// complex values such as "rotate(1rad)" are returned as-is.
-			result = jQuery.css( tween.elem, tween.prop, "" );
-
-			// Empty strings, null, undefined and "auto" are converted to 0.
-			return !result || result === "auto" ? 0 : result;
-		},
-		set: function( tween ) {
-
-			// Use step hook for back compat.
-			// Use cssHook if its there.
-			// Use .style if available and use plain properties where available.
-			if ( jQuery.fx.step[ tween.prop ] ) {
-				jQuery.fx.step[ tween.prop ]( tween );
-			} else if ( tween.elem.nodeType === 1 &&
-				( tween.elem.style[ jQuery.cssProps[ tween.prop ] ] != null ||
-					jQuery.cssHooks[ tween.prop ] ) ) {
-				jQuery.style( tween.elem, tween.prop, tween.now + tween.unit );
-			} else {
-				tween.elem[ tween.prop ] = tween.now;
-			}
-		}
-	}
-};
-
-// Support: IE <=9 only
-// Panic based approach to setting things on disconnected nodes
-Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {
-	set: function( tween ) {
-		if ( tween.elem.nodeType && tween.elem.parentNode ) {
-			tween.elem[ tween.prop ] = tween.now;
-		}
-	}
-};
-
-jQuery.easing = {
-	linear: function( p ) {
-		return p;
-	},
-	swing: function( p ) {
-		return 0.5 - Math.cos( p * Math.PI ) / 2;
-	},
-	_default: "swing"
-};
-
-jQuery.fx = Tween.prototype.init;
-
-// Back compat <1.8 extension point
-jQuery.fx.step = {};
-
-
-
-
-var
-	fxNow, inProgress,
-	rfxtypes = /^(?:toggle|show|hide)$/,
-	rrun = /queueHooks$/;
-
-function schedule() {
-	if ( inProgress ) {
-		if ( document.hidden === false && window.requestAnimationFrame ) {
-			window.requestAnimationFrame( schedule );
-		} else {
-			window.setTimeout( schedule, jQuery.fx.interval );
-		}
-
-		jQuery.fx.tick();
-	}
-}
-
-// Animations created synchronously will run synchronously
-function createFxNow() {
-	window.setTimeout( function() {
-		fxNow = undefined;
-	} );
-	return ( fxNow = jQuery.now() );
-}
-
-// Generate parameters to create a standard animation
-function genFx( type, includeWidth ) {
-	var which,
-		i = 0,
-		attrs = { height: type };
-
-	// If we include width, step value is 1 to do all cssExpand values,
-	// otherwise step value is 2 to skip over Left and Right
-	includeWidth = includeWidth ? 1 : 0;
-	for ( ; i < 4; i += 2 - includeWidth ) {
-		which = cssExpand[ i ];
-		attrs[ "margin" + which ] = attrs[ "padding" + which ] = type;
-	}
-
-	if ( includeWidth ) {
-		attrs.opacity = attrs.width = type;
-	}
-
-	return attrs;
-}
-
-function createTween( value, prop, animation ) {
-	var tween,
-		collection = ( Animation.tweeners[ prop ] || [] ).concat( Animation.tweeners[ "*" ] ),
-		index = 0,
-		length = collection.length;
-	for ( ; index < length; index++ ) {
-		if ( ( tween = collection[ index ].call( animation, prop, value ) ) ) {
-
-			// We're done with this property
-			return tween;
-		}
-	}
-}
-
-function defaultPrefilter( elem, props, opts ) {
-	var prop, value, toggle, hooks, oldfire, propTween, restoreDisplay, display,
-		isBox = "width" in props || "height" in props,
-		anim = this,
-		orig = {},
-		style = elem.style,
-		hidden = elem.nodeType && isHiddenWithinTree( elem ),
-		dataShow = dataPriv.get( elem, "fxshow" );
-
-	// Queue-skipping animations hijack the fx hooks
-	if ( !opts.queue ) {
-		hooks = jQuery._queueHooks( elem, "fx" );
-		if ( hooks.unqueued == null ) {
-			hooks.unqueued = 0;
-			oldfire = hooks.empty.fire;
-			hooks.empty.fire = function() {
-				if ( !hooks.unqueued ) {
-					oldfire();
-				}
-			};
-		}
-		hooks.unqueued++;
-
-		anim.always( function() {
-
-			// Ensure the complete handler is called before this completes
-			anim.always( function() {
-				hooks.unqueued--;
-				if ( !jQuery.queue( elem, "fx" ).length ) {
-					hooks.empty.fire();
-				}
-			} );
-		} );
-	}
-
-	// Detect show/hide animations
-	for ( prop in props ) {
-		value = props[ prop ];
-		if ( rfxtypes.test( value ) ) {
-			delete props[ prop ];
-			toggle = toggle || value === "toggle";
-			if ( value === ( hidden ? "hide" : "show" ) ) {
-
-				// Pretend to be hidden if this is a "show" and
-				// there is still data from a stopped show/hide
-				if ( value === "show" && dataShow && dataShow[ prop ] !== undefined ) {
-					hidden = true;
-
-				// Ignore all other no-op show/hide data
-				} else {
-					continue;
-				}
-			}
-			orig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop );
-		}
-	}
-
-	// Bail out if this is a no-op like .hide().hide()
-	propTween = !jQuery.isEmptyObject( props );
-	if ( !propTween && jQuery.isEmptyObject( orig ) ) {
-		return;
-	}
-
-	// Restrict "overflow" and "display" styles during box animations
-	if ( isBox && elem.nodeType === 1 ) {
-
-		// Support: IE <=9 - 11, Edge 12 - 13
-		// Record all 3 overflow attributes because IE does not infer the shorthand
-		// from identically-valued overflowX and overflowY
-		opts.overflow = [ style.overflow, style.overflowX, style.overflowY ];
-
-		// Identify a display type, preferring old show/hide data over the CSS cascade
-		restoreDisplay = dataShow && dataShow.display;
-		if ( restoreDisplay == null ) {
-			restoreDisplay = dataPriv.get( elem, "display" );
-		}
-		display = jQuery.css( elem, "display" );
-		if ( display === "none" ) {
-			if ( restoreDisplay ) {
-				display = restoreDisplay;
-			} else {
-
-				// Get nonempty value(s) by temporarily forcing visibility
-				showHide( [ elem ], true );
-				restoreDisplay = elem.style.display || restoreDisplay;
-				display = jQuery.css( elem, "display" );
-				showHide( [ elem ] );
-			}
-		}
-
-		// Animate inline elements as inline-block
-		if ( display === "inline" || display === "inline-block" && restoreDisplay != null ) {
-			if ( jQuery.css( elem, "float" ) === "none" ) {
-
-				// Restore the original display value at the end of pure show/hide animations
-				if ( !propTween ) {
-					anim.done( function() {
-						style.display = restoreDisplay;
-					} );
-					if ( restoreDisplay == null ) {
-						display = style.display;
-						restoreDisplay = display === "none" ? "" : display;
-					}
-				}
-				style.display = "inline-block";
-			}
-		}
-	}
-
-	if ( opts.overflow ) {
-		style.overflow = "hidden";
-		anim.always( function() {
-			style.overflow = opts.overflow[ 0 ];
-			style.overflowX = opts.overflow[ 1 ];
-			style.overflowY = opts.overflow[ 2 ];
-		} );
-	}
-
-	// Implement show/hide animations
-	propTween = false;
-	for ( prop in orig ) {
-
-		// General show/hide setup for this element animation
-		if ( !propTween ) {
-			if ( dataShow ) {
-				if ( "hidden" in dataShow ) {
-					hidden = dataShow.hidden;
-				}
-			} else {
-				dataShow = dataPriv.access( elem, "fxshow", { display: restoreDisplay } );
-			}
-
-			// Store hidden/visible for toggle so `.stop().toggle()` "reverses"
-			if ( toggle ) {
-				dataShow.hidden = !hidden;
-			}
-
-			// Show elements before animating them
-			if ( hidden ) {
-				showHide( [ elem ], true );
-			}
-
-			/* eslint-disable no-loop-func */
-
-			anim.done( function() {
-
-			/* eslint-enable no-loop-func */
-
-				// The final step of a "hide" animation is actually hiding the element
-				if ( !hidden ) {
-					showHide( [ elem ] );
-				}
-				dataPriv.remove( elem, "fxshow" );
-				for ( prop in orig ) {
-					jQuery.style( elem, prop, orig[ prop ] );
-				}
-			} );
-		}
-
-		// Per-property setup
-		propTween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim );
-		if ( !( prop in dataShow ) ) {
-			dataShow[ prop ] = propTween.start;
-			if ( hidden ) {
-				propTween.end = propTween.start;
-				propTween.start = 0;
-			}
-		}
-	}
-}
-
-function propFilter( props, specialEasing ) {
-	var index, name, easing, value, hooks;
-
-	// camelCase, specialEasing and expand cssHook pass
-	for ( index in props ) {
-		name = jQuery.camelCase( index );
-		easing = specialEasing[ name ];
-		value = props[ index ];
-		if ( Array.isArray( value ) ) {
-			easing = value[ 1 ];
-			value = props[ index ] = value[ 0 ];
-		}
-
-		if ( index !== name ) {
-			props[ name ] = value;
-			delete props[ index ];
-		}
-
-		hooks = jQuery.cssHooks[ name ];
-		if ( hooks && "expand" in hooks ) {
-			value = hooks.expand( value );
-			delete props[ name ];
-
-			// Not quite $.extend, this won't overwrite existing keys.
-			// Reusing 'index' because we have the correct "name"
-			for ( index in value ) {
-				if ( !( index in props ) ) {
-					props[ index ] = value[ index ];
-					specialEasing[ index ] = easing;
-				}
-			}
-		} else {
-			specialEasing[ name ] = easing;
-		}
-	}
-}
-
-function Animation( elem, properties, options ) {
-	var result,
-		stopped,
-		index = 0,
-		length = Animation.prefilters.length,
-		deferred = jQuery.Deferred().always( function() {
-
-			// Don't match elem in the :animated selector
-			delete tick.elem;
-		} ),
-		tick = function() {
-			if ( stopped ) {
-				return false;
-			}
-			var currentTime = fxNow || createFxNow(),
-				remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ),
-
-				// Support: Android 2.3 only
-				// Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (#12497)
-				temp = remaining / animation.duration || 0,
-				percent = 1 - temp,
-				index = 0,
-				length = animation.tweens.length;
-
-			for ( ; index < length; index++ ) {
-				animation.tweens[ index ].run( percent );
-			}
-
-			deferred.notifyWith( elem, [ animation, percent, remaining ] );
-
-			// If there's more to do, yield
-			if ( percent < 1 && length ) {
-				return remaining;
-			}
-
-			// If this was an empty animation, synthesize a final progress notification
-			if ( !length ) {
-				deferred.notifyWith( elem, [ animation, 1, 0 ] );
-			}
-
-			// Resolve the animation and report its conclusion
-			deferred.resolveWith( elem, [ animation ] );
-			return false;
-		},
-		animation = deferred.promise( {
-			elem: elem,
-			props: jQuery.extend( {}, properties ),
-			opts: jQuery.extend( true, {
-				specialEasing: {},
-				easing: jQuery.easing._default
-			}, options ),
-			originalProperties: properties,
-			originalOptions: options,
-			startTime: fxNow || createFxNow(),
-			duration: options.duration,
-			tweens: [],
-			createTween: function( prop, end ) {
-				var tween = jQuery.Tween( elem, animation.opts, prop, end,
-						animation.opts.specialEasing[ prop ] || animation.opts.easing );
-				animation.tweens.push( tween );
-				return tween;
-			},
-			stop: function( gotoEnd ) {
-				var index = 0,
-
-					// If we are going to the end, we want to run all the tweens
-					// otherwise we skip this part
-					length = gotoEnd ? animation.tweens.length : 0;
-				if ( stopped ) {
-					return this;
-				}
-				stopped = true;
-				for ( ; index < length; index++ ) {
-					animation.tweens[ index ].run( 1 );
-				}
-
-				// Resolve when we played the last frame; otherwise, reject
-				if ( gotoEnd ) {
-					deferred.notifyWith( elem, [ animation, 1, 0 ] );
-					deferred.resolveWith( elem, [ animation, gotoEnd ] );
-				} else {
-					deferred.rejectWith( elem, [ animation, gotoEnd ] );
-				}
-				return this;
-			}
-		} ),
-		props = animation.props;
-
-	propFilter( props, animation.opts.specialEasing );
-
-	for ( ; index < length; index++ ) {
-		result = Animation.prefilters[ index ].call( animation, elem, props, animation.opts );
-		if ( result ) {
-			if ( jQuery.isFunction( result.stop ) ) {
-				jQuery._queueHooks( animation.elem, animation.opts.queue ).stop =
-					jQuery.proxy( result.stop, result );
-			}
-			return result;
-		}
-	}
-
-	jQuery.map( props, createTween, animation );
-
-	if ( jQuery.isFunction( animation.opts.start ) ) {
-		animation.opts.start.call( elem, animation );
-	}
-
-	// Attach callbacks from options
-	animation
-		.progress( animation.opts.progress )
-		.done( animation.opts.done, animation.opts.complete )
-		.fail( animation.opts.fail )
-		.always( animation.opts.always );
-
-	jQuery.fx.timer(
-		jQuery.extend( tick, {
-			elem: elem,
-			anim: animation,
-			queue: animation.opts.queue
-		} )
-	);
-
-	return animation;
-}
-
-jQuery.Animation = jQuery.extend( Animation, {
-
-	tweeners: {
-		"*": [ function( prop, value ) {
-			var tween = this.createTween( prop, value );
-			adjustCSS( tween.elem, prop, rcssNum.exec( value ), tween );
-			return tween;
-		} ]
-	},
-
-	tweener: function( props, callback ) {
-		if ( jQuery.isFunction( props ) ) {
-			callback = props;
-			props = [ "*" ];
-		} else {
-			props = props.match( rnothtmlwhite );
-		}
-
-		var prop,
-			index = 0,
-			length = props.length;
-
-		for ( ; index < length; index++ ) {
-			prop = props[ index ];
-			Animation.tweeners[ prop ] = Animation.tweeners[ prop ] || [];
-			Animation.tweeners[ prop ].unshift( callback );
-		}
-	},
-
-	prefilters: [ defaultPrefilter ],
-
-	prefilter: function( callback, prepend ) {
-		if ( prepend ) {
-			Animation.prefilters.unshift( callback );
-		} else {
-			Animation.prefilters.push( callback );
-		}
-	}
-} );
-
-jQuery.speed = function( speed, easing, fn ) {
-	var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : {
-		complete: fn || !fn && easing ||
-			jQuery.isFunction( speed ) && speed,
-		duration: speed,
-		easing: fn && easing || easing && !jQuery.isFunction( easing ) && easing
-	};
-
-	// Go to the end state if fx are off
-	if ( jQuery.fx.off ) {
-		opt.duration = 0;
-
-	} else {
-		if ( typeof opt.duration !== "number" ) {
-			if ( opt.duration in jQuery.fx.speeds ) {
-				opt.duration = jQuery.fx.speeds[ opt.duration ];
-
-			} else {
-				opt.duration = jQuery.fx.speeds._default;
-			}
-		}
-	}
-
-	// Normalize opt.queue - true/undefined/null -> "fx"
-	if ( opt.queue == null || opt.queue === true ) {
-		opt.queue = "fx";
-	}
-
-	// Queueing
-	opt.old = opt.complete;
-
-	opt.complete = function() {
-		if ( jQuery.isFunction( opt.old ) ) {
-			opt.old.call( this );
-		}
-
-		if ( opt.queue ) {
-			jQuery.dequeue( this, opt.queue );
-		}
-	};
-
-	return opt;
-};
-
-jQuery.fn.extend( {
-	fadeTo: function( speed, to, easing, callback ) {
-
-		// Show any hidden elements after setting opacity to 0
-		return this.filter( isHiddenWithinTree ).css( "opacity", 0 ).show()
-
-			// Animate to the value specified
-			.end().animate( { opacity: to }, speed, easing, callback );
-	},
-	animate: function( prop, speed, easing, callback ) {
-		var empty = jQuery.isEmptyObject( prop ),
-			optall = jQuery.speed( speed, easing, callback ),
-			doAnimation = function() {
-
-				// Operate on a copy of prop so per-property easing won't be lost
-				var anim = Animation( this, jQuery.extend( {}, prop ), optall );
-
-				// Empty animations, or finishing resolves immediately
-				if ( empty || dataPriv.get( this, "finish" ) ) {
-					anim.stop( true );
-				}
-			};
-			doAnimation.finish = doAnimation;
-
-		return empty || optall.queue === false ?
-			this.each( doAnimation ) :
-			this.queue( optall.queue, doAnimation );
-	},
-	stop: function( type, clearQueue, gotoEnd ) {
-		var stopQueue = function( hooks ) {
-			var stop = hooks.stop;
-			delete hooks.stop;
-			stop( gotoEnd );
-		};
-
-		if ( typeof type !== "string" ) {
-			gotoEnd = clearQueue;
-			clearQueue = type;
-			type = undefined;
-		}
-		if ( clearQueue && type !== false ) {
-			this.queue( type || "fx", [] );
-		}
-
-		return this.each( function() {
-			var dequeue = true,
-				index = type != null && type + "queueHooks",
-				timers = jQuery.timers,
-				data = dataPriv.get( this );
-
-			if ( index ) {
-				if ( data[ index ] && data[ index ].stop ) {
-					stopQueue( data[ index ] );
-				}
-			} else {
-				for ( index in data ) {
-					if ( data[ index ] && data[ index ].stop && rrun.test( index ) ) {
-						stopQueue( data[ index ] );
-					}
-				}
-			}
-
-			for ( index = timers.length; index--; ) {
-				if ( timers[ index ].elem === this &&
-					( type == null || timers[ index ].queue === type ) ) {
-
-					timers[ index ].anim.stop( gotoEnd );
-					dequeue = false;
-					timers.splice( index, 1 );
-				}
-			}
-
-			// Start the next in the queue if the last step wasn't forced.
-			// Timers currently will call their complete callbacks, which
-			// will dequeue but only if they were gotoEnd.
-			if ( dequeue || !gotoEnd ) {
-				jQuery.dequeue( this, type );
-			}
-		} );
-	},
-	finish: function( type ) {
-		if ( type !== false ) {
-			type = type || "fx";
-		}
-		return this.each( function() {
-			var index,
-				data = dataPriv.get( this ),
-				queue = data[ type + "queue" ],
-				hooks = data[ type + "queueHooks" ],
-				timers = jQuery.timers,
-				length = queue ? queue.length : 0;
-
-			// Enable finishing flag on private data
-			data.finish = true;
-
-			// Empty the queue first
-			jQuery.queue( this, type, [] );
-
-			if ( hooks && hooks.stop ) {
-				hooks.stop.call( this, true );
-			}
-
-			// Look for any active animations, and finish them
-			for ( index = timers.length; index--; ) {
-				if ( timers[ index ].elem === this && timers[ index ].queue === type ) {
-					timers[ index ].anim.stop( true );
-					timers.splice( index, 1 );
-				}
-			}
-
-			// Look for any animations in the old queue and finish them
-			for ( index = 0; index < length; index++ ) {
-				if ( queue[ index ] && queue[ index ].finish ) {
-					queue[ index ].finish.call( this );
-				}
-			}
-
-			// Turn off finishing flag
-			delete data.finish;
-		} );
-	}
-} );
-
-jQuery.each( [ "toggle", "show", "hide" ], function( i, name ) {
-	var cssFn = jQuery.fn[ name ];
-	jQuery.fn[ name ] = function( speed, easing, callback ) {
-		return speed == null || typeof speed === "boolean" ?
-			cssFn.apply( this, arguments ) :
-			this.animate( genFx( name, true ), speed, easing, callback );
-	};
-} );
-
-// Generate shortcuts for custom animations
-jQuery.each( {
-	slideDown: genFx( "show" ),
-	slideUp: genFx( "hide" ),
-	slideToggle: genFx( "toggle" ),
-	fadeIn: { opacity: "show" },
-	fadeOut: { opacity: "hide" },
-	fadeToggle: { opacity: "toggle" }
-}, function( name, props ) {
-	jQuery.fn[ name ] = function( speed, easing, callback ) {
-		return this.animate( props, speed, easing, callback );
-	};
-} );
-
-jQuery.timers = [];
-jQuery.fx.tick = function() {
-	var timer,
-		i = 0,
-		timers = jQuery.timers;
-
-	fxNow = jQuery.now();
-
-	for ( ; i < timers.length; i++ ) {
-		timer = timers[ i ];
-
-		// Run the timer and safely remove it when done (allowing for external removal)
-		if ( !timer() && timers[ i ] === timer ) {
-			timers.splice( i--, 1 );
-		}
-	}
-
-	if ( !timers.length ) {
-		jQuery.fx.stop();
-	}
-	fxNow = undefined;
-};
-
-jQuery.fx.timer = function( timer ) {
-	jQuery.timers.push( timer );
-	jQuery.fx.start();
-};
-
-jQuery.fx.interval = 13;
-jQuery.fx.start = function() {
-	if ( inProgress ) {
-		return;
-	}
-
-	inProgress = true;
-	schedule();
-};
-
-jQuery.fx.stop = function() {
-	inProgress = null;
-};
-
-jQuery.fx.speeds = {
-	slow: 600,
-	fast: 200,
-
-	// Default speed
-	_default: 400
-};
-
-
-// Based off of the plugin by Clint Helfers, with permission.
-// https://web.archive.org/web/20100324014747/https://blindsignals.com/index.php/2009/07/jquery-delay/
-jQuery.fn.delay = function( time, type ) {
-	time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;
-	type = type || "fx";
-
-	return this.queue( type, function( next, hooks ) {
-		var timeout = window.setTimeout( next, time );
-		hooks.stop = function() {
-			window.clearTimeout( timeout );
-		};
-	} );
-};
-
-
-( function() {
-	var input = document.createElement( "input" ),
-		select = document.createElement( "select" ),
-		opt = select.appendChild( document.createElement( "option" ) );
-
-	input.type = "checkbox";
-
-	// Support: Android <=4.3 only
-	// Default value for a checkbox should be "on"
-	support.checkOn = input.value !== "";
-
-	// Support: IE <=11 only
-	// Must access selectedIndex to make default options select
-	support.optSelected = opt.selected;
-
-	// Support: IE <=11 only
-	// An input loses its value after becoming a radio
-	input = document.createElement( "input" );
-	input.value = "t";
-	input.type = "radio";
-	support.radioValue = input.value === "t";
-} )();
-
-
-var boolHook,
-	attrHandle = jQuery.expr.attrHandle;
-
-jQuery.fn.extend( {
-	attr: function( name, value ) {
-		return access( this, jQuery.attr, name, value, arguments.length > 1 );
-	},
-
-	removeAttr: function( name ) {
-		return this.each( function() {
-			jQuery.removeAttr( this, name );
-		} );
-	}
-} );
-
-jQuery.extend( {
-	attr: function( elem, name, value ) {
-		var ret, hooks,
-			nType = elem.nodeType;
-
-		// Don't get/set attributes on text, comment and attribute nodes
-		if ( nType === 3 || nType === 8 || nType === 2 ) {
-			return;
-		}
-
-		// Fallback to prop when attributes are not supported
-		if ( typeof elem.getAttribute === "undefined" ) {
-			return jQuery.prop( elem, name, value );
-		}
-
-		// Attribute hooks are determined by the lowercase version
-		// Grab necessary hook if one is defined
-		if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {
-			hooks = jQuery.attrHooks[ name.toLowerCase() ] ||
-				( jQuery.expr.match.bool.test( name ) ? boolHook : undefined );
-		}
-
-		if ( value !== undefined ) {
-			if ( value === null ) {
-				jQuery.removeAttr( elem, name );
-				return;
-			}
-
-			if ( hooks && "set" in hooks &&
-				( ret = hooks.set( elem, value, name ) ) !== undefined ) {
-				return ret;
-			}
-
-			elem.setAttribute( name, value + "" );
-			return value;
-		}
-
-		if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {
-			return ret;
-		}
-
-		ret = jQuery.find.attr( elem, name );
-
-		// Non-existent attributes return null, we normalize to undefined
-		return ret == null ? undefined : ret;
-	},
-
-	attrHooks: {
-		type: {
-			set: function( elem, value ) {
-				if ( !support.radioValue && value === "radio" &&
-					nodeName( elem, "input" ) ) {
-					var val = elem.value;
-					elem.setAttribute( "type", value );
-					if ( val ) {
-						elem.value = val;
-					}
-					return value;
-				}
-			}
-		}
-	},
-
-	removeAttr: function( elem, value ) {
-		var name,
-			i = 0,
-
-			// Attribute names can contain non-HTML whitespace characters
-			// https://html.spec.whatwg.org/multipage/syntax.html#attributes-2
-			attrNames = value && value.match( rnothtmlwhite );
-
-		if ( attrNames && elem.nodeType === 1 ) {
-			while ( ( name = attrNames[ i++ ] ) ) {
-				elem.removeAttribute( name );
-			}
-		}
-	}
-} );
-
-// Hooks for boolean attributes
-boolHook = {
-	set: function( elem, value, name ) {
-		if ( value === false ) {
-
-			// Remove boolean attributes when set to false
-			jQuery.removeAttr( elem, name );
-		} else {
-			elem.setAttribute( name, name );
-		}
-		return name;
-	}
-};
-
-jQuery.each( jQuery.expr.match.bool.source.match( /\w+/g ), function( i, name ) {
-	var getter = attrHandle[ name ] || jQuery.find.attr;
-
-	attrHandle[ name ] = function( elem, name, isXML ) {
-		var ret, handle,
-			lowercaseName = name.toLowerCase();
-
-		if ( !isXML ) {
-
-			// Avoid an infinite loop by temporarily removing this function from the getter
-			handle = attrHandle[ lowercaseName ];
-			attrHandle[ lowercaseName ] = ret;
-			ret = getter( elem, name, isXML ) != null ?
-				lowercaseName :
-				null;
-			attrHandle[ lowercaseName ] = handle;
-		}
-		return ret;
-	};
-} );
-
-
-
-
-var rfocusable = /^(?:input|select|textarea|button)$/i,
-	rclickable = /^(?:a|area)$/i;
-
-jQuery.fn.extend( {
-	prop: function( name, value ) {
-		return access( this, jQuery.prop, name, value, arguments.length > 1 );
-	},
-
-	removeProp: function( name ) {
-		return this.each( function() {
-			delete this[ jQuery.propFix[ name ] || name ];
-		} );
-	}
-} );
-
-jQuery.extend( {
-	prop: function( elem, name, value ) {
-		var ret, hooks,
-			nType = elem.nodeType;
-
-		// Don't get/set properties on text, comment and attribute nodes
-		if ( nType === 3 || nType === 8 || nType === 2 ) {
-			return;
-		}
-
-		if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {
-
-			// Fix name and attach hooks
-			name = jQuery.propFix[ name ] || name;
-			hooks = jQuery.propHooks[ name ];
-		}
-
-		if ( value !== undefined ) {
-			if ( hooks && "set" in hooks &&
-				( ret = hooks.set( elem, value, name ) ) !== undefined ) {
-				return ret;
-			}
-
-			return ( elem[ name ] = value );
-		}
-
-		if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {
-			return ret;
-		}
-
-		return elem[ name ];
-	},
-
-	propHooks: {
-		tabIndex: {
-			get: function( elem ) {
-
-				// Support: IE <=9 - 11 only
-				// elem.tabIndex doesn't always return the
-				// correct value when it hasn't been explicitly set
-				// https://web.archive.org/web/20141116233347/https://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
-				// Use proper attribute retrieval(#12072)
-				var tabindex = jQuery.find.attr( elem, "tabindex" );
-
-				if ( tabindex ) {
-					return parseInt( tabindex, 10 );
-				}
-
-				if (
-					rfocusable.test( elem.nodeName ) ||
-					rclickable.test( elem.nodeName ) &&
-					elem.href
-				) {
-					return 0;
-				}
-
-				return -1;
-			}
-		}
-	},
-
-	propFix: {
-		"for": "htmlFor",
-		"class": "className"
-	}
-} );
-
-// Support: IE <=11 only
-// Accessing the selectedIndex property
-// forces the browser to respect setting selected
-// on the option
-// The getter ensures a default option is selected
-// when in an optgroup
-// eslint rule "no-unused-expressions" is disabled for this code
-// since it considers such accessions noop
-if ( !support.optSelected ) {
-	jQuery.propHooks.selected = {
-		get: function( elem ) {
-
-			/* eslint no-unused-expressions: "off" */
-
-			var parent = elem.parentNode;
-			if ( parent && parent.parentNode ) {
-				parent.parentNode.selectedIndex;
-			}
-			return null;
-		},
-		set: function( elem ) {
-
-			/* eslint no-unused-expressions: "off" */
-
-			var parent = elem.parentNode;
-			if ( parent ) {
-				parent.selectedIndex;
-
-				if ( parent.parentNode ) {
-					parent.parentNode.selectedIndex;
-				}
-			}
-		}
-	};
-}
-
-jQuery.each( [
-	"tabIndex",
-	"readOnly",
-	"maxLength",
-	"cellSpacing",
-	"cellPadding",
-	"rowSpan",
-	"colSpan",
-	"useMap",
-	"frameBorder",
-	"contentEditable"
-], function() {
-	jQuery.propFix[ this.toLowerCase() ] = this;
-} );
-
-
-
-
-	// Strip and collapse whitespace according to HTML spec
-	// https://html.spec.whatwg.org/multipage/infrastructure.html#strip-and-collapse-whitespace
-	function stripAndCollapse( value ) {
-		var tokens = value.match( rnothtmlwhite ) || [];
-		return tokens.join( " " );
-	}
-
-
-function getClass( elem ) {
-	return elem.getAttribute && elem.getAttribute( "class" ) || "";
-}
-
-jQuery.fn.extend( {
-	addClass: function( value ) {
-		var classes, elem, cur, curValue, clazz, j, finalValue,
-			i = 0;
-
-		if ( jQuery.isFunction( value ) ) {
-			return this.each( function( j ) {
-				jQuery( this ).addClass( value.call( this, j, getClass( this ) ) );
-			} );
-		}
-
-		if ( typeof value === "string" && value ) {
-			classes = value.match( rnothtmlwhite ) || [];
-
-			while ( ( elem = this[ i++ ] ) ) {
-				curValue = getClass( elem );
-				cur = elem.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " );
-
-				if ( cur ) {
-					j = 0;
-					while ( ( clazz = classes[ j++ ] ) ) {
-						if ( cur.indexOf( " " + clazz + " " ) < 0 ) {
-							cur += clazz + " ";
-						}
-					}
-
-					// Only assign if different to avoid unneeded rendering.
-					finalValue = stripAndCollapse( cur );
-					if ( curValue !== finalValue ) {
-						elem.setAttribute( "class", finalValue );
-					}
-				}
-			}
-		}
-
-		return this;
-	},
-
-	removeClass: function( value ) {
-		var classes, elem, cur, curValue, clazz, j, finalValue,
-			i = 0;
-
-		if ( jQuery.isFunction( value ) ) {
-			return this.each( function( j ) {
-				jQuery( this ).removeClass( value.call( this, j, getClass( this ) ) );
-			} );
-		}
-
-		if ( !arguments.length ) {
-			return this.attr( "class", "" );
-		}
-
-		if ( typeof value === "string" && value ) {
-			classes = value.match( rnothtmlwhite ) || [];
-
-			while ( ( elem = this[ i++ ] ) ) {
-				curValue = getClass( elem );
-
-				// This expression is here for better compressibility (see addClass)
-				cur = elem.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " );
-
-				if ( cur ) {
-					j = 0;
-					while ( ( clazz = classes[ j++ ] ) ) {
-
-						// Remove *all* instances
-						while ( cur.indexOf( " " + clazz + " " ) > -1 ) {
-							cur = cur.replace( " " + clazz + " ", " " );
-						}
-					}
-
-					// Only assign if different to avoid unneeded rendering.
-					finalValue = stripAndCollapse( cur );
-					if ( curValue !== finalValue ) {
-						elem.setAttribute( "class", finalValue );
-					}
-				}
-			}
-		}
-
-		return this;
-	},
-
-	toggleClass: function( value, stateVal ) {
-		var type = typeof value;
-
-		if ( typeof stateVal === "boolean" && type === "string" ) {
-			return stateVal ? this.addClass( value ) : this.removeClass( value );
-		}
-
-		if ( jQuery.isFunction( value ) ) {
-			return this.each( function( i ) {
-				jQuery( this ).toggleClass(
-					value.call( this, i, getClass( this ), stateVal ),
-					stateVal
-				);
-			} );
-		}
-
-		return this.each( function() {
-			var className, i, self, classNames;
-
-			if ( type === "string" ) {
-
-				// Toggle individual class names
-				i = 0;
-				self = jQuery( this );
-				classNames = value.match( rnothtmlwhite ) || [];
-
-				while ( ( className = classNames[ i++ ] ) ) {
-
-					// Check each className given, space separated list
-					if ( self.hasClass( className ) ) {
-						self.removeClass( className );
-					} else {
-						self.addClass( className );
-					}
-				}
-
-			// Toggle whole class name
-			} else if ( value === undefined || type === "boolean" ) {
-				className = getClass( this );
-				if ( className ) {
-
-					// Store className if set
-					dataPriv.set( this, "__className__", className );
-				}
-
-				// If the element has a class name or if we're passed `false`,
-				// then remove the whole classname (if there was one, the above saved it).
-				// Otherwise bring back whatever was previously saved (if anything),
-				// falling back to the empty string if nothing was stored.
-				if ( this.setAttribute ) {
-					this.setAttribute( "class",
-						className || value === false ?
-						"" :
-						dataPriv.get( this, "__className__" ) || ""
-					);
-				}
-			}
-		} );
-	},
-
-	hasClass: function( selector ) {
-		var className, elem,
-			i = 0;
-
-		className = " " + selector + " ";
-		while ( ( elem = this[ i++ ] ) ) {
-			if ( elem.nodeType === 1 &&
-				( " " + stripAndCollapse( getClass( elem ) ) + " " ).indexOf( className ) > -1 ) {
-					return true;
-			}
-		}
-
-		return false;
-	}
-} );
-
-
-
-
-var rreturn = /\r/g;
-
-jQuery.fn.extend( {
-	val: function( value ) {
-		var hooks, ret, isFunction,
-			elem = this[ 0 ];
-
-		if ( !arguments.length ) {
-			if ( elem ) {
-				hooks = jQuery.valHooks[ elem.type ] ||
-					jQuery.valHooks[ elem.nodeName.toLowerCase() ];
-
-				if ( hooks &&
-					"get" in hooks &&
-					( ret = hooks.get( elem, "value" ) ) !== undefined
-				) {
-					return ret;
-				}
-
-				ret = elem.value;
-
-				// Handle most common string cases
-				if ( typeof ret === "string" ) {
-					return ret.replace( rreturn, "" );
-				}
-
-				// Handle cases where value is null/undef or number
-				return ret == null ? "" : ret;
-			}
-
-			return;
-		}
-
-		isFunction = jQuery.isFunction( value );
-
-		return this.each( function( i ) {
-			var val;
-
-			if ( this.nodeType !== 1 ) {
-				return;
-			}
-
-			if ( isFunction ) {
-				val = value.call( this, i, jQuery( this ).val() );
-			} else {
-				val = value;
-			}
-
-			// Treat null/undefined as ""; convert numbers to string
-			if ( val == null ) {
-				val = "";
-
-			} else if ( typeof val === "number" ) {
-				val += "";
-
-			} else if ( Array.isArray( val ) ) {
-				val = jQuery.map( val, function( value ) {
-					return value == null ? "" : value + "";
-				} );
-			}
-
-			hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ];
-
-			// If set returns undefined, fall back to normal setting
-			if ( !hooks || !( "set" in hooks ) || hooks.set( this, val, "value" ) === undefined ) {
-				this.value = val;
-			}
-		} );
-	}
-} );
-
-jQuery.extend( {
-	valHooks: {
-		option: {
-			get: function( elem ) {
-
-				var val = jQuery.find.attr( elem, "value" );
-				return val != null ?
-					val :
-
-					// Support: IE <=10 - 11 only
-					// option.text throws exceptions (#14686, #14858)
-					// Strip and collapse whitespace
-					// https://html.spec.whatwg.org/#strip-and-collapse-whitespace
-					stripAndCollapse( jQuery.text( elem ) );
-			}
-		},
-		select: {
-			get: function( elem ) {
-				var value, option, i,
-					options = elem.options,
-					index = elem.selectedIndex,
-					one = elem.type === "select-one",
-					values = one ? null : [],
-					max = one ? index + 1 : options.length;
-
-				if ( index < 0 ) {
-					i = max;
-
-				} else {
-					i = one ? index : 0;
-				}
-
-				// Loop through all the selected options
-				for ( ; i < max; i++ ) {
-					option = options[ i ];
-
-					// Support: IE <=9 only
-					// IE8-9 doesn't update selected after form reset (#2551)
-					if ( ( option.selected || i === index ) &&
-
-							// Don't return options that are disabled or in a disabled optgroup
-							!option.disabled &&
-							( !option.parentNode.disabled ||
-								!nodeName( option.parentNode, "optgroup" ) ) ) {
-
-						// Get the specific value for the option
-						value = jQuery( option ).val();
-
-						// We don't need an array for one selects
-						if ( one ) {
-							return value;
-						}
-
-						// Multi-Selects return an array
-						values.push( value );
-					}
-				}
-
-				return values;
-			},
-
-			set: function( elem, value ) {
-				var optionSet, option,
-					options = elem.options,
-					values = jQuery.makeArray( value ),
-					i = options.length;
-
-				while ( i-- ) {
-					option = options[ i ];
-
-					/* eslint-disable no-cond-assign */
-
-					if ( option.selected =
-						jQuery.inArray( jQuery.valHooks.option.get( option ), values ) > -1
-					) {
-						optionSet = true;
-					}
-
-					/* eslint-enable no-cond-assign */
-				}
-
-				// Force browsers to behave consistently when non-matching value is set
-				if ( !optionSet ) {
-					elem.selectedIndex = -1;
-				}
-				return values;
-			}
-		}
-	}
-} );
-
-// Radios and checkboxes getter/setter
-jQuery.each( [ "radio", "checkbox" ], function() {
-	jQuery.valHooks[ this ] = {
-		set: function( elem, value ) {
-			if ( Array.isArray( value ) ) {
-				return ( elem.checked = jQuery.inArray( jQuery( elem ).val(), value ) > -1 );
-			}
-		}
-	};
-	if ( !support.checkOn ) {
-		jQuery.valHooks[ this ].get = function( elem ) {
-			return elem.getAttribute( "value" ) === null ? "on" : elem.value;
-		};
-	}
-} );
-
-
-
-
-// Return jQuery for attributes-only inclusion
-
-
-var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/;
-
-jQuery.extend( jQuery.event, {
-
-	trigger: function( event, data, elem, onlyHandlers ) {
-
-		var i, cur, tmp, bubbleType, ontype, handle, special,
-			eventPath = [ elem || document ],
-			type = hasOwn.call( event, "type" ) ? event.type : event,
-			namespaces = hasOwn.call( event, "namespace" ) ? event.namespace.split( "." ) : [];
-
-		cur = tmp = elem = elem || document;
-
-		// Don't do events on text and comment nodes
-		if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
-			return;
-		}
-
-		// focus/blur morphs to focusin/out; ensure we're not firing them right now
-		if ( rfocusMorph.test( type + jQuery.event.triggered ) ) {
-			return;
-		}
-
-		if ( type.indexOf( "." ) > -1 ) {
-
-			// Namespaced trigger; create a regexp to match event type in handle()
-			namespaces = type.split( "." );
-			type = namespaces.shift();
-			namespaces.sort();
-		}
-		ontype = type.indexOf( ":" ) < 0 && "on" + type;
-
-		// Caller can pass in a jQuery.Event object, Object, or just an event type string
-		event = event[ jQuery.expando ] ?
-			event :
-			new jQuery.Event( type, typeof event === "object" && event );
-
-		// Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true)
-		event.isTrigger = onlyHandlers ? 2 : 3;
-		event.namespace = namespaces.join( "." );
-		event.rnamespace = event.namespace ?
-			new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" ) :
-			null;
-
-		// Clean up the event in case it is being reused
-		event.result = undefined;
-		if ( !event.target ) {
-			event.target = elem;
-		}
-
-		// Clone any incoming data and prepend the event, creating the handler arg list
-		data = data == null ?
-			[ event ] :
-			jQuery.makeArray( data, [ event ] );
-
-		// Allow special events to draw outside the lines
-		special = jQuery.event.special[ type ] || {};
-		if ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) {
-			return;
-		}
-
-		// Determine event propagation path in advance, per W3C events spec (#9951)
-		// Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
-		if ( !onlyHandlers && !special.noBubble && !jQuery.isWindow( elem ) ) {
-
-			bubbleType = special.delegateType || type;
-			if ( !rfocusMorph.test( bubbleType + type ) ) {
-				cur = cur.parentNode;
-			}
-			for ( ; cur; cur = cur.parentNode ) {
-				eventPath.push( cur );
-				tmp = cur;
-			}
-
-			// Only add window if we got to document (e.g., not plain obj or detached DOM)
-			if ( tmp === ( elem.ownerDocument || document ) ) {
-				eventPath.push( tmp.defaultView || tmp.parentWindow || window );
-			}
-		}
-
-		// Fire handlers on the event path
-		i = 0;
-		while ( ( cur = eventPath[ i++ ] ) && !event.isPropagationStopped() ) {
-
-			event.type = i > 1 ?
-				bubbleType :
-				special.bindType || type;
-
-			// jQuery handler
-			handle = ( dataPriv.get( cur, "events" ) || {} )[ event.type ] &&
-				dataPriv.get( cur, "handle" );
-			if ( handle ) {
-				handle.apply( cur, data );
-			}
-
-			// Native handler
-			handle = ontype && cur[ ontype ];
-			if ( handle && handle.apply && acceptData( cur ) ) {
-				event.result = handle.apply( cur, data );
-				if ( event.result === false ) {
-					event.preventDefault();
-				}
-			}
-		}
-		event.type = type;
-
-		// If nobody prevented the default action, do it now
-		if ( !onlyHandlers && !event.isDefaultPrevented() ) {
-
-			if ( ( !special._default ||
-				special._default.apply( eventPath.pop(), data ) === false ) &&
-				acceptData( elem ) ) {
-
-				// Call a native DOM method on the target with the same name as the event.
-				// Don't do default actions on window, that's where global variables be (#6170)
-				if ( ontype && jQuery.isFunction( elem[ type ] ) && !jQuery.isWindow( elem ) ) {
-
-					// Don't re-trigger an onFOO event when we call its FOO() method
-					tmp = elem[ ontype ];
-
-					if ( tmp ) {
-						elem[ ontype ] = null;
-					}
-
-					// Prevent re-triggering of the same event, since we already bubbled it above
-					jQuery.event.triggered = type;
-					elem[ type ]();
-					jQuery.event.triggered = undefined;
-
-					if ( tmp ) {
-						elem[ ontype ] = tmp;
-					}
-				}
-			}
-		}
-
-		return event.result;
-	},
-
-	// Piggyback on a donor event to simulate a different one
-	// Used only for `focus(in | out)` events
-	simulate: function( type, elem, event ) {
-		var e = jQuery.extend(
-			new jQuery.Event(),
-			event,
-			{
-				type: type,
-				isSimulated: true
-			}
-		);
-
-		jQuery.event.trigger( e, null, elem );
-	}
-
-} );
-
-jQuery.fn.extend( {
-
-	trigger: function( type, data ) {
-		return this.each( function() {
-			jQuery.event.trigger( type, data, this );
-		} );
-	},
-	triggerHandler: function( type, data ) {
-		var elem = this[ 0 ];
-		if ( elem ) {
-			return jQuery.event.trigger( type, data, elem, true );
-		}
-	}
-} );
-
-
-jQuery.each( ( "blur focus focusin focusout resize scroll click dblclick " +
-	"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
-	"change select submit keydown keypress keyup contextmenu" ).split( " " ),
-	function( i, name ) {
-
-	// Handle event binding
-	jQuery.fn[ name ] = function( data, fn ) {
-		return arguments.length > 0 ?
-			this.on( name, null, data, fn ) :
-			this.trigger( name );
-	};
-} );
-
-jQuery.fn.extend( {
-	hover: function( fnOver, fnOut ) {
-		return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
-	}
-} );
-
-
-
-
-support.focusin = "onfocusin" in window;
-
-
-// Support: Firefox <=44
-// Firefox doesn't have focus(in | out) events
-// Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787
-//
-// Support: Chrome <=48 - 49, Safari <=9.0 - 9.1
-// focus(in | out) events fire after focus & blur events,
-// which is spec violation - https://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order
-// Related ticket - https://bugs.chromium.org/p/chromium/issues/detail?id=449857
-if ( !support.focusin ) {
-	jQuery.each( { focus: "focusin", blur: "focusout" }, function( orig, fix ) {
-
-		// Attach a single capturing handler on the document while someone wants focusin/focusout
-		var handler = function( event ) {
-			jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ) );
-		};
-
-		jQuery.event.special[ fix ] = {
-			setup: function() {
-				var doc = this.ownerDocument || this,
-					attaches = dataPriv.access( doc, fix );
-
-				if ( !attaches ) {
-					doc.addEventListener( orig, handler, true );
-				}
-				dataPriv.access( doc, fix, ( attaches || 0 ) + 1 );
-			},
-			teardown: function() {
-				var doc = this.ownerDocument || this,
-					attaches = dataPriv.access( doc, fix ) - 1;
-
-				if ( !attaches ) {
-					doc.removeEventListener( orig, handler, true );
-					dataPriv.remove( doc, fix );
-
-				} else {
-					dataPriv.access( doc, fix, attaches );
-				}
-			}
-		};
-	} );
-}
-var location = window.location;
-
-var nonce = jQuery.now();
-
-var rquery = ( /\?/ );
-
-
-
-// Cross-browser xml parsing
-jQuery.parseXML = function( data ) {
-	var xml;
-	if ( !data || typeof data !== "string" ) {
-		return null;
-	}
-
-	// Support: IE 9 - 11 only
-	// IE throws on parseFromString with invalid input.
-	try {
-		xml = ( new window.DOMParser() ).parseFromString( data, "text/xml" );
-	} catch ( e ) {
-		xml = undefined;
-	}
-
-	if ( !xml || xml.getElementsByTagName( "parsererror" ).length ) {
-		jQuery.error( "Invalid XML: " + data );
-	}
-	return xml;
-};
-
-
-var
-	rbracket = /\[\]$/,
-	rCRLF = /\r?\n/g,
-	rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i,
-	rsubmittable = /^(?:input|select|textarea|keygen)/i;
-
-function buildParams( prefix, obj, traditional, add ) {
-	var name;
-
-	if ( Array.isArray( obj ) ) {
-
-		// Serialize array item.
-		jQuery.each( obj, function( i, v ) {
-			if ( traditional || rbracket.test( prefix ) ) {
-
-				// Treat each array item as a scalar.
-				add( prefix, v );
-
-			} else {
-
-				// Item is non-scalar (array or object), encode its numeric index.
-				buildParams(
-					prefix + "[" + ( typeof v === "object" && v != null ? i : "" ) + "]",
-					v,
-					traditional,
-					add
-				);
-			}
-		} );
-
-	} else if ( !traditional && jQuery.type( obj ) === "object" ) {
-
-		// Serialize object item.
-		for ( name in obj ) {
-			buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add );
-		}
-
-	} else {
-
-		// Serialize scalar item.
-		add( prefix, obj );
-	}
-}
-
-// Serialize an array of form elements or a set of
-// key/values into a query string
-jQuery.param = function( a, traditional ) {
-	var prefix,
-		s = [],
-		add = function( key, valueOrFunction ) {
-
-			// If value is a function, invoke it and use its return value
-			var value = jQuery.isFunction( valueOrFunction ) ?
-				valueOrFunction() :
-				valueOrFunction;
-
-			s[ s.length ] = encodeURIComponent( key ) + "=" +
-				encodeURIComponent( value == null ? "" : value );
-		};
-
-	// If an array was passed in, assume that it is an array of form elements.
-	if ( Array.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) {
-
-		// Serialize the form elements
-		jQuery.each( a, function() {
-			add( this.name, this.value );
-		} );
-
-	} else {
-
-		// If traditional, encode the "old" way (the way 1.3.2 or older
-		// did it), otherwise encode params recursively.
-		for ( prefix in a ) {
-			buildParams( prefix, a[ prefix ], traditional, add );
-		}
-	}
-
-	// Return the resulting serialization
-	return s.join( "&" );
-};
-
-jQuery.fn.extend( {
-	serialize: function() {
-		return jQuery.param( this.serializeArray() );
-	},
-	serializeArray: function() {
-		return this.map( function() {
-
-			// Can add propHook for "elements" to filter or add form elements
-			var elements = jQuery.prop( this, "elements" );
-			return elements ? jQuery.makeArray( elements ) : this;
-		} )
-		.filter( function() {
-			var type = this.type;
-
-			// Use .is( ":disabled" ) so that fieldset[disabled] works
-			return this.name && !jQuery( this ).is( ":disabled" ) &&
-				rsubmittable.test( this.nodeName ) && !rsubmitterTypes.test( type ) &&
-				( this.checked || !rcheckableType.test( type ) );
-		} )
-		.map( function( i, elem ) {
-			var val = jQuery( this ).val();
-
-			if ( val == null ) {
-				return null;
-			}
-
-			if ( Array.isArray( val ) ) {
-				return jQuery.map( val, function( val ) {
-					return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
-				} );
-			}
-
-			return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
-		} ).get();
-	}
-} );
-
-
-var
-	r20 = /%20/g,
-	rhash = /#.*$/,
-	rantiCache = /([?&])_=[^&]*/,
-	rheaders = /^(.*?):[ \t]*([^\r\n]*)$/mg,
-
-	// #7653, #8125, #8152: local protocol detection
-	rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,
-	rnoContent = /^(?:GET|HEAD)$/,
-	rprotocol = /^\/\//,
-
-	/* Prefilters
-	 * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
-	 * 2) These are called:
-	 *    - BEFORE asking for a transport
-	 *    - AFTER param serialization (s.data is a string if s.processData is true)
-	 * 3) key is the dataType
-	 * 4) the catchall symbol "*" can be used
-	 * 5) execution will start with transport dataType and THEN continue down to "*" if needed
-	 */
-	prefilters = {},
-
-	/* Transports bindings
-	 * 1) key is the dataType
-	 * 2) the catchall symbol "*" can be used
-	 * 3) selection will start with transport dataType and THEN go to "*" if needed
-	 */
-	transports = {},
-
-	// Avoid comment-prolog char sequence (#10098); must appease lint and evade compression
-	allTypes = "*/".concat( "*" ),
-
-	// Anchor tag for parsing the document origin
-	originAnchor = document.createElement( "a" );
-	originAnchor.href = location.href;
-
-// Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
-function addToPrefiltersOrTransports( structure ) {
-
-	// dataTypeExpression is optional and defaults to "*"
-	return function( dataTypeExpression, func ) {
-
-		if ( typeof dataTypeExpression !== "string" ) {
-			func = dataTypeExpression;
-			dataTypeExpression = "*";
-		}
-
-		var dataType,
-			i = 0,
-			dataTypes = dataTypeExpression.toLowerCase().match( rnothtmlwhite ) || [];
-
-		if ( jQuery.isFunction( func ) ) {
-
-			// For each dataType in the dataTypeExpression
-			while ( ( dataType = dataTypes[ i++ ] ) ) {
-
-				// Prepend if requested
-				if ( dataType[ 0 ] === "+" ) {
-					dataType = dataType.slice( 1 ) || "*";
-					( structure[ dataType ] = structure[ dataType ] || [] ).unshift( func );
-
-				// Otherwise append
-				} else {
-					( structure[ dataType ] = structure[ dataType ] || [] ).push( func );
-				}
-			}
-		}
-	};
-}
-
-// Base inspection function for prefilters and transports
-function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) {
-
-	var inspected = {},
-		seekingTransport = ( structure === transports );
-
-	function inspect( dataType ) {
-		var selected;
-		inspected[ dataType ] = true;
-		jQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) {
-			var dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR );
-			if ( typeof dataTypeOrTransport === "string" &&
-				!seekingTransport && !inspected[ dataTypeOrTransport ] ) {
-
-				options.dataTypes.unshift( dataTypeOrTransport );
-				inspect( dataTypeOrTransport );
-				return false;
-			} else if ( seekingTransport ) {
-				return !( selected = dataTypeOrTransport );
-			}
-		} );
-		return selected;
-	}
-
-	return inspect( options.dataTypes[ 0 ] ) || !inspected[ "*" ] && inspect( "*" );
-}
-
-// A special extend for ajax options
-// that takes "flat" options (not to be deep extended)
-// Fixes #9887
-function ajaxExtend( target, src ) {
-	var key, deep,
-		flatOptions = jQuery.ajaxSettings.flatOptions || {};
-
-	for ( key in src ) {
-		if ( src[ key ] !== undefined ) {
-			( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ];
-		}
-	}
-	if ( deep ) {
-		jQuery.extend( true, target, deep );
-	}
-
-	return target;
-}
-
-/* Handles responses to an ajax request:
- * - finds the right dataType (mediates between content-type and expected dataType)
- * - returns the corresponding response
- */
-function ajaxHandleResponses( s, jqXHR, responses ) {
-
-	var ct, type, finalDataType, firstDataType,
-		contents = s.contents,
-		dataTypes = s.dataTypes;
-
-	// Remove auto dataType and get content-type in the process
-	while ( dataTypes[ 0 ] === "*" ) {
-		dataTypes.shift();
-		if ( ct === undefined ) {
-			ct = s.mimeType || jqXHR.getResponseHeader( "Content-Type" );
-		}
-	}
-
-	// Check if we're dealing with a known content-type
-	if ( ct ) {
-		for ( type in contents ) {
-			if ( contents[ type ] && contents[ type ].test( ct ) ) {
-				dataTypes.unshift( type );
-				break;
-			}
-		}
-	}
-
-	// Check to see if we have a response for the expected dataType
-	if ( dataTypes[ 0 ] in responses ) {
-		finalDataType = dataTypes[ 0 ];
-	} else {
-
-		// Try convertible dataTypes
-		for ( type in responses ) {
-			if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[ 0 ] ] ) {
-				finalDataType = type;
-				break;
-			}
-			if ( !firstDataType ) {
-				firstDataType = type;
-			}
-		}
-
-		// Or just use first one
-		finalDataType = finalDataType || firstDataType;
-	}
-
-	// If we found a dataType
-	// We add the dataType to the list if needed
-	// and return the corresponding response
-	if ( finalDataType ) {
-		if ( finalDataType !== dataTypes[ 0 ] ) {
-			dataTypes.unshift( finalDataType );
-		}
-		return responses[ finalDataType ];
-	}
-}
-
-/* Chain conversions given the request and the original response
- * Also sets the responseXXX fields on the jqXHR instance
- */
-function ajaxConvert( s, response, jqXHR, isSuccess ) {
-	var conv2, current, conv, tmp, prev,
-		converters = {},
-
-		// Work with a copy of dataTypes in case we need to modify it for conversion
-		dataTypes = s.dataTypes.slice();
-
-	// Create converters map with lowercased keys
-	if ( dataTypes[ 1 ] ) {
-		for ( conv in s.converters ) {
-			converters[ conv.toLowerCase() ] = s.converters[ conv ];
-		}
-	}
-
-	current = dataTypes.shift();
-
-	// Convert to each sequential dataType
-	while ( current ) {
-
-		if ( s.responseFields[ current ] ) {
-			jqXHR[ s.responseFields[ current ] ] = response;
-		}
-
-		// Apply the dataFilter if provided
-		if ( !prev && isSuccess && s.dataFilter ) {
-			response = s.dataFilter( response, s.dataType );
-		}
-
-		prev = current;
-		current = dataTypes.shift();
-
-		if ( current ) {
-
-			// There's only work to do if current dataType is non-auto
-			if ( current === "*" ) {
-
-				current = prev;
-
-			// Convert response if prev dataType is non-auto and differs from current
-			} else if ( prev !== "*" && prev !== current ) {
-
-				// Seek a direct converter
-				conv = converters[ prev + " " + current ] || converters[ "* " + current ];
-
-				// If none found, seek a pair
-				if ( !conv ) {
-					for ( conv2 in converters ) {
-
-						// If conv2 outputs current
-						tmp = conv2.split( " " );
-						if ( tmp[ 1 ] === current ) {
-
-							// If prev can be converted to accepted input
-							conv = converters[ prev + " " + tmp[ 0 ] ] ||
-								converters[ "* " + tmp[ 0 ] ];
-							if ( conv ) {
-
-								// Condense equivalence converters
-								if ( conv === true ) {
-									conv = converters[ conv2 ];
-
-								// Otherwise, insert the intermediate dataType
-								} else if ( converters[ conv2 ] !== true ) {
-									current = tmp[ 0 ];
-									dataTypes.unshift( tmp[ 1 ] );
-								}
-								break;
-							}
-						}
-					}
-				}
-
-				// Apply converter (if not an equivalence)
-				if ( conv !== true ) {
-
-					// Unless errors are allowed to bubble, catch and return them
-					if ( conv && s.throws ) {
-						response = conv( response );
-					} else {
-						try {
-							response = conv( response );
-						} catch ( e ) {
-							return {
-								state: "parsererror",
-								error: conv ? e : "No conversion from " + prev + " to " + current
-							};
-						}
-					}
-				}
-			}
-		}
-	}
-
-	return { state: "success", data: response };
-}
-
-jQuery.extend( {
-
-	// Counter for holding the number of active queries
-	active: 0,
-
-	// Last-Modified header cache for next request
-	lastModified: {},
-	etag: {},
-
-	ajaxSettings: {
-		url: location.href,
-		type: "GET",
-		isLocal: rlocalProtocol.test( location.protocol ),
-		global: true,
-		processData: true,
-		async: true,
-		contentType: "application/x-www-form-urlencoded; charset=UTF-8",
-
-		/*
-		timeout: 0,
-		data: null,
-		dataType: null,
-		username: null,
-		password: null,
-		cache: null,
-		throws: false,
-		traditional: false,
-		headers: {},
-		*/
-
-		accepts: {
-			"*": allTypes,
-			text: "text/plain",
-			html: "text/html",
-			xml: "application/xml, text/xml",
-			json: "application/json, text/javascript"
-		},
-
-		contents: {
-			xml: /\bxml\b/,
-			html: /\bhtml/,
-			json: /\bjson\b/
-		},
-
-		responseFields: {
-			xml: "responseXML",
-			text: "responseText",
-			json: "responseJSON"
-		},
-
-		// Data converters
-		// Keys separate source (or catchall "*") and destination types with a single space
-		converters: {
-
-			// Convert anything to text
-			"* text": String,
-
-			// Text to html (true = no transformation)
-			"text html": true,
-
-			// Evaluate text as a json expression
-			"text json": JSON.parse,
-
-			// Parse text as xml
-			"text xml": jQuery.parseXML
-		},
-
-		// For options that shouldn't be deep extended:
-		// you can add your own custom options here if
-		// and when you create one that shouldn't be
-		// deep extended (see ajaxExtend)
-		flatOptions: {
-			url: true,
-			context: true
-		}
-	},
-
-	// Creates a full fledged settings object into target
-	// with both ajaxSettings and settings fields.
-	// If target is omitted, writes into ajaxSettings.
-	ajaxSetup: function( target, settings ) {
-		return settings ?
-
-			// Building a settings object
-			ajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) :
-
-			// Extending ajaxSettings
-			ajaxExtend( jQuery.ajaxSettings, target );
-	},
-
-	ajaxPrefilter: addToPrefiltersOrTransports( prefilters ),
-	ajaxTransport: addToPrefiltersOrTransports( transports ),
-
-	// Main method
-	ajax: function( url, options ) {
-
-		// If url is an object, simulate pre-1.5 signature
-		if ( typeof url === "object" ) {
-			options = url;
-			url = undefined;
-		}
-
-		// Force options to be an object
-		options = options || {};
-
-		var transport,
-
-			// URL without anti-cache param
-			cacheURL,
-
-			// Response headers
-			responseHeadersString,
-			responseHeaders,
-
-			// timeout handle
-			timeoutTimer,
-
-			// Url cleanup var
-			urlAnchor,
-
-			// Request state (becomes false upon send and true upon completion)
-			completed,
-
-			// To know if global events are to be dispatched
-			fireGlobals,
-
-			// Loop variable
-			i,
-
-			// uncached part of the url
-			uncached,
-
-			// Create the final options object
-			s = jQuery.ajaxSetup( {}, options ),
-
-			// Callbacks context
-			callbackContext = s.context || s,
-
-			// Context for global events is callbackContext if it is a DOM node or jQuery collection
-			globalEventContext = s.context &&
-				( callbackContext.nodeType || callbackContext.jquery ) ?
-					jQuery( callbackContext ) :
-					jQuery.event,
-
-			// Deferreds
-			deferred = jQuery.Deferred(),
-			completeDeferred = jQuery.Callbacks( "once memory" ),
-
-			// Status-dependent callbacks
-			statusCode = s.statusCode || {},
-
-			// Headers (they are sent all at once)
-			requestHeaders = {},
-			requestHeadersNames = {},
-
-			// Default abort message
-			strAbort = "canceled",
-
-			// Fake xhr
-			jqXHR = {
-				readyState: 0,
-
-				// Builds headers hashtable if needed
-				getResponseHeader: function( key ) {
-					var match;
-					if ( completed ) {
-						if ( !responseHeaders ) {
-							responseHeaders = {};
-							while ( ( match = rheaders.exec( responseHeadersString ) ) ) {
-								responseHeaders[ match[ 1 ].toLowerCase() ] = match[ 2 ];
-							}
-						}
-						match = responseHeaders[ key.toLowerCase() ];
-					}
-					return match == null ? null : match;
-				},
-
-				// Raw string
-				getAllResponseHeaders: function() {
-					return completed ? responseHeadersString : null;
-				},
-
-				// Caches the header
-				setRequestHeader: function( name, value ) {
-					if ( completed == null ) {
-						name = requestHeadersNames[ name.toLowerCase() ] =
-							requestHeadersNames[ name.toLowerCase() ] || name;
-						requestHeaders[ name ] = value;
-					}
-					return this;
-				},
-
-				// Overrides response content-type header
-				overrideMimeType: function( type ) {
-					if ( completed == null ) {
-						s.mimeType = type;
-					}
-					return this;
-				},
-
-				// Status-dependent callbacks
-				statusCode: function( map ) {
-					var code;
-					if ( map ) {
-						if ( completed ) {
-
-							// Execute the appropriate callbacks
-							jqXHR.always( map[ jqXHR.status ] );
-						} else {
-
-							// Lazy-add the new callbacks in a way that preserves old ones
-							for ( code in map ) {
-								statusCode[ code ] = [ statusCode[ code ], map[ code ] ];
-							}
-						}
-					}
-					return this;
-				},
-
-				// Cancel the request
-				abort: function( statusText ) {
-					var finalText = statusText || strAbort;
-					if ( transport ) {
-						transport.abort( finalText );
-					}
-					done( 0, finalText );
-					return this;
-				}
-			};
-
-		// Attach deferreds
-		deferred.promise( jqXHR );
-
-		// Add protocol if not provided (prefilters might expect it)
-		// Handle falsy url in the settings object (#10093: consistency with old signature)
-		// We also use the url parameter if available
-		s.url = ( ( url || s.url || location.href ) + "" )
-			.replace( rprotocol, location.protocol + "//" );
-
-		// Alias method option to type as per ticket #12004
-		s.type = options.method || options.type || s.method || s.type;
-
-		// Extract dataTypes list
-		s.dataTypes = ( s.dataType || "*" ).toLowerCase().match( rnothtmlwhite ) || [ "" ];
-
-		// A cross-domain request is in order when the origin doesn't match the current origin.
-		if ( s.crossDomain == null ) {
-			urlAnchor = document.createElement( "a" );
-
-			// Support: IE <=8 - 11, Edge 12 - 13
-			// IE throws exception on accessing the href property if url is malformed,
-			// e.g. https://example.com:80x/
-			try {
-				urlAnchor.href = s.url;
-
-				// Support: IE <=8 - 11 only
-				// Anchor's host property isn't correctly set when s.url is relative
-				urlAnchor.href = urlAnchor.href;
-				s.crossDomain = originAnchor.protocol + "//" + originAnchor.host !==
-					urlAnchor.protocol + "//" + urlAnchor.host;
-			} catch ( e ) {
-
-				// If there is an error parsing the URL, assume it is crossDomain,
-				// it can be rejected by the transport if it is invalid
-				s.crossDomain = true;
-			}
-		}
-
-		// Convert data if not already a string
-		if ( s.data && s.processData && typeof s.data !== "string" ) {
-			s.data = jQuery.param( s.data, s.traditional );
-		}
-
-		// Apply prefilters
-		inspectPrefiltersOrTransports( prefilters, s, options, jqXHR );
-
-		// If request was aborted inside a prefilter, stop there
-		if ( completed ) {
-			return jqXHR;
-		}
-
-		// We can fire global events as of now if asked to
-		// Don't fire events if jQuery.event is undefined in an AMD-usage scenario (#15118)
-		fireGlobals = jQuery.event && s.global;
-
-		// Watch for a new set of requests
-		if ( fireGlobals && jQuery.active++ === 0 ) {
-			jQuery.event.trigger( "ajaxStart" );
-		}
-
-		// Uppercase the type
-		s.type = s.type.toUpperCase();
-
-		// Determine if request has content
-		s.hasContent = !rnoContent.test( s.type );
-
-		// Save the URL in case we're toying with the If-Modified-Since
-		// and/or If-None-Match header later on
-		// Remove hash to simplify url manipulation
-		cacheURL = s.url.replace( rhash, "" );
-
-		// More options handling for requests with no content
-		if ( !s.hasContent ) {
-
-			// Remember the hash so we can put it back
-			uncached = s.url.slice( cacheURL.length );
-
-			// If data is available, append data to url
-			if ( s.data ) {
-				cacheURL += ( rquery.test( cacheURL ) ? "&" : "?" ) + s.data;
-
-				// #9682: remove data so that it's not used in an eventual retry
-				delete s.data;
-			}
-
-			// Add or update anti-cache param if needed
-			if ( s.cache === false ) {
-				cacheURL = cacheURL.replace( rantiCache, "$1" );
-				uncached = ( rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + ( nonce++ ) + uncached;
-			}
-
-			// Put hash and anti-cache on the URL that will be requested (gh-1732)
-			s.url = cacheURL + uncached;
-
-		// Change '%20' to '+' if this is encoded form body content (gh-2658)
-		} else if ( s.data && s.processData &&
-			( s.contentType || "" ).indexOf( "application/x-www-form-urlencoded" ) === 0 ) {
-			s.data = s.data.replace( r20, "+" );
-		}
-
-		// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
-		if ( s.ifModified ) {
-			if ( jQuery.lastModified[ cacheURL ] ) {
-				jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ cacheURL ] );
-			}
-			if ( jQuery.etag[ cacheURL ] ) {
-				jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ cacheURL ] );
-			}
-		}
-
-		// Set the correct header, if data is being sent
-		if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {
-			jqXHR.setRequestHeader( "Content-Type", s.contentType );
-		}
-
-		// Set the Accepts header for the server, depending on the dataType
-		jqXHR.setRequestHeader(
-			"Accept",
-			s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[ 0 ] ] ?
-				s.accepts[ s.dataTypes[ 0 ] ] +
-					( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) :
-				s.accepts[ "*" ]
-		);
-
-		// Check for headers option
-		for ( i in s.headers ) {
-			jqXHR.setRequestHeader( i, s.headers[ i ] );
-		}
-
-		// Allow custom headers/mimetypes and early abort
-		if ( s.beforeSend &&
-			( s.beforeSend.call( callbackContext, jqXHR, s ) === false || completed ) ) {
-
-			// Abort if not done already and return
-			return jqXHR.abort();
-		}
-
-		// Aborting is no longer a cancellation
-		strAbort = "abort";
-
-		// Install callbacks on deferreds
-		completeDeferred.add( s.complete );
-		jqXHR.done( s.success );
-		jqXHR.fail( s.error );
-
-		// Get transport
-		transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );
-
-		// If no transport, we auto-abort
-		if ( !transport ) {
-			done( -1, "No Transport" );
-		} else {
-			jqXHR.readyState = 1;
-
-			// Send global event
-			if ( fireGlobals ) {
-				globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] );
-			}
-
-			// If request was aborted inside ajaxSend, stop there
-			if ( completed ) {
-				return jqXHR;
-			}
-
-			// Timeout
-			if ( s.async && s.timeout > 0 ) {
-				timeoutTimer = window.setTimeout( function() {
-					jqXHR.abort( "timeout" );
-				}, s.timeout );
-			}
-
-			try {
-				completed = false;
-				transport.send( requestHeaders, done );
-			} catch ( e ) {
-
-				// Rethrow post-completion exceptions
-				if ( completed ) {
-					throw e;
-				}
-
-				// Propagate others as results
-				done( -1, e );
-			}
-		}
-
-		// Callback for when everything is done
-		function done( status, nativeStatusText, responses, headers ) {
-			var isSuccess, success, error, response, modified,
-				statusText = nativeStatusText;
-
-			// Ignore repeat invocations
-			if ( completed ) {
-				return;
-			}
-
-			completed = true;
-
-			// Clear timeout if it exists
-			if ( timeoutTimer ) {
-				window.clearTimeout( timeoutTimer );
-			}
-
-			// Dereference transport for early garbage collection
-			// (no matter how long the jqXHR object will be used)
-			transport = undefined;
-
-			// Cache response headers
-			responseHeadersString = headers || "";
-
-			// Set readyState
-			jqXHR.readyState = status > 0 ? 4 : 0;
-
-			// Determine if successful
-			isSuccess = status >= 200 && status < 300 || status === 304;
-
-			// Get response data
-			if ( responses ) {
-				response = ajaxHandleResponses( s, jqXHR, responses );
-			}
-
-			// Convert no matter what (that way responseXXX fields are always set)
-			response = ajaxConvert( s, response, jqXHR, isSuccess );
-
-			// If successful, handle type chaining
-			if ( isSuccess ) {
-
-				// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
-				if ( s.ifModified ) {
-					modified = jqXHR.getResponseHeader( "Last-Modified" );
-					if ( modified ) {
-						jQuery.lastModified[ cacheURL ] = modified;
-					}
-					modified = jqXHR.getResponseHeader( "etag" );
-					if ( modified ) {
-						jQuery.etag[ cacheURL ] = modified;
-					}
-				}
-
-				// if no content
-				if ( status === 204 || s.type === "HEAD" ) {
-					statusText = "nocontent";
-
-				// if not modified
-				} else if ( status === 304 ) {
-					statusText = "notmodified";
-
-				// If we have data, let's convert it
-				} else {
-					statusText = response.state;
-					success = response.data;
-					error = response.error;
-					isSuccess = !error;
-				}
-			} else {
-
-				// Extract error from statusText and normalize for non-aborts
-				error = statusText;
-				if ( status || !statusText ) {
-					statusText = "error";
-					if ( status < 0 ) {
-						status = 0;
-					}
-				}
-			}
-
-			// Set data for the fake xhr object
-			jqXHR.status = status;
-			jqXHR.statusText = ( nativeStatusText || statusText ) + "";
-
-			// Success/Error
-			if ( isSuccess ) {
-				deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );
-			} else {
-				deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );
-			}
-
-			// Status-dependent callbacks
-			jqXHR.statusCode( statusCode );
-			statusCode = undefined;
-
-			if ( fireGlobals ) {
-				globalEventContext.trigger( isSuccess ? "ajaxSuccess" : "ajaxError",
-					[ jqXHR, s, isSuccess ? success : error ] );
-			}
-
-			// Complete
-			completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] );
-
-			if ( fireGlobals ) {
-				globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] );
-
-				// Handle the global AJAX counter
-				if ( !( --jQuery.active ) ) {
-					jQuery.event.trigger( "ajaxStop" );
-				}
-			}
-		}
-
-		return jqXHR;
-	},
-
-	getJSON: function( url, data, callback ) {
-		return jQuery.get( url, data, callback, "json" );
-	},
-
-	getScript: function( url, callback ) {
-		return jQuery.get( url, undefined, callback, "script" );
-	}
-} );
-
-jQuery.each( [ "get", "post" ], function( i, method ) {
-	jQuery[ method ] = function( url, data, callback, type ) {
-
-		// Shift arguments if data argument was omitted
-		if ( jQuery.isFunction( data ) ) {
-			type = type || callback;
-			callback = data;
-			data = undefined;
-		}
-
-		// The url can be an options object (which then must have .url)
-		return jQuery.ajax( jQuery.extend( {
-			url: url,
-			type: method,
-			dataType: type,
-			data: data,
-			success: callback
-		}, jQuery.isPlainObject( url ) && url ) );
-	};
-} );
-
-
-jQuery._evalUrl = function( url ) {
-	return jQuery.ajax( {
-		url: url,
-
-		// Make this explicit, since user can override this through ajaxSetup (#11264)
-		type: "GET",
-		dataType: "script",
-		cache: true,
-		async: false,
-		global: false,
-		"throws": true
-	} );
-};
-
-
-jQuery.fn.extend( {
-	wrapAll: function( html ) {
-		var wrap;
-
-		if ( this[ 0 ] ) {
-			if ( jQuery.isFunction( html ) ) {
-				html = html.call( this[ 0 ] );
-			}
-
-			// The elements to wrap the target around
-			wrap = jQuery( html, this[ 0 ].ownerDocument ).eq( 0 ).clone( true );
-
-			if ( this[ 0 ].parentNode ) {
-				wrap.insertBefore( this[ 0 ] );
-			}
-
-			wrap.map( function() {
-				var elem = this;
-
-				while ( elem.firstElementChild ) {
-					elem = elem.firstElementChild;
-				}
-
-				return elem;
-			} ).append( this );
-		}
-
-		return this;
-	},
-
-	wrapInner: function( html ) {
-		if ( jQuery.isFunction( html ) ) {
-			return this.each( function( i ) {
-				jQuery( this ).wrapInner( html.call( this, i ) );
-			} );
-		}
-
-		return this.each( function() {
-			var self = jQuery( this ),
-				contents = self.contents();
-
-			if ( contents.length ) {
-				contents.wrapAll( html );
-
-			} else {
-				self.append( html );
-			}
-		} );
-	},
-
-	wrap: function( html ) {
-		var isFunction = jQuery.isFunction( html );
-
-		return this.each( function( i ) {
-			jQuery( this ).wrapAll( isFunction ? html.call( this, i ) : html );
-		} );
-	},
-
-	unwrap: function( selector ) {
-		this.parent( selector ).not( "body" ).each( function() {
-			jQuery( this ).replaceWith( this.childNodes );
-		} );
-		return this;
-	}
-} );
-
-
-jQuery.expr.pseudos.hidden = function( elem ) {
-	return !jQuery.expr.pseudos.visible( elem );
-};
-jQuery.expr.pseudos.visible = function( elem ) {
-	return !!( elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length );
-};
-
-
-
-
-jQuery.ajaxSettings.xhr = function() {
-	try {
-		return new window.XMLHttpRequest();
-	} catch ( e ) {}
-};
-
-var xhrSuccessStatus = {
-
-		// File protocol always yields status code 0, assume 200
-		0: 200,
-
-		// Support: IE <=9 only
-		// #1450: sometimes IE returns 1223 when it should be 204
-		1223: 204
-	},
-	xhrSupported = jQuery.ajaxSettings.xhr();
-
-support.cors = !!xhrSupported && ( "withCredentials" in xhrSupported );
-support.ajax = xhrSupported = !!xhrSupported;
-
-jQuery.ajaxTransport( function( options ) {
-	var callback, errorCallback;
-
-	// Cross domain only allowed if supported through XMLHttpRequest
-	if ( support.cors || xhrSupported && !options.crossDomain ) {
-		return {
-			send: function( headers, complete ) {
-				var i,
-					xhr = options.xhr();
-
-				xhr.open(
-					options.type,
-					options.url,
-					options.async,
-					options.username,
-					options.password
-				);
-
-				// Apply custom fields if provided
-				if ( options.xhrFields ) {
-					for ( i in options.xhrFields ) {
-						xhr[ i ] = options.xhrFields[ i ];
-					}
-				}
-
-				// Override mime type if needed
-				if ( options.mimeType && xhr.overrideMimeType ) {
-					xhr.overrideMimeType( options.mimeType );
-				}
-
-				// X-Requested-With header
-				// For cross-domain requests, seeing as conditions for a preflight are
-				// akin to a jigsaw puzzle, we simply never set it to be sure.
-				// (it can always be set on a per-request basis or even using ajaxSetup)
-				// For same-domain requests, won't change header if already provided.
-				if ( !options.crossDomain && !headers[ "X-Requested-With" ] ) {
-					headers[ "X-Requested-With" ] = "XMLHttpRequest";
-				}
-
-				// Set headers
-				for ( i in headers ) {
-					xhr.setRequestHeader( i, headers[ i ] );
-				}
-
-				// Callback
-				callback = function( type ) {
-					return function() {
-						if ( callback ) {
-							callback = errorCallback = xhr.onload =
-								xhr.onerror = xhr.onabort = xhr.onreadystatechange = null;
-
-							if ( type === "abort" ) {
-								xhr.abort();
-							} else if ( type === "error" ) {
-
-								// Support: IE <=9 only
-								// On a manual native abort, IE9 throws
-								// errors on any property access that is not readyState
-								if ( typeof xhr.status !== "number" ) {
-									complete( 0, "error" );
-								} else {
-									complete(
-
-										// File: protocol always yields status 0; see #8605, #14207
-										xhr.status,
-										xhr.statusText
-									);
-								}
-							} else {
-								complete(
-									xhrSuccessStatus[ xhr.status ] || xhr.status,
-									xhr.statusText,
-
-									// Support: IE <=9 only
-									// IE9 has no XHR2 but throws on binary (trac-11426)
-									// For XHR2 non-text, let the caller handle it (gh-2498)
-									( xhr.responseType || "text" ) !== "text"  ||
-									typeof xhr.responseText !== "string" ?
-										{ binary: xhr.response } :
-										{ text: xhr.responseText },
-									xhr.getAllResponseHeaders()
-								);
-							}
-						}
-					};
-				};
-
-				// Listen to events
-				xhr.onload = callback();
-				errorCallback = xhr.onerror = callback( "error" );
-
-				// Support: IE 9 only
-				// Use onreadystatechange to replace onabort
-				// to handle uncaught aborts
-				if ( xhr.onabort !== undefined ) {
-					xhr.onabort = errorCallback;
-				} else {
-					xhr.onreadystatechange = function() {
-
-						// Check readyState before timeout as it changes
-						if ( xhr.readyState === 4 ) {
-
-							// Allow onerror to be called first,
-							// but that will not handle a native abort
-							// Also, save errorCallback to a variable
-							// as xhr.onerror cannot be accessed
-							window.setTimeout( function() {
-								if ( callback ) {
-									errorCallback();
-								}
-							} );
-						}
-					};
-				}
-
-				// Create the abort callback
-				callback = callback( "abort" );
-
-				try {
-
-					// Do send the request (this may raise an exception)
-					xhr.send( options.hasContent && options.data || null );
-				} catch ( e ) {
-
-					// #14683: Only rethrow if this hasn't been notified as an error yet
-					if ( callback ) {
-						throw e;
-					}
-				}
-			},
-
-			abort: function() {
-				if ( callback ) {
-					callback();
-				}
-			}
-		};
-	}
-} );
-
-
-
-
-// Prevent auto-execution of scripts when no explicit dataType was provided (See gh-2432)
-jQuery.ajaxPrefilter( function( s ) {
-	if ( s.crossDomain ) {
-		s.contents.script = false;
-	}
-} );
-
-// Install script dataType
-jQuery.ajaxSetup( {
-	accepts: {
-		script: "text/javascript, application/javascript, " +
-			"application/ecmascript, application/x-ecmascript"
-	},
-	contents: {
-		script: /\b(?:java|ecma)script\b/
-	},
-	converters: {
-		"text script": function( text ) {
-			jQuery.globalEval( text );
-			return text;
-		}
-	}
-} );
-
-// Handle cache's special case and crossDomain
-jQuery.ajaxPrefilter( "script", function( s ) {
-	if ( s.cache === undefined ) {
-		s.cache = false;
-	}
-	if ( s.crossDomain ) {
-		s.type = "GET";
-	}
-} );
-
-// Bind script tag hack transport
-jQuery.ajaxTransport( "script", function( s ) {
-
-	// This transport only deals with cross domain requests
-	if ( s.crossDomain ) {
-		var script, callback;
-		return {
-			send: function( _, complete ) {
-				script = jQuery( "<script>" ).prop( {
-					charset: s.scriptCharset,
-					src: s.url
-				} ).on(
-					"load error",
-					callback = function( evt ) {
-						script.remove();
-						callback = null;
-						if ( evt ) {
-							complete( evt.type === "error" ? 404 : 200, evt.type );
-						}
-					}
-				);
-
-				// Use native DOM manipulation to avoid our domManip AJAX trickery
-				document.head.appendChild( script[ 0 ] );
-			},
-			abort: function() {
-				if ( callback ) {
-					callback();
-				}
-			}
-		};
-	}
-} );
-
-
-
-
-var oldCallbacks = [],
-	rjsonp = /(=)\?(?=&|$)|\?\?/;
-
-// Default jsonp settings
-jQuery.ajaxSetup( {
-	jsonp: "callback",
-	jsonpCallback: function() {
-		var callback = oldCallbacks.pop() || ( jQuery.expando + "_" + ( nonce++ ) );
-		this[ callback ] = true;
-		return callback;
-	}
-} );
-
-// Detect, normalize options and install callbacks for jsonp requests
-jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) {
-
-	var callbackName, overwritten, responseContainer,
-		jsonProp = s.jsonp !== false && ( rjsonp.test( s.url ) ?
-			"url" :
-			typeof s.data === "string" &&
-				( s.contentType || "" )
-					.indexOf( "application/x-www-form-urlencoded" ) === 0 &&
-				rjsonp.test( s.data ) && "data"
-		);
-
-	// Handle iff the expected data type is "jsonp" or we have a parameter to set
-	if ( jsonProp || s.dataTypes[ 0 ] === "jsonp" ) {
-
-		// Get callback name, remembering preexisting value associated with it
-		callbackName = s.jsonpCallback = jQuery.isFunction( s.jsonpCallback ) ?
-			s.jsonpCallback() :
-			s.jsonpCallback;
-
-		// Insert callback into url or form data
-		if ( jsonProp ) {
-			s[ jsonProp ] = s[ jsonProp ].replace( rjsonp, "$1" + callbackName );
-		} else if ( s.jsonp !== false ) {
-			s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.jsonp + "=" + callbackName;
-		}
-
-		// Use data converter to retrieve json after script execution
-		s.converters[ "script json" ] = function() {
-			if ( !responseContainer ) {
-				jQuery.error( callbackName + " was not called" );
-			}
-			return responseContainer[ 0 ];
-		};
-
-		// Force json dataType
-		s.dataTypes[ 0 ] = "json";
-
-		// Install callback
-		overwritten = window[ callbackName ];
-		window[ callbackName ] = function() {
-			responseContainer = arguments;
-		};
-
-		// Clean-up function (fires after converters)
-		jqXHR.always( function() {
-
-			// If previous value didn't exist - remove it
-			if ( overwritten === undefined ) {
-				jQuery( window ).removeProp( callbackName );
-
-			// Otherwise restore preexisting value
-			} else {
-				window[ callbackName ] = overwritten;
-			}
-
-			// Save back as free
-			if ( s[ callbackName ] ) {
-
-				// Make sure that re-using the options doesn't screw things around
-				s.jsonpCallback = originalSettings.jsonpCallback;
-
-				// Save the callback name for future use
-				oldCallbacks.push( callbackName );
-			}
-
-			// Call if it was a function and we have a response
-			if ( responseContainer && jQuery.isFunction( overwritten ) ) {
-				overwritten( responseContainer[ 0 ] );
-			}
-
-			responseContainer = overwritten = undefined;
-		} );
-
-		// Delegate to script
-		return "script";
-	}
-} );
-
-
-
-
-// Support: Safari 8 only
-// In Safari 8 documents created via document.implementation.createHTMLDocument
-// collapse sibling forms: the second one becomes a child of the first one.
-// Because of that, this security measure has to be disabled in Safari 8.
-// https://bugs.webkit.org/show_bug.cgi?id=137337
-support.createHTMLDocument = ( function() {
-	var body = document.implementation.createHTMLDocument( "" ).body;
-	body.innerHTML = "<form></form><form></form>";
-	return body.childNodes.length === 2;
-} )();
-
-
-// Argument "data" should be string of html
-// context (optional): If specified, the fragment will be created in this context,
-// defaults to document
-// keepScripts (optional): If true, will include scripts passed in the html string
-jQuery.parseHTML = function( data, context, keepScripts ) {
-	if ( typeof data !== "string" ) {
-		return [];
-	}
-	if ( typeof context === "boolean" ) {
-		keepScripts = context;
-		context = false;
-	}
-
-	var base, parsed, scripts;
-
-	if ( !context ) {
-
-		// Stop scripts or inline event handlers from being executed immediately
-		// by using document.implementation
-		if ( support.createHTMLDocument ) {
-			context = document.implementation.createHTMLDocument( "" );
-
-			// Set the base href for the created document
-			// so any parsed elements with URLs
-			// are based on the document's URL (gh-2965)
-			base = context.createElement( "base" );
-			base.href = document.location.href;
-			context.head.appendChild( base );
-		} else {
-			context = document;
-		}
-	}
-
-	parsed = rsingleTag.exec( data );
-	scripts = !keepScripts && [];
-
-	// Single tag
-	if ( parsed ) {
-		return [ context.createElement( parsed[ 1 ] ) ];
-	}
-
-	parsed = buildFragment( [ data ], context, scripts );
-
-	if ( scripts && scripts.length ) {
-		jQuery( scripts ).remove();
-	}
-
-	return jQuery.merge( [], parsed.childNodes );
-};
-
-
-/**
- * Load a url into a page
- */
-jQuery.fn.load = function( url, params, callback ) {
-	var selector, type, response,
-		self = this,
-		off = url.indexOf( " " );
-
-	if ( off > -1 ) {
-		selector = stripAndCollapse( url.slice( off ) );
-		url = url.slice( 0, off );
-	}
-
-	// If it's a function
-	if ( jQuery.isFunction( params ) ) {
-
-		// We assume that it's the callback
-		callback = params;
-		params = undefined;
-
-	// Otherwise, build a param string
-	} else if ( params && typeof params === "object" ) {
-		type = "POST";
-	}
-
-	// If we have elements to modify, make the request
-	if ( self.length > 0 ) {
-		jQuery.ajax( {
-			url: url,
-
-			// If "type" variable is undefined, then "GET" method will be used.
-			// Make value of this field explicit since
-			// user can override it through ajaxSetup method
-			type: type || "GET",
-			dataType: "html",
-			data: params
-		} ).done( function( responseText ) {
-
-			// Save response for use in complete callback
-			response = arguments;
-
-			self.html( selector ?
-
-				// If a selector was specified, locate the right elements in a dummy div
-				// Exclude scripts to avoid IE 'Permission Denied' errors
-				jQuery( "<div>" ).append( jQuery.parseHTML( responseText ) ).find( selector ) :
-
-				// Otherwise use the full result
-				responseText );
-
-		// If the request succeeds, this function gets "data", "status", "jqXHR"
-		// but they are ignored because response was set above.
-		// If it fails, this function gets "jqXHR", "status", "error"
-		} ).always( callback && function( jqXHR, status ) {
-			self.each( function() {
-				callback.apply( this, response || [ jqXHR.responseText, status, jqXHR ] );
-			} );
-		} );
-	}
-
-	return this;
-};
-
-
-
-
-// Attach a bunch of functions for handling common AJAX events
-jQuery.each( [
-	"ajaxStart",
-	"ajaxStop",
-	"ajaxComplete",
-	"ajaxError",
-	"ajaxSuccess",
-	"ajaxSend"
-], function( i, type ) {
-	jQuery.fn[ type ] = function( fn ) {
-		return this.on( type, fn );
-	};
-} );
-
-
-
-
-jQuery.expr.pseudos.animated = function( elem ) {
-	return jQuery.grep( jQuery.timers, function( fn ) {
-		return elem === fn.elem;
-	} ).length;
-};
-
-
-
-
-jQuery.offset = {
-	setOffset: function( elem, options, i ) {
-		var curPosition, curLeft, curCSSTop, curTop, curOffset, curCSSLeft, calculatePosition,
-			position = jQuery.css( elem, "position" ),
-			curElem = jQuery( elem ),
-			props = {};
-
-		// Set position first, in-case top/left are set even on static elem
-		if ( position === "static" ) {
-			elem.style.position = "relative";
-		}
-
-		curOffset = curElem.offset();
-		curCSSTop = jQuery.css( elem, "top" );
-		curCSSLeft = jQuery.css( elem, "left" );
-		calculatePosition = ( position === "absolute" || position === "fixed" ) &&
-			( curCSSTop + curCSSLeft ).indexOf( "auto" ) > -1;
-
-		// Need to be able to calculate position if either
-		// top or left is auto and position is either absolute or fixed
-		if ( calculatePosition ) {
-			curPosition = curElem.position();
-			curTop = curPosition.top;
-			curLeft = curPosition.left;
-
-		} else {
-			curTop = parseFloat( curCSSTop ) || 0;
-			curLeft = parseFloat( curCSSLeft ) || 0;
-		}
-
-		if ( jQuery.isFunction( options ) ) {
-
-			// Use jQuery.extend here to allow modification of coordinates argument (gh-1848)
-			options = options.call( elem, i, jQuery.extend( {}, curOffset ) );
-		}
-
-		if ( options.top != null ) {
-			props.top = ( options.top - curOffset.top ) + curTop;
-		}
-		if ( options.left != null ) {
-			props.left = ( options.left - curOffset.left ) + curLeft;
-		}
-
-		if ( "using" in options ) {
-			options.using.call( elem, props );
-
-		} else {
-			curElem.css( props );
-		}
-	}
-};
-
-jQuery.fn.extend( {
-	offset: function( options ) {
-
-		// Preserve chaining for setter
-		if ( arguments.length ) {
-			return options === undefined ?
-				this :
-				this.each( function( i ) {
-					jQuery.offset.setOffset( this, options, i );
-				} );
-		}
-
-		var doc, docElem, rect, win,
-			elem = this[ 0 ];
-
-		if ( !elem ) {
-			return;
-		}
-
-		// Return zeros for disconnected and hidden (display: none) elements (gh-2310)
-		// Support: IE <=11 only
-		// Running getBoundingClientRect on a
-		// disconnected node in IE throws an error
-		if ( !elem.getClientRects().length ) {
-			return { top: 0, left: 0 };
-		}
-
-		rect = elem.getBoundingClientRect();
-
-		doc = elem.ownerDocument;
-		docElem = doc.documentElement;
-		win = doc.defaultView;
-
-		return {
-			top: rect.top + win.pageYOffset - docElem.clientTop,
-			left: rect.left + win.pageXOffset - docElem.clientLeft
-		};
-	},
-
-	position: function() {
-		if ( !this[ 0 ] ) {
-			return;
-		}
-
-		var offsetParent, offset,
-			elem = this[ 0 ],
-			parentOffset = { top: 0, left: 0 };
-
-		// Fixed elements are offset from window (parentOffset = {top:0, left: 0},
-		// because it is its only offset parent
-		if ( jQuery.css( elem, "position" ) === "fixed" ) {
-
-			// Assume getBoundingClientRect is there when computed position is fixed
-			offset = elem.getBoundingClientRect();
-
-		} else {
-
-			// Get *real* offsetParent
-			offsetParent = this.offsetParent();
-
-			// Get correct offsets
-			offset = this.offset();
-			if ( !nodeName( offsetParent[ 0 ], "html" ) ) {
-				parentOffset = offsetParent.offset();
-			}
-
-			// Add offsetParent borders
-			parentOffset = {
-				top: parentOffset.top + jQuery.css( offsetParent[ 0 ], "borderTopWidth", true ),
-				left: parentOffset.left + jQuery.css( offsetParent[ 0 ], "borderLeftWidth", true )
-			};
-		}
-
-		// Subtract parent offsets and element margins
-		return {
-			top: offset.top - parentOffset.top - jQuery.css( elem, "marginTop", true ),
-			left: offset.left - parentOffset.left - jQuery.css( elem, "marginLeft", true )
-		};
-	},
-
-	// This method will return documentElement in the following cases:
-	// 1) For the element inside the iframe without offsetParent, this method will return
-	//    documentElement of the parent window
-	// 2) For the hidden or detached element
-	// 3) For body or html element, i.e. in case of the html node - it will return itself
-	//
-	// but those exceptions were never presented as a real life use-cases
-	// and might be considered as more preferable results.
-	//
-	// This logic, however, is not guaranteed and can change at any point in the future
-	offsetParent: function() {
-		return this.map( function() {
-			var offsetParent = this.offsetParent;
-
-			while ( offsetParent && jQuery.css( offsetParent, "position" ) === "static" ) {
-				offsetParent = offsetParent.offsetParent;
-			}
-
-			return offsetParent || documentElement;
-		} );
-	}
-} );
-
-// Create scrollLeft and scrollTop methods
-jQuery.each( { scrollLeft: "pageXOffset", scrollTop: "pageYOffset" }, function( method, prop ) {
-	var top = "pageYOffset" === prop;
-
-	jQuery.fn[ method ] = function( val ) {
-		return access( this, function( elem, method, val ) {
-
-			// Coalesce documents and windows
-			var win;
-			if ( jQuery.isWindow( elem ) ) {
-				win = elem;
-			} else if ( elem.nodeType === 9 ) {
-				win = elem.defaultView;
-			}
-
-			if ( val === undefined ) {
-				return win ? win[ prop ] : elem[ method ];
-			}
-
-			if ( win ) {
-				win.scrollTo(
-					!top ? val : win.pageXOffset,
-					top ? val : win.pageYOffset
-				);
-
-			} else {
-				elem[ method ] = val;
-			}
-		}, method, val, arguments.length );
-	};
-} );
-
-// Support: Safari <=7 - 9.1, Chrome <=37 - 49
-// Add the top/left cssHooks using jQuery.fn.position
-// Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084
-// Blink bug: https://bugs.chromium.org/p/chromium/issues/detail?id=589347
-// getComputedStyle returns percent when specified for top/left/bottom/right;
-// rather than make the css module depend on the offset module, just check for it here
-jQuery.each( [ "top", "left" ], function( i, prop ) {
-	jQuery.cssHooks[ prop ] = addGetHookIf( support.pixelPosition,
-		function( elem, computed ) {
-			if ( computed ) {
-				computed = curCSS( elem, prop );
-
-				// If curCSS returns percentage, fallback to offset
-				return rnumnonpx.test( computed ) ?
-					jQuery( elem ).position()[ prop ] + "px" :
-					computed;
-			}
-		}
-	);
-} );
-
-
-// Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods
-jQuery.each( { Height: "height", Width: "width" }, function( name, type ) {
-	jQuery.each( { padding: "inner" + name, content: type, "": "outer" + name },
-		function( defaultExtra, funcName ) {
-
-		// Margin is only for outerHeight, outerWidth
-		jQuery.fn[ funcName ] = function( margin, value ) {
-			var chainable = arguments.length && ( defaultExtra || typeof margin !== "boolean" ),
-				extra = defaultExtra || ( margin === true || value === true ? "margin" : "border" );
-
-			return access( this, function( elem, type, value ) {
-				var doc;
-
-				if ( jQuery.isWindow( elem ) ) {
-
-					// $( window ).outerWidth/Height return w/h including scrollbars (gh-1729)
-					return funcName.indexOf( "outer" ) === 0 ?
-						elem[ "inner" + name ] :
-						elem.document.documentElement[ "client" + name ];
-				}
-
-				// Get document width or height
-				if ( elem.nodeType === 9 ) {
-					doc = elem.documentElement;
-
-					// Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height],
-					// whichever is greatest
-					return Math.max(
-						elem.body[ "scroll" + name ], doc[ "scroll" + name ],
-						elem.body[ "offset" + name ], doc[ "offset" + name ],
-						doc[ "client" + name ]
-					);
-				}
-
-				return value === undefined ?
-
-					// Get width or height on the element, requesting but not forcing parseFloat
-					jQuery.css( elem, type, extra ) :
-
-					// Set width or height on the element
-					jQuery.style( elem, type, value, extra );
-			}, type, chainable ? margin : undefined, chainable );
-		};
-	} );
-} );
-
-
-jQuery.fn.extend( {
-
-	bind: function( types, data, fn ) {
-		return this.on( types, null, data, fn );
-	},
-	unbind: function( types, fn ) {
-		return this.off( types, null, fn );
-	},
-
-	delegate: function( selector, types, data, fn ) {
-		return this.on( types, selector, data, fn );
-	},
-	undelegate: function( selector, types, fn ) {
-
-		// ( namespace ) or ( selector, types [, fn] )
-		return arguments.length === 1 ?
-			this.off( selector, "**" ) :
-			this.off( types, selector || "**", fn );
-	}
-} );
-
-jQuery.holdReady = function( hold ) {
-	if ( hold ) {
-		jQuery.readyWait++;
-	} else {
-		jQuery.ready( true );
-	}
-};
-jQuery.isArray = Array.isArray;
-jQuery.parseJSON = JSON.parse;
-jQuery.nodeName = nodeName;
-
-
-
-
-// Register as a named AMD module, since jQuery can be concatenated with other
-// files that may use define, but not via a proper concatenation script that
-// understands anonymous AMD modules. A named AMD is safest and most robust
-// way to register. Lowercase jquery is used because AMD module names are
-// derived from file names, and jQuery is normally delivered in a lowercase
-// file name. Do this after creating the global so that if an AMD module wants
-// to call noConflict to hide this version of jQuery, it will work.
-
-// Note that for maximum portability, libraries that are not jQuery should
-// declare themselves as anonymous modules, and avoid setting a global if an
-// AMD loader is present. jQuery is a special case. For more information, see
-// https://github.com/jrburke/requirejs/wiki/Updating-existing-libraries#wiki-anon
-
-if ( typeof define === "function" && define.amd ) {
-	define( "jquery", [], function() {
-		return jQuery;
-	} );
-}
-
-
-
-
-var
-
-	// Map over jQuery in case of overwrite
-	_jQuery = window.jQuery,
-
-	// Map over the $ in case of overwrite
-	_$ = window.$;
-
-jQuery.noConflict = function( deep ) {
-	if ( window.$ === jQuery ) {
-		window.$ = _$;
-	}
-
-	if ( deep && window.jQuery === jQuery ) {
-		window.jQuery = _jQuery;
-	}
-
-	return jQuery;
-};
-
-// Expose jQuery and $ identifiers, even in AMD
-// (#7102#comment:10, https://github.com/jquery/jquery/pull/557)
-// and CommonJS for browser emulators (#13566)
-if ( !noGlobal ) {
-	window.jQuery = window.$ = jQuery;
-}
-
-
-
-
-return jQuery;
-} );
diff --git a/_static/jquery.js b/_static/jquery.js
deleted file mode 100755
index 644d35e274f..00000000000
--- a/_static/jquery.js
+++ /dev/null
@@ -1,4 +0,0 @@
-/*! jQuery v3.2.1 | (c) JS Foundation and other contributors | jquery.org/license */
-!function(a,b){"use strict";"object"==typeof module&&"object"==typeof module.exports?module.exports=a.document?b(a,!0):function(a){if(!a.document)throw new Error("jQuery requires a window with a document");return b(a)}:b(a)}("undefined"!=typeof window?window:this,function(a,b){"use strict";var c=[],d=a.document,e=Object.getPrototypeOf,f=c.slice,g=c.concat,h=c.push,i=c.indexOf,j={},k=j.toString,l=j.hasOwnProperty,m=l.toString,n=m.call(Object),o={};function p(a,b){b=b||d;var c=b.createElement("script");c.text=a,b.head.appendChild(c).parentNode.removeChild(c)}var q="3.2.1",r=function(a,b){return new r.fn.init(a,b)},s=/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,t=/^-ms-/,u=/-([a-z])/g,v=function(a,b){return b.toUpperCase()};r.fn=r.prototype={jquery:q,constructor:r,length:0,toArray:function(){return f.call(this)},get:function(a){return null==a?f.call(this):a<0?this[a+this.length]:this[a]},pushStack:function(a){var b=r.merge(this.constructor(),a);return b.prevObject=this,b},each:function(a){return r.each(this,a)},map:function(a){return this.pushStack(r.map(this,function(b,c){return a.call(b,c,b)}))},slice:function(){return this.pushStack(f.apply(this,arguments))},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},eq:function(a){var b=this.length,c=+a+(a<0?b:0);return this.pushStack(c>=0&&c<b?[this[c]]:[])},end:function(){return this.prevObject||this.constructor()},push:h,sort:c.sort,splice:c.splice},r.extend=r.fn.extend=function(){var a,b,c,d,e,f,g=arguments[0]||{},h=1,i=arguments.length,j=!1;for("boolean"==typeof g&&(j=g,g=arguments[h]||{},h++),"object"==typeof g||r.isFunction(g)||(g={}),h===i&&(g=this,h--);h<i;h++)if(null!=(a=arguments[h]))for(b in a)c=g[b],d=a[b],g!==d&&(j&&d&&(r.isPlainObject(d)||(e=Array.isArray(d)))?(e?(e=!1,f=c&&Array.isArray(c)?c:[]):f=c&&r.isPlainObject(c)?c:{},g[b]=r.extend(j,f,d)):void 0!==d&&(g[b]=d));return g},r.extend({expando:"jQuery"+(q+Math.random()).replace(/\D/g,""),isReady:!0,error:function(a){throw new Error(a)},noop:function(){},isFunction:function(a){return"function"===r.type(a)},isWindow:function(a){return null!=a&&a===a.window},isNumeric:function(a){var b=r.type(a);return("number"===b||"string"===b)&&!isNaN(a-parseFloat(a))},isPlainObject:function(a){var b,c;return!(!a||"[object Object]"!==k.call(a))&&(!(b=e(a))||(c=l.call(b,"constructor")&&b.constructor,"function"==typeof c&&m.call(c)===n))},isEmptyObject:function(a){var b;for(b in a)return!1;return!0},type:function(a){return null==a?a+"":"object"==typeof a||"function"==typeof a?j[k.call(a)]||"object":typeof a},globalEval:function(a){p(a)},camelCase:function(a){return a.replace(t,"ms-").replace(u,v)},each:function(a,b){var c,d=0;if(w(a)){for(c=a.length;d<c;d++)if(b.call(a[d],d,a[d])===!1)break}else for(d in a)if(b.call(a[d],d,a[d])===!1)break;return a},trim:function(a){return null==a?"":(a+"").replace(s,"")},makeArray:function(a,b){var c=b||[];return null!=a&&(w(Object(a))?r.merge(c,"string"==typeof a?[a]:a):h.call(c,a)),c},inArray:function(a,b,c){return null==b?-1:i.call(b,a,c)},merge:function(a,b){for(var c=+b.length,d=0,e=a.length;d<c;d++)a[e++]=b[d];return a.length=e,a},grep:function(a,b,c){for(var d,e=[],f=0,g=a.length,h=!c;f<g;f++)d=!b(a[f],f),d!==h&&e.push(a[f]);return e},map:function(a,b,c){var d,e,f=0,h=[];if(w(a))for(d=a.length;f<d;f++)e=b(a[f],f,c),null!=e&&h.push(e);else for(f in a)e=b(a[f],f,c),null!=e&&h.push(e);return g.apply([],h)},guid:1,proxy:function(a,b){var c,d,e;if("string"==typeof b&&(c=a[b],b=a,a=c),r.isFunction(a))return d=f.call(arguments,2),e=function(){return a.apply(b||this,d.concat(f.call(arguments)))},e.guid=a.guid=a.guid||r.guid++,e},now:Date.now,support:o}),"function"==typeof Symbol&&(r.fn[Symbol.iterator]=c[Symbol.iterator]),r.each("Boolean Number String Function Array Date RegExp Object Error Symbol".split(" "),function(a,b){j["[object "+b+"]"]=b.toLowerCase()});function w(a){var b=!!a&&"length"in a&&a.length,c=r.type(a);return"function"!==c&&!r.isWindow(a)&&("array"===c||0===b||"number"==typeof b&&b>0&&b-1 in a)}var x=function(a){var b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u="sizzle"+1*new Date,v=a.document,w=0,x=0,y=ha(),z=ha(),A=ha(),B=function(a,b){return a===b&&(l=!0),0},C={}.hasOwnProperty,D=[],E=D.pop,F=D.push,G=D.push,H=D.slice,I=function(a,b){for(var c=0,d=a.length;c<d;c++)if(a[c]===b)return c;return-1},J="checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",K="[\\x20\\t\\r\\n\\f]",L="(?:\\\\.|[\\w-]|[^\0-\\xa0])+",M="\\["+K+"*("+L+")(?:"+K+"*([*^$|!~]?=)"+K+"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|("+L+"))|)"+K+"*\\]",N=":("+L+")(?:\\((('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|((?:\\\\.|[^\\\\()[\\]]|"+M+")*)|.*)\\)|)",O=new RegExp(K+"+","g"),P=new RegExp("^"+K+"+|((?:^|[^\\\\])(?:\\\\.)*)"+K+"+$","g"),Q=new RegExp("^"+K+"*,"+K+"*"),R=new RegExp("^"+K+"*([>+~]|"+K+")"+K+"*"),S=new RegExp("="+K+"*([^\\]'\"]*?)"+K+"*\\]","g"),T=new RegExp(N),U=new RegExp("^"+L+"$"),V={ID:new RegExp("^#("+L+")"),CLASS:new RegExp("^\\.("+L+")"),TAG:new RegExp("^("+L+"|[*])"),ATTR:new RegExp("^"+M),PSEUDO:new RegExp("^"+N),CHILD:new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\("+K+"*(even|odd|(([+-]|)(\\d*)n|)"+K+"*(?:([+-]|)"+K+"*(\\d+)|))"+K+"*\\)|)","i"),bool:new RegExp("^(?:"+J+")$","i"),needsContext:new RegExp("^"+K+"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\("+K+"*((?:-\\d)?\\d*)"+K+"*\\)|)(?=[^-]|$)","i")},W=/^(?:input|select|textarea|button)$/i,X=/^h\d$/i,Y=/^[^{]+\{\s*\[native \w/,Z=/^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,$=/[+~]/,_=new RegExp("\\\\([\\da-f]{1,6}"+K+"?|("+K+")|.)","ig"),aa=function(a,b,c){var d="0x"+b-65536;return d!==d||c?b:d<0?String.fromCharCode(d+65536):String.fromCharCode(d>>10|55296,1023&d|56320)},ba=/([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,ca=function(a,b){return b?"\0"===a?"\ufffd":a.slice(0,-1)+"\\"+a.charCodeAt(a.length-1).toString(16)+" ":"\\"+a},da=function(){m()},ea=ta(function(a){return a.disabled===!0&&("form"in a||"label"in a)},{dir:"parentNode",next:"legend"});try{G.apply(D=H.call(v.childNodes),v.childNodes),D[v.childNodes.length].nodeType}catch(fa){G={apply:D.length?function(a,b){F.apply(a,H.call(b))}:function(a,b){var c=a.length,d=0;while(a[c++]=b[d++]);a.length=c-1}}}function ga(a,b,d,e){var f,h,j,k,l,o,r,s=b&&b.ownerDocument,w=b?b.nodeType:9;if(d=d||[],"string"!=typeof a||!a||1!==w&&9!==w&&11!==w)return d;if(!e&&((b?b.ownerDocument||b:v)!==n&&m(b),b=b||n,p)){if(11!==w&&(l=Z.exec(a)))if(f=l[1]){if(9===w){if(!(j=b.getElementById(f)))return d;if(j.id===f)return d.push(j),d}else if(s&&(j=s.getElementById(f))&&t(b,j)&&j.id===f)return d.push(j),d}else{if(l[2])return G.apply(d,b.getElementsByTagName(a)),d;if((f=l[3])&&c.getElementsByClassName&&b.getElementsByClassName)return G.apply(d,b.getElementsByClassName(f)),d}if(c.qsa&&!A[a+" "]&&(!q||!q.test(a))){if(1!==w)s=b,r=a;else if("object"!==b.nodeName.toLowerCase()){(k=b.getAttribute("id"))?k=k.replace(ba,ca):b.setAttribute("id",k=u),o=g(a),h=o.length;while(h--)o[h]="#"+k+" "+sa(o[h]);r=o.join(","),s=$.test(a)&&qa(b.parentNode)||b}if(r)try{return G.apply(d,s.querySelectorAll(r)),d}catch(x){}finally{k===u&&b.removeAttribute("id")}}}return i(a.replace(P,"$1"),b,d,e)}function ha(){var a=[];function b(c,e){return a.push(c+" ")>d.cacheLength&&delete b[a.shift()],b[c+" "]=e}return b}function ia(a){return a[u]=!0,a}function ja(a){var b=n.createElement("fieldset");try{return!!a(b)}catch(c){return!1}finally{b.parentNode&&b.parentNode.removeChild(b),b=null}}function ka(a,b){var c=a.split("|"),e=c.length;while(e--)d.attrHandle[c[e]]=b}function la(a,b){var c=b&&a,d=c&&1===a.nodeType&&1===b.nodeType&&a.sourceIndex-b.sourceIndex;if(d)return d;if(c)while(c=c.nextSibling)if(c===b)return-1;return a?1:-1}function ma(a){return function(b){var c=b.nodeName.toLowerCase();return"input"===c&&b.type===a}}function na(a){return function(b){var c=b.nodeName.toLowerCase();return("input"===c||"button"===c)&&b.type===a}}function oa(a){return function(b){return"form"in b?b.parentNode&&b.disabled===!1?"label"in b?"label"in b.parentNode?b.parentNode.disabled===a:b.disabled===a:b.isDisabled===a||b.isDisabled!==!a&&ea(b)===a:b.disabled===a:"label"in b&&b.disabled===a}}function pa(a){return ia(function(b){return b=+b,ia(function(c,d){var e,f=a([],c.length,b),g=f.length;while(g--)c[e=f[g]]&&(c[e]=!(d[e]=c[e]))})})}function qa(a){return a&&"undefined"!=typeof a.getElementsByTagName&&a}c=ga.support={},f=ga.isXML=function(a){var b=a&&(a.ownerDocument||a).documentElement;return!!b&&"HTML"!==b.nodeName},m=ga.setDocument=function(a){var b,e,g=a?a.ownerDocument||a:v;return g!==n&&9===g.nodeType&&g.documentElement?(n=g,o=n.documentElement,p=!f(n),v!==n&&(e=n.defaultView)&&e.top!==e&&(e.addEventListener?e.addEventListener("unload",da,!1):e.attachEvent&&e.attachEvent("onunload",da)),c.attributes=ja(function(a){return a.className="i",!a.getAttribute("className")}),c.getElementsByTagName=ja(function(a){return a.appendChild(n.createComment("")),!a.getElementsByTagName("*").length}),c.getElementsByClassName=Y.test(n.getElementsByClassName),c.getById=ja(function(a){return o.appendChild(a).id=u,!n.getElementsByName||!n.getElementsByName(u).length}),c.getById?(d.filter.ID=function(a){var b=a.replace(_,aa);return function(a){return a.getAttribute("id")===b}},d.find.ID=function(a,b){if("undefined"!=typeof b.getElementById&&p){var c=b.getElementById(a);return c?[c]:[]}}):(d.filter.ID=function(a){var b=a.replace(_,aa);return function(a){var c="undefined"!=typeof a.getAttributeNode&&a.getAttributeNode("id");return c&&c.value===b}},d.find.ID=function(a,b){if("undefined"!=typeof b.getElementById&&p){var c,d,e,f=b.getElementById(a);if(f){if(c=f.getAttributeNode("id"),c&&c.value===a)return[f];e=b.getElementsByName(a),d=0;while(f=e[d++])if(c=f.getAttributeNode("id"),c&&c.value===a)return[f]}return[]}}),d.find.TAG=c.getElementsByTagName?function(a,b){return"undefined"!=typeof b.getElementsByTagName?b.getElementsByTagName(a):c.qsa?b.querySelectorAll(a):void 0}:function(a,b){var c,d=[],e=0,f=b.getElementsByTagName(a);if("*"===a){while(c=f[e++])1===c.nodeType&&d.push(c);return d}return f},d.find.CLASS=c.getElementsByClassName&&function(a,b){if("undefined"!=typeof b.getElementsByClassName&&p)return b.getElementsByClassName(a)},r=[],q=[],(c.qsa=Y.test(n.querySelectorAll))&&(ja(function(a){o.appendChild(a).innerHTML="<a id='"+u+"'></a><select id='"+u+"-\r\\' msallowcapture=''><option selected=''></option></select>",a.querySelectorAll("[msallowcapture^='']").length&&q.push("[*^$]="+K+"*(?:''|\"\")"),a.querySelectorAll("[selected]").length||q.push("\\["+K+"*(?:value|"+J+")"),a.querySelectorAll("[id~="+u+"-]").length||q.push("~="),a.querySelectorAll(":checked").length||q.push(":checked"),a.querySelectorAll("a#"+u+"+*").length||q.push(".#.+[+~]")}),ja(function(a){a.innerHTML="<a href='' disabled='disabled'></a><select disabled='disabled'><option/></select>";var b=n.createElement("input");b.setAttribute("type","hidden"),a.appendChild(b).setAttribute("name","D"),a.querySelectorAll("[name=d]").length&&q.push("name"+K+"*[*^$|!~]?="),2!==a.querySelectorAll(":enabled").length&&q.push(":enabled",":disabled"),o.appendChild(a).disabled=!0,2!==a.querySelectorAll(":disabled").length&&q.push(":enabled",":disabled"),a.querySelectorAll("*,:x"),q.push(",.*:")})),(c.matchesSelector=Y.test(s=o.matches||o.webkitMatchesSelector||o.mozMatchesSelector||o.oMatchesSelector||o.msMatchesSelector))&&ja(function(a){c.disconnectedMatch=s.call(a,"*"),s.call(a,"[s!='']:x"),r.push("!=",N)}),q=q.length&&new RegExp(q.join("|")),r=r.length&&new RegExp(r.join("|")),b=Y.test(o.compareDocumentPosition),t=b||Y.test(o.contains)?function(a,b){var c=9===a.nodeType?a.documentElement:a,d=b&&b.parentNode;return a===d||!(!d||1!==d.nodeType||!(c.contains?c.contains(d):a.compareDocumentPosition&&16&a.compareDocumentPosition(d)))}:function(a,b){if(b)while(b=b.parentNode)if(b===a)return!0;return!1},B=b?function(a,b){if(a===b)return l=!0,0;var d=!a.compareDocumentPosition-!b.compareDocumentPosition;return d?d:(d=(a.ownerDocument||a)===(b.ownerDocument||b)?a.compareDocumentPosition(b):1,1&d||!c.sortDetached&&b.compareDocumentPosition(a)===d?a===n||a.ownerDocument===v&&t(v,a)?-1:b===n||b.ownerDocument===v&&t(v,b)?1:k?I(k,a)-I(k,b):0:4&d?-1:1)}:function(a,b){if(a===b)return l=!0,0;var c,d=0,e=a.parentNode,f=b.parentNode,g=[a],h=[b];if(!e||!f)return a===n?-1:b===n?1:e?-1:f?1:k?I(k,a)-I(k,b):0;if(e===f)return la(a,b);c=a;while(c=c.parentNode)g.unshift(c);c=b;while(c=c.parentNode)h.unshift(c);while(g[d]===h[d])d++;return d?la(g[d],h[d]):g[d]===v?-1:h[d]===v?1:0},n):n},ga.matches=function(a,b){return ga(a,null,null,b)},ga.matchesSelector=function(a,b){if((a.ownerDocument||a)!==n&&m(a),b=b.replace(S,"='$1']"),c.matchesSelector&&p&&!A[b+" "]&&(!r||!r.test(b))&&(!q||!q.test(b)))try{var d=s.call(a,b);if(d||c.disconnectedMatch||a.document&&11!==a.document.nodeType)return d}catch(e){}return ga(b,n,null,[a]).length>0},ga.contains=function(a,b){return(a.ownerDocument||a)!==n&&m(a),t(a,b)},ga.attr=function(a,b){(a.ownerDocument||a)!==n&&m(a);var e=d.attrHandle[b.toLowerCase()],f=e&&C.call(d.attrHandle,b.toLowerCase())?e(a,b,!p):void 0;return void 0!==f?f:c.attributes||!p?a.getAttribute(b):(f=a.getAttributeNode(b))&&f.specified?f.value:null},ga.escape=function(a){return(a+"").replace(ba,ca)},ga.error=function(a){throw new Error("Syntax error, unrecognized expression: "+a)},ga.uniqueSort=function(a){var b,d=[],e=0,f=0;if(l=!c.detectDuplicates,k=!c.sortStable&&a.slice(0),a.sort(B),l){while(b=a[f++])b===a[f]&&(e=d.push(f));while(e--)a.splice(d[e],1)}return k=null,a},e=ga.getText=function(a){var b,c="",d=0,f=a.nodeType;if(f){if(1===f||9===f||11===f){if("string"==typeof a.textContent)return a.textContent;for(a=a.firstChild;a;a=a.nextSibling)c+=e(a)}else if(3===f||4===f)return a.nodeValue}else while(b=a[d++])c+=e(b);return c},d=ga.selectors={cacheLength:50,createPseudo:ia,match:V,attrHandle:{},find:{},relative:{">":{dir:"parentNode",first:!0}," ":{dir:"parentNode"},"+":{dir:"previousSibling",first:!0},"~":{dir:"previousSibling"}},preFilter:{ATTR:function(a){return a[1]=a[1].replace(_,aa),a[3]=(a[3]||a[4]||a[5]||"").replace(_,aa),"~="===a[2]&&(a[3]=" "+a[3]+" "),a.slice(0,4)},CHILD:function(a){return a[1]=a[1].toLowerCase(),"nth"===a[1].slice(0,3)?(a[3]||ga.error(a[0]),a[4]=+(a[4]?a[5]+(a[6]||1):2*("even"===a[3]||"odd"===a[3])),a[5]=+(a[7]+a[8]||"odd"===a[3])):a[3]&&ga.error(a[0]),a},PSEUDO:function(a){var b,c=!a[6]&&a[2];return V.CHILD.test(a[0])?null:(a[3]?a[2]=a[4]||a[5]||"":c&&T.test(c)&&(b=g(c,!0))&&(b=c.indexOf(")",c.length-b)-c.length)&&(a[0]=a[0].slice(0,b),a[2]=c.slice(0,b)),a.slice(0,3))}},filter:{TAG:function(a){var b=a.replace(_,aa).toLowerCase();return"*"===a?function(){return!0}:function(a){return a.nodeName&&a.nodeName.toLowerCase()===b}},CLASS:function(a){var b=y[a+" "];return b||(b=new RegExp("(^|"+K+")"+a+"("+K+"|$)"))&&y(a,function(a){return b.test("string"==typeof a.className&&a.className||"undefined"!=typeof a.getAttribute&&a.getAttribute("class")||"")})},ATTR:function(a,b,c){return function(d){var e=ga.attr(d,a);return null==e?"!="===b:!b||(e+="","="===b?e===c:"!="===b?e!==c:"^="===b?c&&0===e.indexOf(c):"*="===b?c&&e.indexOf(c)>-1:"$="===b?c&&e.slice(-c.length)===c:"~="===b?(" "+e.replace(O," ")+" ").indexOf(c)>-1:"|="===b&&(e===c||e.slice(0,c.length+1)===c+"-"))}},CHILD:function(a,b,c,d,e){var f="nth"!==a.slice(0,3),g="last"!==a.slice(-4),h="of-type"===b;return 1===d&&0===e?function(a){return!!a.parentNode}:function(b,c,i){var j,k,l,m,n,o,p=f!==g?"nextSibling":"previousSibling",q=b.parentNode,r=h&&b.nodeName.toLowerCase(),s=!i&&!h,t=!1;if(q){if(f){while(p){m=b;while(m=m[p])if(h?m.nodeName.toLowerCase()===r:1===m.nodeType)return!1;o=p="only"===a&&!o&&"nextSibling"}return!0}if(o=[g?q.firstChild:q.lastChild],g&&s){m=q,l=m[u]||(m[u]={}),k=l[m.uniqueID]||(l[m.uniqueID]={}),j=k[a]||[],n=j[0]===w&&j[1],t=n&&j[2],m=n&&q.childNodes[n];while(m=++n&&m&&m[p]||(t=n=0)||o.pop())if(1===m.nodeType&&++t&&m===b){k[a]=[w,n,t];break}}else if(s&&(m=b,l=m[u]||(m[u]={}),k=l[m.uniqueID]||(l[m.uniqueID]={}),j=k[a]||[],n=j[0]===w&&j[1],t=n),t===!1)while(m=++n&&m&&m[p]||(t=n=0)||o.pop())if((h?m.nodeName.toLowerCase()===r:1===m.nodeType)&&++t&&(s&&(l=m[u]||(m[u]={}),k=l[m.uniqueID]||(l[m.uniqueID]={}),k[a]=[w,t]),m===b))break;return t-=e,t===d||t%d===0&&t/d>=0}}},PSEUDO:function(a,b){var c,e=d.pseudos[a]||d.setFilters[a.toLowerCase()]||ga.error("unsupported pseudo: "+a);return e[u]?e(b):e.length>1?(c=[a,a,"",b],d.setFilters.hasOwnProperty(a.toLowerCase())?ia(function(a,c){var d,f=e(a,b),g=f.length;while(g--)d=I(a,f[g]),a[d]=!(c[d]=f[g])}):function(a){return e(a,0,c)}):e}},pseudos:{not:ia(function(a){var b=[],c=[],d=h(a.replace(P,"$1"));return d[u]?ia(function(a,b,c,e){var f,g=d(a,null,e,[]),h=a.length;while(h--)(f=g[h])&&(a[h]=!(b[h]=f))}):function(a,e,f){return b[0]=a,d(b,null,f,c),b[0]=null,!c.pop()}}),has:ia(function(a){return function(b){return ga(a,b).length>0}}),contains:ia(function(a){return a=a.replace(_,aa),function(b){return(b.textContent||b.innerText||e(b)).indexOf(a)>-1}}),lang:ia(function(a){return U.test(a||"")||ga.error("unsupported lang: "+a),a=a.replace(_,aa).toLowerCase(),function(b){var c;do if(c=p?b.lang:b.getAttribute("xml:lang")||b.getAttribute("lang"))return c=c.toLowerCase(),c===a||0===c.indexOf(a+"-");while((b=b.parentNode)&&1===b.nodeType);return!1}}),target:function(b){var c=a.location&&a.location.hash;return c&&c.slice(1)===b.id},root:function(a){return a===o},focus:function(a){return a===n.activeElement&&(!n.hasFocus||n.hasFocus())&&!!(a.type||a.href||~a.tabIndex)},enabled:oa(!1),disabled:oa(!0),checked:function(a){var b=a.nodeName.toLowerCase();return"input"===b&&!!a.checked||"option"===b&&!!a.selected},selected:function(a){return a.parentNode&&a.parentNode.selectedIndex,a.selected===!0},empty:function(a){for(a=a.firstChild;a;a=a.nextSibling)if(a.nodeType<6)return!1;return!0},parent:function(a){return!d.pseudos.empty(a)},header:function(a){return X.test(a.nodeName)},input:function(a){return W.test(a.nodeName)},button:function(a){var b=a.nodeName.toLowerCase();return"input"===b&&"button"===a.type||"button"===b},text:function(a){var b;return"input"===a.nodeName.toLowerCase()&&"text"===a.type&&(null==(b=a.getAttribute("type"))||"text"===b.toLowerCase())},first:pa(function(){return[0]}),last:pa(function(a,b){return[b-1]}),eq:pa(function(a,b,c){return[c<0?c+b:c]}),even:pa(function(a,b){for(var c=0;c<b;c+=2)a.push(c);return a}),odd:pa(function(a,b){for(var c=1;c<b;c+=2)a.push(c);return a}),lt:pa(function(a,b,c){for(var d=c<0?c+b:c;--d>=0;)a.push(d);return a}),gt:pa(function(a,b,c){for(var d=c<0?c+b:c;++d<b;)a.push(d);return a})}},d.pseudos.nth=d.pseudos.eq;for(b in{radio:!0,checkbox:!0,file:!0,password:!0,image:!0})d.pseudos[b]=ma(b);for(b in{submit:!0,reset:!0})d.pseudos[b]=na(b);function ra(){}ra.prototype=d.filters=d.pseudos,d.setFilters=new ra,g=ga.tokenize=function(a,b){var c,e,f,g,h,i,j,k=z[a+" "];if(k)return b?0:k.slice(0);h=a,i=[],j=d.preFilter;while(h){c&&!(e=Q.exec(h))||(e&&(h=h.slice(e[0].length)||h),i.push(f=[])),c=!1,(e=R.exec(h))&&(c=e.shift(),f.push({value:c,type:e[0].replace(P," ")}),h=h.slice(c.length));for(g in d.filter)!(e=V[g].exec(h))||j[g]&&!(e=j[g](e))||(c=e.shift(),f.push({value:c,type:g,matches:e}),h=h.slice(c.length));if(!c)break}return b?h.length:h?ga.error(a):z(a,i).slice(0)};function sa(a){for(var b=0,c=a.length,d="";b<c;b++)d+=a[b].value;return d}function ta(a,b,c){var d=b.dir,e=b.next,f=e||d,g=c&&"parentNode"===f,h=x++;return b.first?function(b,c,e){while(b=b[d])if(1===b.nodeType||g)return a(b,c,e);return!1}:function(b,c,i){var j,k,l,m=[w,h];if(i){while(b=b[d])if((1===b.nodeType||g)&&a(b,c,i))return!0}else while(b=b[d])if(1===b.nodeType||g)if(l=b[u]||(b[u]={}),k=l[b.uniqueID]||(l[b.uniqueID]={}),e&&e===b.nodeName.toLowerCase())b=b[d]||b;else{if((j=k[f])&&j[0]===w&&j[1]===h)return m[2]=j[2];if(k[f]=m,m[2]=a(b,c,i))return!0}return!1}}function ua(a){return a.length>1?function(b,c,d){var e=a.length;while(e--)if(!a[e](b,c,d))return!1;return!0}:a[0]}function va(a,b,c){for(var d=0,e=b.length;d<e;d++)ga(a,b[d],c);return c}function wa(a,b,c,d,e){for(var f,g=[],h=0,i=a.length,j=null!=b;h<i;h++)(f=a[h])&&(c&&!c(f,d,e)||(g.push(f),j&&b.push(h)));return g}function xa(a,b,c,d,e,f){return d&&!d[u]&&(d=xa(d)),e&&!e[u]&&(e=xa(e,f)),ia(function(f,g,h,i){var j,k,l,m=[],n=[],o=g.length,p=f||va(b||"*",h.nodeType?[h]:h,[]),q=!a||!f&&b?p:wa(p,m,a,h,i),r=c?e||(f?a:o||d)?[]:g:q;if(c&&c(q,r,h,i),d){j=wa(r,n),d(j,[],h,i),k=j.length;while(k--)(l=j[k])&&(r[n[k]]=!(q[n[k]]=l))}if(f){if(e||a){if(e){j=[],k=r.length;while(k--)(l=r[k])&&j.push(q[k]=l);e(null,r=[],j,i)}k=r.length;while(k--)(l=r[k])&&(j=e?I(f,l):m[k])>-1&&(f[j]=!(g[j]=l))}}else r=wa(r===g?r.splice(o,r.length):r),e?e(null,g,r,i):G.apply(g,r)})}function ya(a){for(var b,c,e,f=a.length,g=d.relative[a[0].type],h=g||d.relative[" "],i=g?1:0,k=ta(function(a){return a===b},h,!0),l=ta(function(a){return I(b,a)>-1},h,!0),m=[function(a,c,d){var e=!g&&(d||c!==j)||((b=c).nodeType?k(a,c,d):l(a,c,d));return b=null,e}];i<f;i++)if(c=d.relative[a[i].type])m=[ta(ua(m),c)];else{if(c=d.filter[a[i].type].apply(null,a[i].matches),c[u]){for(e=++i;e<f;e++)if(d.relative[a[e].type])break;return xa(i>1&&ua(m),i>1&&sa(a.slice(0,i-1).concat({value:" "===a[i-2].type?"*":""})).replace(P,"$1"),c,i<e&&ya(a.slice(i,e)),e<f&&ya(a=a.slice(e)),e<f&&sa(a))}m.push(c)}return ua(m)}function za(a,b){var c=b.length>0,e=a.length>0,f=function(f,g,h,i,k){var l,o,q,r=0,s="0",t=f&&[],u=[],v=j,x=f||e&&d.find.TAG("*",k),y=w+=null==v?1:Math.random()||.1,z=x.length;for(k&&(j=g===n||g||k);s!==z&&null!=(l=x[s]);s++){if(e&&l){o=0,g||l.ownerDocument===n||(m(l),h=!p);while(q=a[o++])if(q(l,g||n,h)){i.push(l);break}k&&(w=y)}c&&((l=!q&&l)&&r--,f&&t.push(l))}if(r+=s,c&&s!==r){o=0;while(q=b[o++])q(t,u,g,h);if(f){if(r>0)while(s--)t[s]||u[s]||(u[s]=E.call(i));u=wa(u)}G.apply(i,u),k&&!f&&u.length>0&&r+b.length>1&&ga.uniqueSort(i)}return k&&(w=y,j=v),t};return c?ia(f):f}return h=ga.compile=function(a,b){var c,d=[],e=[],f=A[a+" "];if(!f){b||(b=g(a)),c=b.length;while(c--)f=ya(b[c]),f[u]?d.push(f):e.push(f);f=A(a,za(e,d)),f.selector=a}return f},i=ga.select=function(a,b,c,e){var f,i,j,k,l,m="function"==typeof a&&a,n=!e&&g(a=m.selector||a);if(c=c||[],1===n.length){if(i=n[0]=n[0].slice(0),i.length>2&&"ID"===(j=i[0]).type&&9===b.nodeType&&p&&d.relative[i[1].type]){if(b=(d.find.ID(j.matches[0].replace(_,aa),b)||[])[0],!b)return c;m&&(b=b.parentNode),a=a.slice(i.shift().value.length)}f=V.needsContext.test(a)?0:i.length;while(f--){if(j=i[f],d.relative[k=j.type])break;if((l=d.find[k])&&(e=l(j.matches[0].replace(_,aa),$.test(i[0].type)&&qa(b.parentNode)||b))){if(i.splice(f,1),a=e.length&&sa(i),!a)return G.apply(c,e),c;break}}}return(m||h(a,n))(e,b,!p,c,!b||$.test(a)&&qa(b.parentNode)||b),c},c.sortStable=u.split("").sort(B).join("")===u,c.detectDuplicates=!!l,m(),c.sortDetached=ja(function(a){return 1&a.compareDocumentPosition(n.createElement("fieldset"))}),ja(function(a){return a.innerHTML="<a href='#'></a>","#"===a.firstChild.getAttribute("href")})||ka("type|href|height|width",function(a,b,c){if(!c)return a.getAttribute(b,"type"===b.toLowerCase()?1:2)}),c.attributes&&ja(function(a){return a.innerHTML="<input/>",a.firstChild.setAttribute("value",""),""===a.firstChild.getAttribute("value")})||ka("value",function(a,b,c){if(!c&&"input"===a.nodeName.toLowerCase())return a.defaultValue}),ja(function(a){return null==a.getAttribute("disabled")})||ka(J,function(a,b,c){var d;if(!c)return a[b]===!0?b.toLowerCase():(d=a.getAttributeNode(b))&&d.specified?d.value:null}),ga}(a);r.find=x,r.expr=x.selectors,r.expr[":"]=r.expr.pseudos,r.uniqueSort=r.unique=x.uniqueSort,r.text=x.getText,r.isXMLDoc=x.isXML,r.contains=x.contains,r.escapeSelector=x.escape;var y=function(a,b,c){var d=[],e=void 0!==c;while((a=a[b])&&9!==a.nodeType)if(1===a.nodeType){if(e&&r(a).is(c))break;d.push(a)}return d},z=function(a,b){for(var c=[];a;a=a.nextSibling)1===a.nodeType&&a!==b&&c.push(a);return c},A=r.expr.match.needsContext;function B(a,b){return a.nodeName&&a.nodeName.toLowerCase()===b.toLowerCase()}var C=/^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i,D=/^.[^:#\[\.,]*$/;function E(a,b,c){return r.isFunction(b)?r.grep(a,function(a,d){return!!b.call(a,d,a)!==c}):b.nodeType?r.grep(a,function(a){return a===b!==c}):"string"!=typeof b?r.grep(a,function(a){return i.call(b,a)>-1!==c}):D.test(b)?r.filter(b,a,c):(b=r.filter(b,a),r.grep(a,function(a){return i.call(b,a)>-1!==c&&1===a.nodeType}))}r.filter=function(a,b,c){var d=b[0];return c&&(a=":not("+a+")"),1===b.length&&1===d.nodeType?r.find.matchesSelector(d,a)?[d]:[]:r.find.matches(a,r.grep(b,function(a){return 1===a.nodeType}))},r.fn.extend({find:function(a){var b,c,d=this.length,e=this;if("string"!=typeof a)return this.pushStack(r(a).filter(function(){for(b=0;b<d;b++)if(r.contains(e[b],this))return!0}));for(c=this.pushStack([]),b=0;b<d;b++)r.find(a,e[b],c);return d>1?r.uniqueSort(c):c},filter:function(a){return this.pushStack(E(this,a||[],!1))},not:function(a){return this.pushStack(E(this,a||[],!0))},is:function(a){return!!E(this,"string"==typeof a&&A.test(a)?r(a):a||[],!1).length}});var F,G=/^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/,H=r.fn.init=function(a,b,c){var e,f;if(!a)return this;if(c=c||F,"string"==typeof a){if(e="<"===a[0]&&">"===a[a.length-1]&&a.length>=3?[null,a,null]:G.exec(a),!e||!e[1]&&b)return!b||b.jquery?(b||c).find(a):this.constructor(b).find(a);if(e[1]){if(b=b instanceof r?b[0]:b,r.merge(this,r.parseHTML(e[1],b&&b.nodeType?b.ownerDocument||b:d,!0)),C.test(e[1])&&r.isPlainObject(b))for(e in b)r.isFunction(this[e])?this[e](b[e]):this.attr(e,b[e]);return this}return f=d.getElementById(e[2]),f&&(this[0]=f,this.length=1),this}return a.nodeType?(this[0]=a,this.length=1,this):r.isFunction(a)?void 0!==c.ready?c.ready(a):a(r):r.makeArray(a,this)};H.prototype=r.fn,F=r(d);var I=/^(?:parents|prev(?:Until|All))/,J={children:!0,contents:!0,next:!0,prev:!0};r.fn.extend({has:function(a){var b=r(a,this),c=b.length;return this.filter(function(){for(var a=0;a<c;a++)if(r.contains(this,b[a]))return!0})},closest:function(a,b){var c,d=0,e=this.length,f=[],g="string"!=typeof a&&r(a);if(!A.test(a))for(;d<e;d++)for(c=this[d];c&&c!==b;c=c.parentNode)if(c.nodeType<11&&(g?g.index(c)>-1:1===c.nodeType&&r.find.matchesSelector(c,a))){f.push(c);break}return this.pushStack(f.length>1?r.uniqueSort(f):f)},index:function(a){return a?"string"==typeof a?i.call(r(a),this[0]):i.call(this,a.jquery?a[0]:a):this[0]&&this[0].parentNode?this.first().prevAll().length:-1},add:function(a,b){return this.pushStack(r.uniqueSort(r.merge(this.get(),r(a,b))))},addBack:function(a){return this.add(null==a?this.prevObject:this.prevObject.filter(a))}});function K(a,b){while((a=a[b])&&1!==a.nodeType);return a}r.each({parent:function(a){var b=a.parentNode;return b&&11!==b.nodeType?b:null},parents:function(a){return y(a,"parentNode")},parentsUntil:function(a,b,c){return y(a,"parentNode",c)},next:function(a){return K(a,"nextSibling")},prev:function(a){return K(a,"previousSibling")},nextAll:function(a){return y(a,"nextSibling")},prevAll:function(a){return y(a,"previousSibling")},nextUntil:function(a,b,c){return y(a,"nextSibling",c)},prevUntil:function(a,b,c){return y(a,"previousSibling",c)},siblings:function(a){return z((a.parentNode||{}).firstChild,a)},children:function(a){return z(a.firstChild)},contents:function(a){return B(a,"iframe")?a.contentDocument:(B(a,"template")&&(a=a.content||a),r.merge([],a.childNodes))}},function(a,b){r.fn[a]=function(c,d){var e=r.map(this,b,c);return"Until"!==a.slice(-5)&&(d=c),d&&"string"==typeof d&&(e=r.filter(d,e)),this.length>1&&(J[a]||r.uniqueSort(e),I.test(a)&&e.reverse()),this.pushStack(e)}});var L=/[^\x20\t\r\n\f]+/g;function M(a){var b={};return r.each(a.match(L)||[],function(a,c){b[c]=!0}),b}r.Callbacks=function(a){a="string"==typeof a?M(a):r.extend({},a);var b,c,d,e,f=[],g=[],h=-1,i=function(){for(e=e||a.once,d=b=!0;g.length;h=-1){c=g.shift();while(++h<f.length)f[h].apply(c[0],c[1])===!1&&a.stopOnFalse&&(h=f.length,c=!1)}a.memory||(c=!1),b=!1,e&&(f=c?[]:"")},j={add:function(){return f&&(c&&!b&&(h=f.length-1,g.push(c)),function d(b){r.each(b,function(b,c){r.isFunction(c)?a.unique&&j.has(c)||f.push(c):c&&c.length&&"string"!==r.type(c)&&d(c)})}(arguments),c&&!b&&i()),this},remove:function(){return r.each(arguments,function(a,b){var c;while((c=r.inArray(b,f,c))>-1)f.splice(c,1),c<=h&&h--}),this},has:function(a){return a?r.inArray(a,f)>-1:f.length>0},empty:function(){return f&&(f=[]),this},disable:function(){return e=g=[],f=c="",this},disabled:function(){return!f},lock:function(){return e=g=[],c||b||(f=c=""),this},locked:function(){return!!e},fireWith:function(a,c){return e||(c=c||[],c=[a,c.slice?c.slice():c],g.push(c),b||i()),this},fire:function(){return j.fireWith(this,arguments),this},fired:function(){return!!d}};return j};function N(a){return a}function O(a){throw a}function P(a,b,c,d){var e;try{a&&r.isFunction(e=a.promise)?e.call(a).done(b).fail(c):a&&r.isFunction(e=a.then)?e.call(a,b,c):b.apply(void 0,[a].slice(d))}catch(a){c.apply(void 0,[a])}}r.extend({Deferred:function(b){var c=[["notify","progress",r.Callbacks("memory"),r.Callbacks("memory"),2],["resolve","done",r.Callbacks("once memory"),r.Callbacks("once memory"),0,"resolved"],["reject","fail",r.Callbacks("once memory"),r.Callbacks("once memory"),1,"rejected"]],d="pending",e={state:function(){return d},always:function(){return f.done(arguments).fail(arguments),this},"catch":function(a){return e.then(null,a)},pipe:function(){var a=arguments;return r.Deferred(function(b){r.each(c,function(c,d){var e=r.isFunction(a[d[4]])&&a[d[4]];f[d[1]](function(){var a=e&&e.apply(this,arguments);a&&r.isFunction(a.promise)?a.promise().progress(b.notify).done(b.resolve).fail(b.reject):b[d[0]+"With"](this,e?[a]:arguments)})}),a=null}).promise()},then:function(b,d,e){var f=0;function g(b,c,d,e){return function(){var h=this,i=arguments,j=function(){var a,j;if(!(b<f)){if(a=d.apply(h,i),a===c.promise())throw new TypeError("Thenable self-resolution");j=a&&("object"==typeof a||"function"==typeof a)&&a.then,r.isFunction(j)?e?j.call(a,g(f,c,N,e),g(f,c,O,e)):(f++,j.call(a,g(f,c,N,e),g(f,c,O,e),g(f,c,N,c.notifyWith))):(d!==N&&(h=void 0,i=[a]),(e||c.resolveWith)(h,i))}},k=e?j:function(){try{j()}catch(a){r.Deferred.exceptionHook&&r.Deferred.exceptionHook(a,k.stackTrace),b+1>=f&&(d!==O&&(h=void 0,i=[a]),c.rejectWith(h,i))}};b?k():(r.Deferred.getStackHook&&(k.stackTrace=r.Deferred.getStackHook()),a.setTimeout(k))}}return r.Deferred(function(a){c[0][3].add(g(0,a,r.isFunction(e)?e:N,a.notifyWith)),c[1][3].add(g(0,a,r.isFunction(b)?b:N)),c[2][3].add(g(0,a,r.isFunction(d)?d:O))}).promise()},promise:function(a){return null!=a?r.extend(a,e):e}},f={};return r.each(c,function(a,b){var g=b[2],h=b[5];e[b[1]]=g.add,h&&g.add(function(){d=h},c[3-a][2].disable,c[0][2].lock),g.add(b[3].fire),f[b[0]]=function(){return f[b[0]+"With"](this===f?void 0:this,arguments),this},f[b[0]+"With"]=g.fireWith}),e.promise(f),b&&b.call(f,f),f},when:function(a){var b=arguments.length,c=b,d=Array(c),e=f.call(arguments),g=r.Deferred(),h=function(a){return function(c){d[a]=this,e[a]=arguments.length>1?f.call(arguments):c,--b||g.resolveWith(d,e)}};if(b<=1&&(P(a,g.done(h(c)).resolve,g.reject,!b),"pending"===g.state()||r.isFunction(e[c]&&e[c].then)))return g.then();while(c--)P(e[c],h(c),g.reject);return g.promise()}});var Q=/^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;r.Deferred.exceptionHook=function(b,c){a.console&&a.console.warn&&b&&Q.test(b.name)&&a.console.warn("jQuery.Deferred exception: "+b.message,b.stack,c)},r.readyException=function(b){a.setTimeout(function(){throw b})};var R=r.Deferred();r.fn.ready=function(a){return R.then(a)["catch"](function(a){r.readyException(a)}),this},r.extend({isReady:!1,readyWait:1,ready:function(a){(a===!0?--r.readyWait:r.isReady)||(r.isReady=!0,a!==!0&&--r.readyWait>0||R.resolveWith(d,[r]))}}),r.ready.then=R.then;function S(){d.removeEventListener("DOMContentLoaded",S),
-a.removeEventListener("load",S),r.ready()}"complete"===d.readyState||"loading"!==d.readyState&&!d.documentElement.doScroll?a.setTimeout(r.ready):(d.addEventListener("DOMContentLoaded",S),a.addEventListener("load",S));var T=function(a,b,c,d,e,f,g){var h=0,i=a.length,j=null==c;if("object"===r.type(c)){e=!0;for(h in c)T(a,b,h,c[h],!0,f,g)}else if(void 0!==d&&(e=!0,r.isFunction(d)||(g=!0),j&&(g?(b.call(a,d),b=null):(j=b,b=function(a,b,c){return j.call(r(a),c)})),b))for(;h<i;h++)b(a[h],c,g?d:d.call(a[h],h,b(a[h],c)));return e?a:j?b.call(a):i?b(a[0],c):f},U=function(a){return 1===a.nodeType||9===a.nodeType||!+a.nodeType};function V(){this.expando=r.expando+V.uid++}V.uid=1,V.prototype={cache:function(a){var b=a[this.expando];return b||(b={},U(a)&&(a.nodeType?a[this.expando]=b:Object.defineProperty(a,this.expando,{value:b,configurable:!0}))),b},set:function(a,b,c){var d,e=this.cache(a);if("string"==typeof b)e[r.camelCase(b)]=c;else for(d in b)e[r.camelCase(d)]=b[d];return e},get:function(a,b){return void 0===b?this.cache(a):a[this.expando]&&a[this.expando][r.camelCase(b)]},access:function(a,b,c){return void 0===b||b&&"string"==typeof b&&void 0===c?this.get(a,b):(this.set(a,b,c),void 0!==c?c:b)},remove:function(a,b){var c,d=a[this.expando];if(void 0!==d){if(void 0!==b){Array.isArray(b)?b=b.map(r.camelCase):(b=r.camelCase(b),b=b in d?[b]:b.match(L)||[]),c=b.length;while(c--)delete d[b[c]]}(void 0===b||r.isEmptyObject(d))&&(a.nodeType?a[this.expando]=void 0:delete a[this.expando])}},hasData:function(a){var b=a[this.expando];return void 0!==b&&!r.isEmptyObject(b)}};var W=new V,X=new V,Y=/^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,Z=/[A-Z]/g;function $(a){return"true"===a||"false"!==a&&("null"===a?null:a===+a+""?+a:Y.test(a)?JSON.parse(a):a)}function _(a,b,c){var d;if(void 0===c&&1===a.nodeType)if(d="data-"+b.replace(Z,"-$&").toLowerCase(),c=a.getAttribute(d),"string"==typeof c){try{c=$(c)}catch(e){}X.set(a,b,c)}else c=void 0;return c}r.extend({hasData:function(a){return X.hasData(a)||W.hasData(a)},data:function(a,b,c){return X.access(a,b,c)},removeData:function(a,b){X.remove(a,b)},_data:function(a,b,c){return W.access(a,b,c)},_removeData:function(a,b){W.remove(a,b)}}),r.fn.extend({data:function(a,b){var c,d,e,f=this[0],g=f&&f.attributes;if(void 0===a){if(this.length&&(e=X.get(f),1===f.nodeType&&!W.get(f,"hasDataAttrs"))){c=g.length;while(c--)g[c]&&(d=g[c].name,0===d.indexOf("data-")&&(d=r.camelCase(d.slice(5)),_(f,d,e[d])));W.set(f,"hasDataAttrs",!0)}return e}return"object"==typeof a?this.each(function(){X.set(this,a)}):T(this,function(b){var c;if(f&&void 0===b){if(c=X.get(f,a),void 0!==c)return c;if(c=_(f,a),void 0!==c)return c}else this.each(function(){X.set(this,a,b)})},null,b,arguments.length>1,null,!0)},removeData:function(a){return this.each(function(){X.remove(this,a)})}}),r.extend({queue:function(a,b,c){var d;if(a)return b=(b||"fx")+"queue",d=W.get(a,b),c&&(!d||Array.isArray(c)?d=W.access(a,b,r.makeArray(c)):d.push(c)),d||[]},dequeue:function(a,b){b=b||"fx";var c=r.queue(a,b),d=c.length,e=c.shift(),f=r._queueHooks(a,b),g=function(){r.dequeue(a,b)};"inprogress"===e&&(e=c.shift(),d--),e&&("fx"===b&&c.unshift("inprogress"),delete f.stop,e.call(a,g,f)),!d&&f&&f.empty.fire()},_queueHooks:function(a,b){var c=b+"queueHooks";return W.get(a,c)||W.access(a,c,{empty:r.Callbacks("once memory").add(function(){W.remove(a,[b+"queue",c])})})}}),r.fn.extend({queue:function(a,b){var c=2;return"string"!=typeof a&&(b=a,a="fx",c--),arguments.length<c?r.queue(this[0],a):void 0===b?this:this.each(function(){var c=r.queue(this,a,b);r._queueHooks(this,a),"fx"===a&&"inprogress"!==c[0]&&r.dequeue(this,a)})},dequeue:function(a){return this.each(function(){r.dequeue(this,a)})},clearQueue:function(a){return this.queue(a||"fx",[])},promise:function(a,b){var c,d=1,e=r.Deferred(),f=this,g=this.length,h=function(){--d||e.resolveWith(f,[f])};"string"!=typeof a&&(b=a,a=void 0),a=a||"fx";while(g--)c=W.get(f[g],a+"queueHooks"),c&&c.empty&&(d++,c.empty.add(h));return h(),e.promise(b)}});var aa=/[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source,ba=new RegExp("^(?:([+-])=|)("+aa+")([a-z%]*)$","i"),ca=["Top","Right","Bottom","Left"],da=function(a,b){return a=b||a,"none"===a.style.display||""===a.style.display&&r.contains(a.ownerDocument,a)&&"none"===r.css(a,"display")},ea=function(a,b,c,d){var e,f,g={};for(f in b)g[f]=a.style[f],a.style[f]=b[f];e=c.apply(a,d||[]);for(f in b)a.style[f]=g[f];return e};function fa(a,b,c,d){var e,f=1,g=20,h=d?function(){return d.cur()}:function(){return r.css(a,b,"")},i=h(),j=c&&c[3]||(r.cssNumber[b]?"":"px"),k=(r.cssNumber[b]||"px"!==j&&+i)&&ba.exec(r.css(a,b));if(k&&k[3]!==j){j=j||k[3],c=c||[],k=+i||1;do f=f||".5",k/=f,r.style(a,b,k+j);while(f!==(f=h()/i)&&1!==f&&--g)}return c&&(k=+k||+i||0,e=c[1]?k+(c[1]+1)*c[2]:+c[2],d&&(d.unit=j,d.start=k,d.end=e)),e}var ga={};function ha(a){var b,c=a.ownerDocument,d=a.nodeName,e=ga[d];return e?e:(b=c.body.appendChild(c.createElement(d)),e=r.css(b,"display"),b.parentNode.removeChild(b),"none"===e&&(e="block"),ga[d]=e,e)}function ia(a,b){for(var c,d,e=[],f=0,g=a.length;f<g;f++)d=a[f],d.style&&(c=d.style.display,b?("none"===c&&(e[f]=W.get(d,"display")||null,e[f]||(d.style.display="")),""===d.style.display&&da(d)&&(e[f]=ha(d))):"none"!==c&&(e[f]="none",W.set(d,"display",c)));for(f=0;f<g;f++)null!=e[f]&&(a[f].style.display=e[f]);return a}r.fn.extend({show:function(){return ia(this,!0)},hide:function(){return ia(this)},toggle:function(a){return"boolean"==typeof a?a?this.show():this.hide():this.each(function(){da(this)?r(this).show():r(this).hide()})}});var ja=/^(?:checkbox|radio)$/i,ka=/<([a-z][^\/\0>\x20\t\r\n\f]+)/i,la=/^$|\/(?:java|ecma)script/i,ma={option:[1,"<select multiple='multiple'>","</select>"],thead:[1,"<table>","</table>"],col:[2,"<table><colgroup>","</colgroup></table>"],tr:[2,"<table><tbody>","</tbody></table>"],td:[3,"<table><tbody><tr>","</tr></tbody></table>"],_default:[0,"",""]};ma.optgroup=ma.option,ma.tbody=ma.tfoot=ma.colgroup=ma.caption=ma.thead,ma.th=ma.td;function na(a,b){var c;return c="undefined"!=typeof a.getElementsByTagName?a.getElementsByTagName(b||"*"):"undefined"!=typeof a.querySelectorAll?a.querySelectorAll(b||"*"):[],void 0===b||b&&B(a,b)?r.merge([a],c):c}function oa(a,b){for(var c=0,d=a.length;c<d;c++)W.set(a[c],"globalEval",!b||W.get(b[c],"globalEval"))}var pa=/<|&#?\w+;/;function qa(a,b,c,d,e){for(var f,g,h,i,j,k,l=b.createDocumentFragment(),m=[],n=0,o=a.length;n<o;n++)if(f=a[n],f||0===f)if("object"===r.type(f))r.merge(m,f.nodeType?[f]:f);else if(pa.test(f)){g=g||l.appendChild(b.createElement("div")),h=(ka.exec(f)||["",""])[1].toLowerCase(),i=ma[h]||ma._default,g.innerHTML=i[1]+r.htmlPrefilter(f)+i[2],k=i[0];while(k--)g=g.lastChild;r.merge(m,g.childNodes),g=l.firstChild,g.textContent=""}else m.push(b.createTextNode(f));l.textContent="",n=0;while(f=m[n++])if(d&&r.inArray(f,d)>-1)e&&e.push(f);else if(j=r.contains(f.ownerDocument,f),g=na(l.appendChild(f),"script"),j&&oa(g),c){k=0;while(f=g[k++])la.test(f.type||"")&&c.push(f)}return l}!function(){var a=d.createDocumentFragment(),b=a.appendChild(d.createElement("div")),c=d.createElement("input");c.setAttribute("type","radio"),c.setAttribute("checked","checked"),c.setAttribute("name","t"),b.appendChild(c),o.checkClone=b.cloneNode(!0).cloneNode(!0).lastChild.checked,b.innerHTML="<textarea>x</textarea>",o.noCloneChecked=!!b.cloneNode(!0).lastChild.defaultValue}();var ra=d.documentElement,sa=/^key/,ta=/^(?:mouse|pointer|contextmenu|drag|drop)|click/,ua=/^([^.]*)(?:\.(.+)|)/;function va(){return!0}function wa(){return!1}function xa(){try{return d.activeElement}catch(a){}}function ya(a,b,c,d,e,f){var g,h;if("object"==typeof b){"string"!=typeof c&&(d=d||c,c=void 0);for(h in b)ya(a,h,c,d,b[h],f);return a}if(null==d&&null==e?(e=c,d=c=void 0):null==e&&("string"==typeof c?(e=d,d=void 0):(e=d,d=c,c=void 0)),e===!1)e=wa;else if(!e)return a;return 1===f&&(g=e,e=function(a){return r().off(a),g.apply(this,arguments)},e.guid=g.guid||(g.guid=r.guid++)),a.each(function(){r.event.add(this,b,e,d,c)})}r.event={global:{},add:function(a,b,c,d,e){var f,g,h,i,j,k,l,m,n,o,p,q=W.get(a);if(q){c.handler&&(f=c,c=f.handler,e=f.selector),e&&r.find.matchesSelector(ra,e),c.guid||(c.guid=r.guid++),(i=q.events)||(i=q.events={}),(g=q.handle)||(g=q.handle=function(b){return"undefined"!=typeof r&&r.event.triggered!==b.type?r.event.dispatch.apply(a,arguments):void 0}),b=(b||"").match(L)||[""],j=b.length;while(j--)h=ua.exec(b[j])||[],n=p=h[1],o=(h[2]||"").split(".").sort(),n&&(l=r.event.special[n]||{},n=(e?l.delegateType:l.bindType)||n,l=r.event.special[n]||{},k=r.extend({type:n,origType:p,data:d,handler:c,guid:c.guid,selector:e,needsContext:e&&r.expr.match.needsContext.test(e),namespace:o.join(".")},f),(m=i[n])||(m=i[n]=[],m.delegateCount=0,l.setup&&l.setup.call(a,d,o,g)!==!1||a.addEventListener&&a.addEventListener(n,g)),l.add&&(l.add.call(a,k),k.handler.guid||(k.handler.guid=c.guid)),e?m.splice(m.delegateCount++,0,k):m.push(k),r.event.global[n]=!0)}},remove:function(a,b,c,d,e){var f,g,h,i,j,k,l,m,n,o,p,q=W.hasData(a)&&W.get(a);if(q&&(i=q.events)){b=(b||"").match(L)||[""],j=b.length;while(j--)if(h=ua.exec(b[j])||[],n=p=h[1],o=(h[2]||"").split(".").sort(),n){l=r.event.special[n]||{},n=(d?l.delegateType:l.bindType)||n,m=i[n]||[],h=h[2]&&new RegExp("(^|\\.)"+o.join("\\.(?:.*\\.|)")+"(\\.|$)"),g=f=m.length;while(f--)k=m[f],!e&&p!==k.origType||c&&c.guid!==k.guid||h&&!h.test(k.namespace)||d&&d!==k.selector&&("**"!==d||!k.selector)||(m.splice(f,1),k.selector&&m.delegateCount--,l.remove&&l.remove.call(a,k));g&&!m.length&&(l.teardown&&l.teardown.call(a,o,q.handle)!==!1||r.removeEvent(a,n,q.handle),delete i[n])}else for(n in i)r.event.remove(a,n+b[j],c,d,!0);r.isEmptyObject(i)&&W.remove(a,"handle events")}},dispatch:function(a){var b=r.event.fix(a),c,d,e,f,g,h,i=new Array(arguments.length),j=(W.get(this,"events")||{})[b.type]||[],k=r.event.special[b.type]||{};for(i[0]=b,c=1;c<arguments.length;c++)i[c]=arguments[c];if(b.delegateTarget=this,!k.preDispatch||k.preDispatch.call(this,b)!==!1){h=r.event.handlers.call(this,b,j),c=0;while((f=h[c++])&&!b.isPropagationStopped()){b.currentTarget=f.elem,d=0;while((g=f.handlers[d++])&&!b.isImmediatePropagationStopped())b.rnamespace&&!b.rnamespace.test(g.namespace)||(b.handleObj=g,b.data=g.data,e=((r.event.special[g.origType]||{}).handle||g.handler).apply(f.elem,i),void 0!==e&&(b.result=e)===!1&&(b.preventDefault(),b.stopPropagation()))}return k.postDispatch&&k.postDispatch.call(this,b),b.result}},handlers:function(a,b){var c,d,e,f,g,h=[],i=b.delegateCount,j=a.target;if(i&&j.nodeType&&!("click"===a.type&&a.button>=1))for(;j!==this;j=j.parentNode||this)if(1===j.nodeType&&("click"!==a.type||j.disabled!==!0)){for(f=[],g={},c=0;c<i;c++)d=b[c],e=d.selector+" ",void 0===g[e]&&(g[e]=d.needsContext?r(e,this).index(j)>-1:r.find(e,this,null,[j]).length),g[e]&&f.push(d);f.length&&h.push({elem:j,handlers:f})}return j=this,i<b.length&&h.push({elem:j,handlers:b.slice(i)}),h},addProp:function(a,b){Object.defineProperty(r.Event.prototype,a,{enumerable:!0,configurable:!0,get:r.isFunction(b)?function(){if(this.originalEvent)return b(this.originalEvent)}:function(){if(this.originalEvent)return this.originalEvent[a]},set:function(b){Object.defineProperty(this,a,{enumerable:!0,configurable:!0,writable:!0,value:b})}})},fix:function(a){return a[r.expando]?a:new r.Event(a)},special:{load:{noBubble:!0},focus:{trigger:function(){if(this!==xa()&&this.focus)return this.focus(),!1},delegateType:"focusin"},blur:{trigger:function(){if(this===xa()&&this.blur)return this.blur(),!1},delegateType:"focusout"},click:{trigger:function(){if("checkbox"===this.type&&this.click&&B(this,"input"))return this.click(),!1},_default:function(a){return B(a.target,"a")}},beforeunload:{postDispatch:function(a){void 0!==a.result&&a.originalEvent&&(a.originalEvent.returnValue=a.result)}}}},r.removeEvent=function(a,b,c){a.removeEventListener&&a.removeEventListener(b,c)},r.Event=function(a,b){return this instanceof r.Event?(a&&a.type?(this.originalEvent=a,this.type=a.type,this.isDefaultPrevented=a.defaultPrevented||void 0===a.defaultPrevented&&a.returnValue===!1?va:wa,this.target=a.target&&3===a.target.nodeType?a.target.parentNode:a.target,this.currentTarget=a.currentTarget,this.relatedTarget=a.relatedTarget):this.type=a,b&&r.extend(this,b),this.timeStamp=a&&a.timeStamp||r.now(),void(this[r.expando]=!0)):new r.Event(a,b)},r.Event.prototype={constructor:r.Event,isDefaultPrevented:wa,isPropagationStopped:wa,isImmediatePropagationStopped:wa,isSimulated:!1,preventDefault:function(){var a=this.originalEvent;this.isDefaultPrevented=va,a&&!this.isSimulated&&a.preventDefault()},stopPropagation:function(){var a=this.originalEvent;this.isPropagationStopped=va,a&&!this.isSimulated&&a.stopPropagation()},stopImmediatePropagation:function(){var a=this.originalEvent;this.isImmediatePropagationStopped=va,a&&!this.isSimulated&&a.stopImmediatePropagation(),this.stopPropagation()}},r.each({altKey:!0,bubbles:!0,cancelable:!0,changedTouches:!0,ctrlKey:!0,detail:!0,eventPhase:!0,metaKey:!0,pageX:!0,pageY:!0,shiftKey:!0,view:!0,"char":!0,charCode:!0,key:!0,keyCode:!0,button:!0,buttons:!0,clientX:!0,clientY:!0,offsetX:!0,offsetY:!0,pointerId:!0,pointerType:!0,screenX:!0,screenY:!0,targetTouches:!0,toElement:!0,touches:!0,which:function(a){var b=a.button;return null==a.which&&sa.test(a.type)?null!=a.charCode?a.charCode:a.keyCode:!a.which&&void 0!==b&&ta.test(a.type)?1&b?1:2&b?3:4&b?2:0:a.which}},r.event.addProp),r.each({mouseenter:"mouseover",mouseleave:"mouseout",pointerenter:"pointerover",pointerleave:"pointerout"},function(a,b){r.event.special[a]={delegateType:b,bindType:b,handle:function(a){var c,d=this,e=a.relatedTarget,f=a.handleObj;return e&&(e===d||r.contains(d,e))||(a.type=f.origType,c=f.handler.apply(this,arguments),a.type=b),c}}}),r.fn.extend({on:function(a,b,c,d){return ya(this,a,b,c,d)},one:function(a,b,c,d){return ya(this,a,b,c,d,1)},off:function(a,b,c){var d,e;if(a&&a.preventDefault&&a.handleObj)return d=a.handleObj,r(a.delegateTarget).off(d.namespace?d.origType+"."+d.namespace:d.origType,d.selector,d.handler),this;if("object"==typeof a){for(e in a)this.off(e,b,a[e]);return this}return b!==!1&&"function"!=typeof b||(c=b,b=void 0),c===!1&&(c=wa),this.each(function(){r.event.remove(this,a,c,b)})}});var za=/<(?!area|br|col|embed|hr|img|input|link|meta|param)(([a-z][^\/\0>\x20\t\r\n\f]*)[^>]*)\/>/gi,Aa=/<script|<style|<link/i,Ba=/checked\s*(?:[^=]|=\s*.checked.)/i,Ca=/^true\/(.*)/,Da=/^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g;function Ea(a,b){return B(a,"table")&&B(11!==b.nodeType?b:b.firstChild,"tr")?r(">tbody",a)[0]||a:a}function Fa(a){return a.type=(null!==a.getAttribute("type"))+"/"+a.type,a}function Ga(a){var b=Ca.exec(a.type);return b?a.type=b[1]:a.removeAttribute("type"),a}function Ha(a,b){var c,d,e,f,g,h,i,j;if(1===b.nodeType){if(W.hasData(a)&&(f=W.access(a),g=W.set(b,f),j=f.events)){delete g.handle,g.events={};for(e in j)for(c=0,d=j[e].length;c<d;c++)r.event.add(b,e,j[e][c])}X.hasData(a)&&(h=X.access(a),i=r.extend({},h),X.set(b,i))}}function Ia(a,b){var c=b.nodeName.toLowerCase();"input"===c&&ja.test(a.type)?b.checked=a.checked:"input"!==c&&"textarea"!==c||(b.defaultValue=a.defaultValue)}function Ja(a,b,c,d){b=g.apply([],b);var e,f,h,i,j,k,l=0,m=a.length,n=m-1,q=b[0],s=r.isFunction(q);if(s||m>1&&"string"==typeof q&&!o.checkClone&&Ba.test(q))return a.each(function(e){var f=a.eq(e);s&&(b[0]=q.call(this,e,f.html())),Ja(f,b,c,d)});if(m&&(e=qa(b,a[0].ownerDocument,!1,a,d),f=e.firstChild,1===e.childNodes.length&&(e=f),f||d)){for(h=r.map(na(e,"script"),Fa),i=h.length;l<m;l++)j=e,l!==n&&(j=r.clone(j,!0,!0),i&&r.merge(h,na(j,"script"))),c.call(a[l],j,l);if(i)for(k=h[h.length-1].ownerDocument,r.map(h,Ga),l=0;l<i;l++)j=h[l],la.test(j.type||"")&&!W.access(j,"globalEval")&&r.contains(k,j)&&(j.src?r._evalUrl&&r._evalUrl(j.src):p(j.textContent.replace(Da,""),k))}return a}function Ka(a,b,c){for(var d,e=b?r.filter(b,a):a,f=0;null!=(d=e[f]);f++)c||1!==d.nodeType||r.cleanData(na(d)),d.parentNode&&(c&&r.contains(d.ownerDocument,d)&&oa(na(d,"script")),d.parentNode.removeChild(d));return a}r.extend({htmlPrefilter:function(a){return a.replace(za,"<$1></$2>")},clone:function(a,b,c){var d,e,f,g,h=a.cloneNode(!0),i=r.contains(a.ownerDocument,a);if(!(o.noCloneChecked||1!==a.nodeType&&11!==a.nodeType||r.isXMLDoc(a)))for(g=na(h),f=na(a),d=0,e=f.length;d<e;d++)Ia(f[d],g[d]);if(b)if(c)for(f=f||na(a),g=g||na(h),d=0,e=f.length;d<e;d++)Ha(f[d],g[d]);else Ha(a,h);return g=na(h,"script"),g.length>0&&oa(g,!i&&na(a,"script")),h},cleanData:function(a){for(var b,c,d,e=r.event.special,f=0;void 0!==(c=a[f]);f++)if(U(c)){if(b=c[W.expando]){if(b.events)for(d in b.events)e[d]?r.event.remove(c,d):r.removeEvent(c,d,b.handle);c[W.expando]=void 0}c[X.expando]&&(c[X.expando]=void 0)}}}),r.fn.extend({detach:function(a){return Ka(this,a,!0)},remove:function(a){return Ka(this,a)},text:function(a){return T(this,function(a){return void 0===a?r.text(this):this.empty().each(function(){1!==this.nodeType&&11!==this.nodeType&&9!==this.nodeType||(this.textContent=a)})},null,a,arguments.length)},append:function(){return Ja(this,arguments,function(a){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var b=Ea(this,a);b.appendChild(a)}})},prepend:function(){return Ja(this,arguments,function(a){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var b=Ea(this,a);b.insertBefore(a,b.firstChild)}})},before:function(){return Ja(this,arguments,function(a){this.parentNode&&this.parentNode.insertBefore(a,this)})},after:function(){return Ja(this,arguments,function(a){this.parentNode&&this.parentNode.insertBefore(a,this.nextSibling)})},empty:function(){for(var a,b=0;null!=(a=this[b]);b++)1===a.nodeType&&(r.cleanData(na(a,!1)),a.textContent="");return this},clone:function(a,b){return a=null!=a&&a,b=null==b?a:b,this.map(function(){return r.clone(this,a,b)})},html:function(a){return T(this,function(a){var b=this[0]||{},c=0,d=this.length;if(void 0===a&&1===b.nodeType)return b.innerHTML;if("string"==typeof a&&!Aa.test(a)&&!ma[(ka.exec(a)||["",""])[1].toLowerCase()]){a=r.htmlPrefilter(a);try{for(;c<d;c++)b=this[c]||{},1===b.nodeType&&(r.cleanData(na(b,!1)),b.innerHTML=a);b=0}catch(e){}}b&&this.empty().append(a)},null,a,arguments.length)},replaceWith:function(){var a=[];return Ja(this,arguments,function(b){var c=this.parentNode;r.inArray(this,a)<0&&(r.cleanData(na(this)),c&&c.replaceChild(b,this))},a)}}),r.each({appendTo:"append",prependTo:"prepend",insertBefore:"before",insertAfter:"after",replaceAll:"replaceWith"},function(a,b){r.fn[a]=function(a){for(var c,d=[],e=r(a),f=e.length-1,g=0;g<=f;g++)c=g===f?this:this.clone(!0),r(e[g])[b](c),h.apply(d,c.get());return this.pushStack(d)}});var La=/^margin/,Ma=new RegExp("^("+aa+")(?!px)[a-z%]+$","i"),Na=function(b){var c=b.ownerDocument.defaultView;return c&&c.opener||(c=a),c.getComputedStyle(b)};!function(){function b(){if(i){i.style.cssText="box-sizing:border-box;position:relative;display:block;margin:auto;border:1px;padding:1px;top:1%;width:50%",i.innerHTML="",ra.appendChild(h);var b=a.getComputedStyle(i);c="1%"!==b.top,g="2px"===b.marginLeft,e="4px"===b.width,i.style.marginRight="50%",f="4px"===b.marginRight,ra.removeChild(h),i=null}}var c,e,f,g,h=d.createElement("div"),i=d.createElement("div");i.style&&(i.style.backgroundClip="content-box",i.cloneNode(!0).style.backgroundClip="",o.clearCloneStyle="content-box"===i.style.backgroundClip,h.style.cssText="border:0;width:8px;height:0;top:0;left:-9999px;padding:0;margin-top:1px;position:absolute",h.appendChild(i),r.extend(o,{pixelPosition:function(){return b(),c},boxSizingReliable:function(){return b(),e},pixelMarginRight:function(){return b(),f},reliableMarginLeft:function(){return b(),g}}))}();function Oa(a,b,c){var d,e,f,g,h=a.style;return c=c||Na(a),c&&(g=c.getPropertyValue(b)||c[b],""!==g||r.contains(a.ownerDocument,a)||(g=r.style(a,b)),!o.pixelMarginRight()&&Ma.test(g)&&La.test(b)&&(d=h.width,e=h.minWidth,f=h.maxWidth,h.minWidth=h.maxWidth=h.width=g,g=c.width,h.width=d,h.minWidth=e,h.maxWidth=f)),void 0!==g?g+"":g}function Pa(a,b){return{get:function(){return a()?void delete this.get:(this.get=b).apply(this,arguments)}}}var Qa=/^(none|table(?!-c[ea]).+)/,Ra=/^--/,Sa={position:"absolute",visibility:"hidden",display:"block"},Ta={letterSpacing:"0",fontWeight:"400"},Ua=["Webkit","Moz","ms"],Va=d.createElement("div").style;function Wa(a){if(a in Va)return a;var b=a[0].toUpperCase()+a.slice(1),c=Ua.length;while(c--)if(a=Ua[c]+b,a in Va)return a}function Xa(a){var b=r.cssProps[a];return b||(b=r.cssProps[a]=Wa(a)||a),b}function Ya(a,b,c){var d=ba.exec(b);return d?Math.max(0,d[2]-(c||0))+(d[3]||"px"):b}function Za(a,b,c,d,e){var f,g=0;for(f=c===(d?"border":"content")?4:"width"===b?1:0;f<4;f+=2)"margin"===c&&(g+=r.css(a,c+ca[f],!0,e)),d?("content"===c&&(g-=r.css(a,"padding"+ca[f],!0,e)),"margin"!==c&&(g-=r.css(a,"border"+ca[f]+"Width",!0,e))):(g+=r.css(a,"padding"+ca[f],!0,e),"padding"!==c&&(g+=r.css(a,"border"+ca[f]+"Width",!0,e)));return g}function $a(a,b,c){var d,e=Na(a),f=Oa(a,b,e),g="border-box"===r.css(a,"boxSizing",!1,e);return Ma.test(f)?f:(d=g&&(o.boxSizingReliable()||f===a.style[b]),"auto"===f&&(f=a["offset"+b[0].toUpperCase()+b.slice(1)]),f=parseFloat(f)||0,f+Za(a,b,c||(g?"border":"content"),d,e)+"px")}r.extend({cssHooks:{opacity:{get:function(a,b){if(b){var c=Oa(a,"opacity");return""===c?"1":c}}}},cssNumber:{animationIterationCount:!0,columnCount:!0,fillOpacity:!0,flexGrow:!0,flexShrink:!0,fontWeight:!0,lineHeight:!0,opacity:!0,order:!0,orphans:!0,widows:!0,zIndex:!0,zoom:!0},cssProps:{"float":"cssFloat"},style:function(a,b,c,d){if(a&&3!==a.nodeType&&8!==a.nodeType&&a.style){var e,f,g,h=r.camelCase(b),i=Ra.test(b),j=a.style;return i||(b=Xa(h)),g=r.cssHooks[b]||r.cssHooks[h],void 0===c?g&&"get"in g&&void 0!==(e=g.get(a,!1,d))?e:j[b]:(f=typeof c,"string"===f&&(e=ba.exec(c))&&e[1]&&(c=fa(a,b,e),f="number"),null!=c&&c===c&&("number"===f&&(c+=e&&e[3]||(r.cssNumber[h]?"":"px")),o.clearCloneStyle||""!==c||0!==b.indexOf("background")||(j[b]="inherit"),g&&"set"in g&&void 0===(c=g.set(a,c,d))||(i?j.setProperty(b,c):j[b]=c)),void 0)}},css:function(a,b,c,d){var e,f,g,h=r.camelCase(b),i=Ra.test(b);return i||(b=Xa(h)),g=r.cssHooks[b]||r.cssHooks[h],g&&"get"in g&&(e=g.get(a,!0,c)),void 0===e&&(e=Oa(a,b,d)),"normal"===e&&b in Ta&&(e=Ta[b]),""===c||c?(f=parseFloat(e),c===!0||isFinite(f)?f||0:e):e}}),r.each(["height","width"],function(a,b){r.cssHooks[b]={get:function(a,c,d){if(c)return!Qa.test(r.css(a,"display"))||a.getClientRects().length&&a.getBoundingClientRect().width?$a(a,b,d):ea(a,Sa,function(){return $a(a,b,d)})},set:function(a,c,d){var e,f=d&&Na(a),g=d&&Za(a,b,d,"border-box"===r.css(a,"boxSizing",!1,f),f);return g&&(e=ba.exec(c))&&"px"!==(e[3]||"px")&&(a.style[b]=c,c=r.css(a,b)),Ya(a,c,g)}}}),r.cssHooks.marginLeft=Pa(o.reliableMarginLeft,function(a,b){if(b)return(parseFloat(Oa(a,"marginLeft"))||a.getBoundingClientRect().left-ea(a,{marginLeft:0},function(){return a.getBoundingClientRect().left}))+"px"}),r.each({margin:"",padding:"",border:"Width"},function(a,b){r.cssHooks[a+b]={expand:function(c){for(var d=0,e={},f="string"==typeof c?c.split(" "):[c];d<4;d++)e[a+ca[d]+b]=f[d]||f[d-2]||f[0];return e}},La.test(a)||(r.cssHooks[a+b].set=Ya)}),r.fn.extend({css:function(a,b){return T(this,function(a,b,c){var d,e,f={},g=0;if(Array.isArray(b)){for(d=Na(a),e=b.length;g<e;g++)f[b[g]]=r.css(a,b[g],!1,d);return f}return void 0!==c?r.style(a,b,c):r.css(a,b)},a,b,arguments.length>1)}});function _a(a,b,c,d,e){return new _a.prototype.init(a,b,c,d,e)}r.Tween=_a,_a.prototype={constructor:_a,init:function(a,b,c,d,e,f){this.elem=a,this.prop=c,this.easing=e||r.easing._default,this.options=b,this.start=this.now=this.cur(),this.end=d,this.unit=f||(r.cssNumber[c]?"":"px")},cur:function(){var a=_a.propHooks[this.prop];return a&&a.get?a.get(this):_a.propHooks._default.get(this)},run:function(a){var b,c=_a.propHooks[this.prop];return this.options.duration?this.pos=b=r.easing[this.easing](a,this.options.duration*a,0,1,this.options.duration):this.pos=b=a,this.now=(this.end-this.start)*b+this.start,this.options.step&&this.options.step.call(this.elem,this.now,this),c&&c.set?c.set(this):_a.propHooks._default.set(this),this}},_a.prototype.init.prototype=_a.prototype,_a.propHooks={_default:{get:function(a){var b;return 1!==a.elem.nodeType||null!=a.elem[a.prop]&&null==a.elem.style[a.prop]?a.elem[a.prop]:(b=r.css(a.elem,a.prop,""),b&&"auto"!==b?b:0)},set:function(a){r.fx.step[a.prop]?r.fx.step[a.prop](a):1!==a.elem.nodeType||null==a.elem.style[r.cssProps[a.prop]]&&!r.cssHooks[a.prop]?a.elem[a.prop]=a.now:r.style(a.elem,a.prop,a.now+a.unit)}}},_a.propHooks.scrollTop=_a.propHooks.scrollLeft={set:function(a){a.elem.nodeType&&a.elem.parentNode&&(a.elem[a.prop]=a.now)}},r.easing={linear:function(a){return a},swing:function(a){return.5-Math.cos(a*Math.PI)/2},_default:"swing"},r.fx=_a.prototype.init,r.fx.step={};var ab,bb,cb=/^(?:toggle|show|hide)$/,db=/queueHooks$/;function eb(){bb&&(d.hidden===!1&&a.requestAnimationFrame?a.requestAnimationFrame(eb):a.setTimeout(eb,r.fx.interval),r.fx.tick())}function fb(){return a.setTimeout(function(){ab=void 0}),ab=r.now()}function gb(a,b){var c,d=0,e={height:a};for(b=b?1:0;d<4;d+=2-b)c=ca[d],e["margin"+c]=e["padding"+c]=a;return b&&(e.opacity=e.width=a),e}function hb(a,b,c){for(var d,e=(kb.tweeners[b]||[]).concat(kb.tweeners["*"]),f=0,g=e.length;f<g;f++)if(d=e[f].call(c,b,a))return d}function ib(a,b,c){var d,e,f,g,h,i,j,k,l="width"in b||"height"in b,m=this,n={},o=a.style,p=a.nodeType&&da(a),q=W.get(a,"fxshow");c.queue||(g=r._queueHooks(a,"fx"),null==g.unqueued&&(g.unqueued=0,h=g.empty.fire,g.empty.fire=function(){g.unqueued||h()}),g.unqueued++,m.always(function(){m.always(function(){g.unqueued--,r.queue(a,"fx").length||g.empty.fire()})}));for(d in b)if(e=b[d],cb.test(e)){if(delete b[d],f=f||"toggle"===e,e===(p?"hide":"show")){if("show"!==e||!q||void 0===q[d])continue;p=!0}n[d]=q&&q[d]||r.style(a,d)}if(i=!r.isEmptyObject(b),i||!r.isEmptyObject(n)){l&&1===a.nodeType&&(c.overflow=[o.overflow,o.overflowX,o.overflowY],j=q&&q.display,null==j&&(j=W.get(a,"display")),k=r.css(a,"display"),"none"===k&&(j?k=j:(ia([a],!0),j=a.style.display||j,k=r.css(a,"display"),ia([a]))),("inline"===k||"inline-block"===k&&null!=j)&&"none"===r.css(a,"float")&&(i||(m.done(function(){o.display=j}),null==j&&(k=o.display,j="none"===k?"":k)),o.display="inline-block")),c.overflow&&(o.overflow="hidden",m.always(function(){o.overflow=c.overflow[0],o.overflowX=c.overflow[1],o.overflowY=c.overflow[2]})),i=!1;for(d in n)i||(q?"hidden"in q&&(p=q.hidden):q=W.access(a,"fxshow",{display:j}),f&&(q.hidden=!p),p&&ia([a],!0),m.done(function(){p||ia([a]),W.remove(a,"fxshow");for(d in n)r.style(a,d,n[d])})),i=hb(p?q[d]:0,d,m),d in q||(q[d]=i.start,p&&(i.end=i.start,i.start=0))}}function jb(a,b){var c,d,e,f,g;for(c in a)if(d=r.camelCase(c),e=b[d],f=a[c],Array.isArray(f)&&(e=f[1],f=a[c]=f[0]),c!==d&&(a[d]=f,delete a[c]),g=r.cssHooks[d],g&&"expand"in g){f=g.expand(f),delete a[d];for(c in f)c in a||(a[c]=f[c],b[c]=e)}else b[d]=e}function kb(a,b,c){var d,e,f=0,g=kb.prefilters.length,h=r.Deferred().always(function(){delete i.elem}),i=function(){if(e)return!1;for(var b=ab||fb(),c=Math.max(0,j.startTime+j.duration-b),d=c/j.duration||0,f=1-d,g=0,i=j.tweens.length;g<i;g++)j.tweens[g].run(f);return h.notifyWith(a,[j,f,c]),f<1&&i?c:(i||h.notifyWith(a,[j,1,0]),h.resolveWith(a,[j]),!1)},j=h.promise({elem:a,props:r.extend({},b),opts:r.extend(!0,{specialEasing:{},easing:r.easing._default},c),originalProperties:b,originalOptions:c,startTime:ab||fb(),duration:c.duration,tweens:[],createTween:function(b,c){var d=r.Tween(a,j.opts,b,c,j.opts.specialEasing[b]||j.opts.easing);return j.tweens.push(d),d},stop:function(b){var c=0,d=b?j.tweens.length:0;if(e)return this;for(e=!0;c<d;c++)j.tweens[c].run(1);return b?(h.notifyWith(a,[j,1,0]),h.resolveWith(a,[j,b])):h.rejectWith(a,[j,b]),this}}),k=j.props;for(jb(k,j.opts.specialEasing);f<g;f++)if(d=kb.prefilters[f].call(j,a,k,j.opts))return r.isFunction(d.stop)&&(r._queueHooks(j.elem,j.opts.queue).stop=r.proxy(d.stop,d)),d;return r.map(k,hb,j),r.isFunction(j.opts.start)&&j.opts.start.call(a,j),j.progress(j.opts.progress).done(j.opts.done,j.opts.complete).fail(j.opts.fail).always(j.opts.always),r.fx.timer(r.extend(i,{elem:a,anim:j,queue:j.opts.queue})),j}r.Animation=r.extend(kb,{tweeners:{"*":[function(a,b){var c=this.createTween(a,b);return fa(c.elem,a,ba.exec(b),c),c}]},tweener:function(a,b){r.isFunction(a)?(b=a,a=["*"]):a=a.match(L);for(var c,d=0,e=a.length;d<e;d++)c=a[d],kb.tweeners[c]=kb.tweeners[c]||[],kb.tweeners[c].unshift(b)},prefilters:[ib],prefilter:function(a,b){b?kb.prefilters.unshift(a):kb.prefilters.push(a)}}),r.speed=function(a,b,c){var d=a&&"object"==typeof a?r.extend({},a):{complete:c||!c&&b||r.isFunction(a)&&a,duration:a,easing:c&&b||b&&!r.isFunction(b)&&b};return r.fx.off?d.duration=0:"number"!=typeof d.duration&&(d.duration in r.fx.speeds?d.duration=r.fx.speeds[d.duration]:d.duration=r.fx.speeds._default),null!=d.queue&&d.queue!==!0||(d.queue="fx"),d.old=d.complete,d.complete=function(){r.isFunction(d.old)&&d.old.call(this),d.queue&&r.dequeue(this,d.queue)},d},r.fn.extend({fadeTo:function(a,b,c,d){return this.filter(da).css("opacity",0).show().end().animate({opacity:b},a,c,d)},animate:function(a,b,c,d){var e=r.isEmptyObject(a),f=r.speed(b,c,d),g=function(){var b=kb(this,r.extend({},a),f);(e||W.get(this,"finish"))&&b.stop(!0)};return g.finish=g,e||f.queue===!1?this.each(g):this.queue(f.queue,g)},stop:function(a,b,c){var d=function(a){var b=a.stop;delete a.stop,b(c)};return"string"!=typeof a&&(c=b,b=a,a=void 0),b&&a!==!1&&this.queue(a||"fx",[]),this.each(function(){var b=!0,e=null!=a&&a+"queueHooks",f=r.timers,g=W.get(this);if(e)g[e]&&g[e].stop&&d(g[e]);else for(e in g)g[e]&&g[e].stop&&db.test(e)&&d(g[e]);for(e=f.length;e--;)f[e].elem!==this||null!=a&&f[e].queue!==a||(f[e].anim.stop(c),b=!1,f.splice(e,1));!b&&c||r.dequeue(this,a)})},finish:function(a){return a!==!1&&(a=a||"fx"),this.each(function(){var b,c=W.get(this),d=c[a+"queue"],e=c[a+"queueHooks"],f=r.timers,g=d?d.length:0;for(c.finish=!0,r.queue(this,a,[]),e&&e.stop&&e.stop.call(this,!0),b=f.length;b--;)f[b].elem===this&&f[b].queue===a&&(f[b].anim.stop(!0),f.splice(b,1));for(b=0;b<g;b++)d[b]&&d[b].finish&&d[b].finish.call(this);delete c.finish})}}),r.each(["toggle","show","hide"],function(a,b){var c=r.fn[b];r.fn[b]=function(a,d,e){return null==a||"boolean"==typeof a?c.apply(this,arguments):this.animate(gb(b,!0),a,d,e)}}),r.each({slideDown:gb("show"),slideUp:gb("hide"),slideToggle:gb("toggle"),fadeIn:{opacity:"show"},fadeOut:{opacity:"hide"},fadeToggle:{opacity:"toggle"}},function(a,b){r.fn[a]=function(a,c,d){return this.animate(b,a,c,d)}}),r.timers=[],r.fx.tick=function(){var a,b=0,c=r.timers;for(ab=r.now();b<c.length;b++)a=c[b],a()||c[b]!==a||c.splice(b--,1);c.length||r.fx.stop(),ab=void 0},r.fx.timer=function(a){r.timers.push(a),r.fx.start()},r.fx.interval=13,r.fx.start=function(){bb||(bb=!0,eb())},r.fx.stop=function(){bb=null},r.fx.speeds={slow:600,fast:200,_default:400},r.fn.delay=function(b,c){return b=r.fx?r.fx.speeds[b]||b:b,c=c||"fx",this.queue(c,function(c,d){var e=a.setTimeout(c,b);d.stop=function(){a.clearTimeout(e)}})},function(){var a=d.createElement("input"),b=d.createElement("select"),c=b.appendChild(d.createElement("option"));a.type="checkbox",o.checkOn=""!==a.value,o.optSelected=c.selected,a=d.createElement("input"),a.value="t",a.type="radio",o.radioValue="t"===a.value}();var lb,mb=r.expr.attrHandle;r.fn.extend({attr:function(a,b){return T(this,r.attr,a,b,arguments.length>1)},removeAttr:function(a){return this.each(function(){r.removeAttr(this,a)})}}),r.extend({attr:function(a,b,c){var d,e,f=a.nodeType;if(3!==f&&8!==f&&2!==f)return"undefined"==typeof a.getAttribute?r.prop(a,b,c):(1===f&&r.isXMLDoc(a)||(e=r.attrHooks[b.toLowerCase()]||(r.expr.match.bool.test(b)?lb:void 0)),void 0!==c?null===c?void r.removeAttr(a,b):e&&"set"in e&&void 0!==(d=e.set(a,c,b))?d:(a.setAttribute(b,c+""),c):e&&"get"in e&&null!==(d=e.get(a,b))?d:(d=r.find.attr(a,b),
-null==d?void 0:d))},attrHooks:{type:{set:function(a,b){if(!o.radioValue&&"radio"===b&&B(a,"input")){var c=a.value;return a.setAttribute("type",b),c&&(a.value=c),b}}}},removeAttr:function(a,b){var c,d=0,e=b&&b.match(L);if(e&&1===a.nodeType)while(c=e[d++])a.removeAttribute(c)}}),lb={set:function(a,b,c){return b===!1?r.removeAttr(a,c):a.setAttribute(c,c),c}},r.each(r.expr.match.bool.source.match(/\w+/g),function(a,b){var c=mb[b]||r.find.attr;mb[b]=function(a,b,d){var e,f,g=b.toLowerCase();return d||(f=mb[g],mb[g]=e,e=null!=c(a,b,d)?g:null,mb[g]=f),e}});var nb=/^(?:input|select|textarea|button)$/i,ob=/^(?:a|area)$/i;r.fn.extend({prop:function(a,b){return T(this,r.prop,a,b,arguments.length>1)},removeProp:function(a){return this.each(function(){delete this[r.propFix[a]||a]})}}),r.extend({prop:function(a,b,c){var d,e,f=a.nodeType;if(3!==f&&8!==f&&2!==f)return 1===f&&r.isXMLDoc(a)||(b=r.propFix[b]||b,e=r.propHooks[b]),void 0!==c?e&&"set"in e&&void 0!==(d=e.set(a,c,b))?d:a[b]=c:e&&"get"in e&&null!==(d=e.get(a,b))?d:a[b]},propHooks:{tabIndex:{get:function(a){var b=r.find.attr(a,"tabindex");return b?parseInt(b,10):nb.test(a.nodeName)||ob.test(a.nodeName)&&a.href?0:-1}}},propFix:{"for":"htmlFor","class":"className"}}),o.optSelected||(r.propHooks.selected={get:function(a){var b=a.parentNode;return b&&b.parentNode&&b.parentNode.selectedIndex,null},set:function(a){var b=a.parentNode;b&&(b.selectedIndex,b.parentNode&&b.parentNode.selectedIndex)}}),r.each(["tabIndex","readOnly","maxLength","cellSpacing","cellPadding","rowSpan","colSpan","useMap","frameBorder","contentEditable"],function(){r.propFix[this.toLowerCase()]=this});function pb(a){var b=a.match(L)||[];return b.join(" ")}function qb(a){return a.getAttribute&&a.getAttribute("class")||""}r.fn.extend({addClass:function(a){var b,c,d,e,f,g,h,i=0;if(r.isFunction(a))return this.each(function(b){r(this).addClass(a.call(this,b,qb(this)))});if("string"==typeof a&&a){b=a.match(L)||[];while(c=this[i++])if(e=qb(c),d=1===c.nodeType&&" "+pb(e)+" "){g=0;while(f=b[g++])d.indexOf(" "+f+" ")<0&&(d+=f+" ");h=pb(d),e!==h&&c.setAttribute("class",h)}}return this},removeClass:function(a){var b,c,d,e,f,g,h,i=0;if(r.isFunction(a))return this.each(function(b){r(this).removeClass(a.call(this,b,qb(this)))});if(!arguments.length)return this.attr("class","");if("string"==typeof a&&a){b=a.match(L)||[];while(c=this[i++])if(e=qb(c),d=1===c.nodeType&&" "+pb(e)+" "){g=0;while(f=b[g++])while(d.indexOf(" "+f+" ")>-1)d=d.replace(" "+f+" "," ");h=pb(d),e!==h&&c.setAttribute("class",h)}}return this},toggleClass:function(a,b){var c=typeof a;return"boolean"==typeof b&&"string"===c?b?this.addClass(a):this.removeClass(a):r.isFunction(a)?this.each(function(c){r(this).toggleClass(a.call(this,c,qb(this),b),b)}):this.each(function(){var b,d,e,f;if("string"===c){d=0,e=r(this),f=a.match(L)||[];while(b=f[d++])e.hasClass(b)?e.removeClass(b):e.addClass(b)}else void 0!==a&&"boolean"!==c||(b=qb(this),b&&W.set(this,"__className__",b),this.setAttribute&&this.setAttribute("class",b||a===!1?"":W.get(this,"__className__")||""))})},hasClass:function(a){var b,c,d=0;b=" "+a+" ";while(c=this[d++])if(1===c.nodeType&&(" "+pb(qb(c))+" ").indexOf(b)>-1)return!0;return!1}});var rb=/\r/g;r.fn.extend({val:function(a){var b,c,d,e=this[0];{if(arguments.length)return d=r.isFunction(a),this.each(function(c){var e;1===this.nodeType&&(e=d?a.call(this,c,r(this).val()):a,null==e?e="":"number"==typeof e?e+="":Array.isArray(e)&&(e=r.map(e,function(a){return null==a?"":a+""})),b=r.valHooks[this.type]||r.valHooks[this.nodeName.toLowerCase()],b&&"set"in b&&void 0!==b.set(this,e,"value")||(this.value=e))});if(e)return b=r.valHooks[e.type]||r.valHooks[e.nodeName.toLowerCase()],b&&"get"in b&&void 0!==(c=b.get(e,"value"))?c:(c=e.value,"string"==typeof c?c.replace(rb,""):null==c?"":c)}}}),r.extend({valHooks:{option:{get:function(a){var b=r.find.attr(a,"value");return null!=b?b:pb(r.text(a))}},select:{get:function(a){var b,c,d,e=a.options,f=a.selectedIndex,g="select-one"===a.type,h=g?null:[],i=g?f+1:e.length;for(d=f<0?i:g?f:0;d<i;d++)if(c=e[d],(c.selected||d===f)&&!c.disabled&&(!c.parentNode.disabled||!B(c.parentNode,"optgroup"))){if(b=r(c).val(),g)return b;h.push(b)}return h},set:function(a,b){var c,d,e=a.options,f=r.makeArray(b),g=e.length;while(g--)d=e[g],(d.selected=r.inArray(r.valHooks.option.get(d),f)>-1)&&(c=!0);return c||(a.selectedIndex=-1),f}}}}),r.each(["radio","checkbox"],function(){r.valHooks[this]={set:function(a,b){if(Array.isArray(b))return a.checked=r.inArray(r(a).val(),b)>-1}},o.checkOn||(r.valHooks[this].get=function(a){return null===a.getAttribute("value")?"on":a.value})});var sb=/^(?:focusinfocus|focusoutblur)$/;r.extend(r.event,{trigger:function(b,c,e,f){var g,h,i,j,k,m,n,o=[e||d],p=l.call(b,"type")?b.type:b,q=l.call(b,"namespace")?b.namespace.split("."):[];if(h=i=e=e||d,3!==e.nodeType&&8!==e.nodeType&&!sb.test(p+r.event.triggered)&&(p.indexOf(".")>-1&&(q=p.split("."),p=q.shift(),q.sort()),k=p.indexOf(":")<0&&"on"+p,b=b[r.expando]?b:new r.Event(p,"object"==typeof b&&b),b.isTrigger=f?2:3,b.namespace=q.join("."),b.rnamespace=b.namespace?new RegExp("(^|\\.)"+q.join("\\.(?:.*\\.|)")+"(\\.|$)"):null,b.result=void 0,b.target||(b.target=e),c=null==c?[b]:r.makeArray(c,[b]),n=r.event.special[p]||{},f||!n.trigger||n.trigger.apply(e,c)!==!1)){if(!f&&!n.noBubble&&!r.isWindow(e)){for(j=n.delegateType||p,sb.test(j+p)||(h=h.parentNode);h;h=h.parentNode)o.push(h),i=h;i===(e.ownerDocument||d)&&o.push(i.defaultView||i.parentWindow||a)}g=0;while((h=o[g++])&&!b.isPropagationStopped())b.type=g>1?j:n.bindType||p,m=(W.get(h,"events")||{})[b.type]&&W.get(h,"handle"),m&&m.apply(h,c),m=k&&h[k],m&&m.apply&&U(h)&&(b.result=m.apply(h,c),b.result===!1&&b.preventDefault());return b.type=p,f||b.isDefaultPrevented()||n._default&&n._default.apply(o.pop(),c)!==!1||!U(e)||k&&r.isFunction(e[p])&&!r.isWindow(e)&&(i=e[k],i&&(e[k]=null),r.event.triggered=p,e[p](),r.event.triggered=void 0,i&&(e[k]=i)),b.result}},simulate:function(a,b,c){var d=r.extend(new r.Event,c,{type:a,isSimulated:!0});r.event.trigger(d,null,b)}}),r.fn.extend({trigger:function(a,b){return this.each(function(){r.event.trigger(a,b,this)})},triggerHandler:function(a,b){var c=this[0];if(c)return r.event.trigger(a,b,c,!0)}}),r.each("blur focus focusin focusout resize scroll click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup contextmenu".split(" "),function(a,b){r.fn[b]=function(a,c){return arguments.length>0?this.on(b,null,a,c):this.trigger(b)}}),r.fn.extend({hover:function(a,b){return this.mouseenter(a).mouseleave(b||a)}}),o.focusin="onfocusin"in a,o.focusin||r.each({focus:"focusin",blur:"focusout"},function(a,b){var c=function(a){r.event.simulate(b,a.target,r.event.fix(a))};r.event.special[b]={setup:function(){var d=this.ownerDocument||this,e=W.access(d,b);e||d.addEventListener(a,c,!0),W.access(d,b,(e||0)+1)},teardown:function(){var d=this.ownerDocument||this,e=W.access(d,b)-1;e?W.access(d,b,e):(d.removeEventListener(a,c,!0),W.remove(d,b))}}});var tb=a.location,ub=r.now(),vb=/\?/;r.parseXML=function(b){var c;if(!b||"string"!=typeof b)return null;try{c=(new a.DOMParser).parseFromString(b,"text/xml")}catch(d){c=void 0}return c&&!c.getElementsByTagName("parsererror").length||r.error("Invalid XML: "+b),c};var wb=/\[\]$/,xb=/\r?\n/g,yb=/^(?:submit|button|image|reset|file)$/i,zb=/^(?:input|select|textarea|keygen)/i;function Ab(a,b,c,d){var e;if(Array.isArray(b))r.each(b,function(b,e){c||wb.test(a)?d(a,e):Ab(a+"["+("object"==typeof e&&null!=e?b:"")+"]",e,c,d)});else if(c||"object"!==r.type(b))d(a,b);else for(e in b)Ab(a+"["+e+"]",b[e],c,d)}r.param=function(a,b){var c,d=[],e=function(a,b){var c=r.isFunction(b)?b():b;d[d.length]=encodeURIComponent(a)+"="+encodeURIComponent(null==c?"":c)};if(Array.isArray(a)||a.jquery&&!r.isPlainObject(a))r.each(a,function(){e(this.name,this.value)});else for(c in a)Ab(c,a[c],b,e);return d.join("&")},r.fn.extend({serialize:function(){return r.param(this.serializeArray())},serializeArray:function(){return this.map(function(){var a=r.prop(this,"elements");return a?r.makeArray(a):this}).filter(function(){var a=this.type;return this.name&&!r(this).is(":disabled")&&zb.test(this.nodeName)&&!yb.test(a)&&(this.checked||!ja.test(a))}).map(function(a,b){var c=r(this).val();return null==c?null:Array.isArray(c)?r.map(c,function(a){return{name:b.name,value:a.replace(xb,"\r\n")}}):{name:b.name,value:c.replace(xb,"\r\n")}}).get()}});var Bb=/%20/g,Cb=/#.*$/,Db=/([?&])_=[^&]*/,Eb=/^(.*?):[ \t]*([^\r\n]*)$/gm,Fb=/^(?:about|app|app-storage|.+-extension|file|res|widget):$/,Gb=/^(?:GET|HEAD)$/,Hb=/^\/\//,Ib={},Jb={},Kb="*/".concat("*"),Lb=d.createElement("a");Lb.href=tb.href;function Mb(a){return function(b,c){"string"!=typeof b&&(c=b,b="*");var d,e=0,f=b.toLowerCase().match(L)||[];if(r.isFunction(c))while(d=f[e++])"+"===d[0]?(d=d.slice(1)||"*",(a[d]=a[d]||[]).unshift(c)):(a[d]=a[d]||[]).push(c)}}function Nb(a,b,c,d){var e={},f=a===Jb;function g(h){var i;return e[h]=!0,r.each(a[h]||[],function(a,h){var j=h(b,c,d);return"string"!=typeof j||f||e[j]?f?!(i=j):void 0:(b.dataTypes.unshift(j),g(j),!1)}),i}return g(b.dataTypes[0])||!e["*"]&&g("*")}function Ob(a,b){var c,d,e=r.ajaxSettings.flatOptions||{};for(c in b)void 0!==b[c]&&((e[c]?a:d||(d={}))[c]=b[c]);return d&&r.extend(!0,a,d),a}function Pb(a,b,c){var d,e,f,g,h=a.contents,i=a.dataTypes;while("*"===i[0])i.shift(),void 0===d&&(d=a.mimeType||b.getResponseHeader("Content-Type"));if(d)for(e in h)if(h[e]&&h[e].test(d)){i.unshift(e);break}if(i[0]in c)f=i[0];else{for(e in c){if(!i[0]||a.converters[e+" "+i[0]]){f=e;break}g||(g=e)}f=f||g}if(f)return f!==i[0]&&i.unshift(f),c[f]}function Qb(a,b,c,d){var e,f,g,h,i,j={},k=a.dataTypes.slice();if(k[1])for(g in a.converters)j[g.toLowerCase()]=a.converters[g];f=k.shift();while(f)if(a.responseFields[f]&&(c[a.responseFields[f]]=b),!i&&d&&a.dataFilter&&(b=a.dataFilter(b,a.dataType)),i=f,f=k.shift())if("*"===f)f=i;else if("*"!==i&&i!==f){if(g=j[i+" "+f]||j["* "+f],!g)for(e in j)if(h=e.split(" "),h[1]===f&&(g=j[i+" "+h[0]]||j["* "+h[0]])){g===!0?g=j[e]:j[e]!==!0&&(f=h[0],k.unshift(h[1]));break}if(g!==!0)if(g&&a["throws"])b=g(b);else try{b=g(b)}catch(l){return{state:"parsererror",error:g?l:"No conversion from "+i+" to "+f}}}return{state:"success",data:b}}r.extend({active:0,lastModified:{},etag:{},ajaxSettings:{url:tb.href,type:"GET",isLocal:Fb.test(tb.protocol),global:!0,processData:!0,async:!0,contentType:"application/x-www-form-urlencoded; charset=UTF-8",accepts:{"*":Kb,text:"text/plain",html:"text/html",xml:"application/xml, text/xml",json:"application/json, text/javascript"},contents:{xml:/\bxml\b/,html:/\bhtml/,json:/\bjson\b/},responseFields:{xml:"responseXML",text:"responseText",json:"responseJSON"},converters:{"* text":String,"text html":!0,"text json":JSON.parse,"text xml":r.parseXML},flatOptions:{url:!0,context:!0}},ajaxSetup:function(a,b){return b?Ob(Ob(a,r.ajaxSettings),b):Ob(r.ajaxSettings,a)},ajaxPrefilter:Mb(Ib),ajaxTransport:Mb(Jb),ajax:function(b,c){"object"==typeof b&&(c=b,b=void 0),c=c||{};var e,f,g,h,i,j,k,l,m,n,o=r.ajaxSetup({},c),p=o.context||o,q=o.context&&(p.nodeType||p.jquery)?r(p):r.event,s=r.Deferred(),t=r.Callbacks("once memory"),u=o.statusCode||{},v={},w={},x="canceled",y={readyState:0,getResponseHeader:function(a){var b;if(k){if(!h){h={};while(b=Eb.exec(g))h[b[1].toLowerCase()]=b[2]}b=h[a.toLowerCase()]}return null==b?null:b},getAllResponseHeaders:function(){return k?g:null},setRequestHeader:function(a,b){return null==k&&(a=w[a.toLowerCase()]=w[a.toLowerCase()]||a,v[a]=b),this},overrideMimeType:function(a){return null==k&&(o.mimeType=a),this},statusCode:function(a){var b;if(a)if(k)y.always(a[y.status]);else for(b in a)u[b]=[u[b],a[b]];return this},abort:function(a){var b=a||x;return e&&e.abort(b),A(0,b),this}};if(s.promise(y),o.url=((b||o.url||tb.href)+"").replace(Hb,tb.protocol+"//"),o.type=c.method||c.type||o.method||o.type,o.dataTypes=(o.dataType||"*").toLowerCase().match(L)||[""],null==o.crossDomain){j=d.createElement("a");try{j.href=o.url,j.href=j.href,o.crossDomain=Lb.protocol+"//"+Lb.host!=j.protocol+"//"+j.host}catch(z){o.crossDomain=!0}}if(o.data&&o.processData&&"string"!=typeof o.data&&(o.data=r.param(o.data,o.traditional)),Nb(Ib,o,c,y),k)return y;l=r.event&&o.global,l&&0===r.active++&&r.event.trigger("ajaxStart"),o.type=o.type.toUpperCase(),o.hasContent=!Gb.test(o.type),f=o.url.replace(Cb,""),o.hasContent?o.data&&o.processData&&0===(o.contentType||"").indexOf("application/x-www-form-urlencoded")&&(o.data=o.data.replace(Bb,"+")):(n=o.url.slice(f.length),o.data&&(f+=(vb.test(f)?"&":"?")+o.data,delete o.data),o.cache===!1&&(f=f.replace(Db,"$1"),n=(vb.test(f)?"&":"?")+"_="+ub++ +n),o.url=f+n),o.ifModified&&(r.lastModified[f]&&y.setRequestHeader("If-Modified-Since",r.lastModified[f]),r.etag[f]&&y.setRequestHeader("If-None-Match",r.etag[f])),(o.data&&o.hasContent&&o.contentType!==!1||c.contentType)&&y.setRequestHeader("Content-Type",o.contentType),y.setRequestHeader("Accept",o.dataTypes[0]&&o.accepts[o.dataTypes[0]]?o.accepts[o.dataTypes[0]]+("*"!==o.dataTypes[0]?", "+Kb+"; q=0.01":""):o.accepts["*"]);for(m in o.headers)y.setRequestHeader(m,o.headers[m]);if(o.beforeSend&&(o.beforeSend.call(p,y,o)===!1||k))return y.abort();if(x="abort",t.add(o.complete),y.done(o.success),y.fail(o.error),e=Nb(Jb,o,c,y)){if(y.readyState=1,l&&q.trigger("ajaxSend",[y,o]),k)return y;o.async&&o.timeout>0&&(i=a.setTimeout(function(){y.abort("timeout")},o.timeout));try{k=!1,e.send(v,A)}catch(z){if(k)throw z;A(-1,z)}}else A(-1,"No Transport");function A(b,c,d,h){var j,m,n,v,w,x=c;k||(k=!0,i&&a.clearTimeout(i),e=void 0,g=h||"",y.readyState=b>0?4:0,j=b>=200&&b<300||304===b,d&&(v=Pb(o,y,d)),v=Qb(o,v,y,j),j?(o.ifModified&&(w=y.getResponseHeader("Last-Modified"),w&&(r.lastModified[f]=w),w=y.getResponseHeader("etag"),w&&(r.etag[f]=w)),204===b||"HEAD"===o.type?x="nocontent":304===b?x="notmodified":(x=v.state,m=v.data,n=v.error,j=!n)):(n=x,!b&&x||(x="error",b<0&&(b=0))),y.status=b,y.statusText=(c||x)+"",j?s.resolveWith(p,[m,x,y]):s.rejectWith(p,[y,x,n]),y.statusCode(u),u=void 0,l&&q.trigger(j?"ajaxSuccess":"ajaxError",[y,o,j?m:n]),t.fireWith(p,[y,x]),l&&(q.trigger("ajaxComplete",[y,o]),--r.active||r.event.trigger("ajaxStop")))}return y},getJSON:function(a,b,c){return r.get(a,b,c,"json")},getScript:function(a,b){return r.get(a,void 0,b,"script")}}),r.each(["get","post"],function(a,b){r[b]=function(a,c,d,e){return r.isFunction(c)&&(e=e||d,d=c,c=void 0),r.ajax(r.extend({url:a,type:b,dataType:e,data:c,success:d},r.isPlainObject(a)&&a))}}),r._evalUrl=function(a){return r.ajax({url:a,type:"GET",dataType:"script",cache:!0,async:!1,global:!1,"throws":!0})},r.fn.extend({wrapAll:function(a){var b;return this[0]&&(r.isFunction(a)&&(a=a.call(this[0])),b=r(a,this[0].ownerDocument).eq(0).clone(!0),this[0].parentNode&&b.insertBefore(this[0]),b.map(function(){var a=this;while(a.firstElementChild)a=a.firstElementChild;return a}).append(this)),this},wrapInner:function(a){return r.isFunction(a)?this.each(function(b){r(this).wrapInner(a.call(this,b))}):this.each(function(){var b=r(this),c=b.contents();c.length?c.wrapAll(a):b.append(a)})},wrap:function(a){var b=r.isFunction(a);return this.each(function(c){r(this).wrapAll(b?a.call(this,c):a)})},unwrap:function(a){return this.parent(a).not("body").each(function(){r(this).replaceWith(this.childNodes)}),this}}),r.expr.pseudos.hidden=function(a){return!r.expr.pseudos.visible(a)},r.expr.pseudos.visible=function(a){return!!(a.offsetWidth||a.offsetHeight||a.getClientRects().length)},r.ajaxSettings.xhr=function(){try{return new a.XMLHttpRequest}catch(b){}};var Rb={0:200,1223:204},Sb=r.ajaxSettings.xhr();o.cors=!!Sb&&"withCredentials"in Sb,o.ajax=Sb=!!Sb,r.ajaxTransport(function(b){var c,d;if(o.cors||Sb&&!b.crossDomain)return{send:function(e,f){var g,h=b.xhr();if(h.open(b.type,b.url,b.async,b.username,b.password),b.xhrFields)for(g in b.xhrFields)h[g]=b.xhrFields[g];b.mimeType&&h.overrideMimeType&&h.overrideMimeType(b.mimeType),b.crossDomain||e["X-Requested-With"]||(e["X-Requested-With"]="XMLHttpRequest");for(g in e)h.setRequestHeader(g,e[g]);c=function(a){return function(){c&&(c=d=h.onload=h.onerror=h.onabort=h.onreadystatechange=null,"abort"===a?h.abort():"error"===a?"number"!=typeof h.status?f(0,"error"):f(h.status,h.statusText):f(Rb[h.status]||h.status,h.statusText,"text"!==(h.responseType||"text")||"string"!=typeof h.responseText?{binary:h.response}:{text:h.responseText},h.getAllResponseHeaders()))}},h.onload=c(),d=h.onerror=c("error"),void 0!==h.onabort?h.onabort=d:h.onreadystatechange=function(){4===h.readyState&&a.setTimeout(function(){c&&d()})},c=c("abort");try{h.send(b.hasContent&&b.data||null)}catch(i){if(c)throw i}},abort:function(){c&&c()}}}),r.ajaxPrefilter(function(a){a.crossDomain&&(a.contents.script=!1)}),r.ajaxSetup({accepts:{script:"text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"},contents:{script:/\b(?:java|ecma)script\b/},converters:{"text script":function(a){return r.globalEval(a),a}}}),r.ajaxPrefilter("script",function(a){void 0===a.cache&&(a.cache=!1),a.crossDomain&&(a.type="GET")}),r.ajaxTransport("script",function(a){if(a.crossDomain){var b,c;return{send:function(e,f){b=r("<script>").prop({charset:a.scriptCharset,src:a.url}).on("load error",c=function(a){b.remove(),c=null,a&&f("error"===a.type?404:200,a.type)}),d.head.appendChild(b[0])},abort:function(){c&&c()}}}});var Tb=[],Ub=/(=)\?(?=&|$)|\?\?/;r.ajaxSetup({jsonp:"callback",jsonpCallback:function(){var a=Tb.pop()||r.expando+"_"+ub++;return this[a]=!0,a}}),r.ajaxPrefilter("json jsonp",function(b,c,d){var e,f,g,h=b.jsonp!==!1&&(Ub.test(b.url)?"url":"string"==typeof b.data&&0===(b.contentType||"").indexOf("application/x-www-form-urlencoded")&&Ub.test(b.data)&&"data");if(h||"jsonp"===b.dataTypes[0])return e=b.jsonpCallback=r.isFunction(b.jsonpCallback)?b.jsonpCallback():b.jsonpCallback,h?b[h]=b[h].replace(Ub,"$1"+e):b.jsonp!==!1&&(b.url+=(vb.test(b.url)?"&":"?")+b.jsonp+"="+e),b.converters["script json"]=function(){return g||r.error(e+" was not called"),g[0]},b.dataTypes[0]="json",f=a[e],a[e]=function(){g=arguments},d.always(function(){void 0===f?r(a).removeProp(e):a[e]=f,b[e]&&(b.jsonpCallback=c.jsonpCallback,Tb.push(e)),g&&r.isFunction(f)&&f(g[0]),g=f=void 0}),"script"}),o.createHTMLDocument=function(){var a=d.implementation.createHTMLDocument("").body;return a.innerHTML="<form></form><form></form>",2===a.childNodes.length}(),r.parseHTML=function(a,b,c){if("string"!=typeof a)return[];"boolean"==typeof b&&(c=b,b=!1);var e,f,g;return b||(o.createHTMLDocument?(b=d.implementation.createHTMLDocument(""),e=b.createElement("base"),e.href=d.location.href,b.head.appendChild(e)):b=d),f=C.exec(a),g=!c&&[],f?[b.createElement(f[1])]:(f=qa([a],b,g),g&&g.length&&r(g).remove(),r.merge([],f.childNodes))},r.fn.load=function(a,b,c){var d,e,f,g=this,h=a.indexOf(" ");return h>-1&&(d=pb(a.slice(h)),a=a.slice(0,h)),r.isFunction(b)?(c=b,b=void 0):b&&"object"==typeof b&&(e="POST"),g.length>0&&r.ajax({url:a,type:e||"GET",dataType:"html",data:b}).done(function(a){f=arguments,g.html(d?r("<div>").append(r.parseHTML(a)).find(d):a)}).always(c&&function(a,b){g.each(function(){c.apply(this,f||[a.responseText,b,a])})}),this},r.each(["ajaxStart","ajaxStop","ajaxComplete","ajaxError","ajaxSuccess","ajaxSend"],function(a,b){r.fn[b]=function(a){return this.on(b,a)}}),r.expr.pseudos.animated=function(a){return r.grep(r.timers,function(b){return a===b.elem}).length},r.offset={setOffset:function(a,b,c){var d,e,f,g,h,i,j,k=r.css(a,"position"),l=r(a),m={};"static"===k&&(a.style.position="relative"),h=l.offset(),f=r.css(a,"top"),i=r.css(a,"left"),j=("absolute"===k||"fixed"===k)&&(f+i).indexOf("auto")>-1,j?(d=l.position(),g=d.top,e=d.left):(g=parseFloat(f)||0,e=parseFloat(i)||0),r.isFunction(b)&&(b=b.call(a,c,r.extend({},h))),null!=b.top&&(m.top=b.top-h.top+g),null!=b.left&&(m.left=b.left-h.left+e),"using"in b?b.using.call(a,m):l.css(m)}},r.fn.extend({offset:function(a){if(arguments.length)return void 0===a?this:this.each(function(b){r.offset.setOffset(this,a,b)});var b,c,d,e,f=this[0];if(f)return f.getClientRects().length?(d=f.getBoundingClientRect(),b=f.ownerDocument,c=b.documentElement,e=b.defaultView,{top:d.top+e.pageYOffset-c.clientTop,left:d.left+e.pageXOffset-c.clientLeft}):{top:0,left:0}},position:function(){if(this[0]){var a,b,c=this[0],d={top:0,left:0};return"fixed"===r.css(c,"position")?b=c.getBoundingClientRect():(a=this.offsetParent(),b=this.offset(),B(a[0],"html")||(d=a.offset()),d={top:d.top+r.css(a[0],"borderTopWidth",!0),left:d.left+r.css(a[0],"borderLeftWidth",!0)}),{top:b.top-d.top-r.css(c,"marginTop",!0),left:b.left-d.left-r.css(c,"marginLeft",!0)}}},offsetParent:function(){return this.map(function(){var a=this.offsetParent;while(a&&"static"===r.css(a,"position"))a=a.offsetParent;return a||ra})}}),r.each({scrollLeft:"pageXOffset",scrollTop:"pageYOffset"},function(a,b){var c="pageYOffset"===b;r.fn[a]=function(d){return T(this,function(a,d,e){var f;return r.isWindow(a)?f=a:9===a.nodeType&&(f=a.defaultView),void 0===e?f?f[b]:a[d]:void(f?f.scrollTo(c?f.pageXOffset:e,c?e:f.pageYOffset):a[d]=e)},a,d,arguments.length)}}),r.each(["top","left"],function(a,b){r.cssHooks[b]=Pa(o.pixelPosition,function(a,c){if(c)return c=Oa(a,b),Ma.test(c)?r(a).position()[b]+"px":c})}),r.each({Height:"height",Width:"width"},function(a,b){r.each({padding:"inner"+a,content:b,"":"outer"+a},function(c,d){r.fn[d]=function(e,f){var g=arguments.length&&(c||"boolean"!=typeof e),h=c||(e===!0||f===!0?"margin":"border");return T(this,function(b,c,e){var f;return r.isWindow(b)?0===d.indexOf("outer")?b["inner"+a]:b.document.documentElement["client"+a]:9===b.nodeType?(f=b.documentElement,Math.max(b.body["scroll"+a],f["scroll"+a],b.body["offset"+a],f["offset"+a],f["client"+a])):void 0===e?r.css(b,c,h):r.style(b,c,e,h)},b,g?e:void 0,g)}})}),r.fn.extend({bind:function(a,b,c){return this.on(a,null,b,c)},unbind:function(a,b){return this.off(a,null,b)},delegate:function(a,b,c,d){return this.on(b,a,c,d)},undelegate:function(a,b,c){return 1===arguments.length?this.off(a,"**"):this.off(b,a||"**",c)}}),r.holdReady=function(a){a?r.readyWait++:r.ready(!0)},r.isArray=Array.isArray,r.parseJSON=JSON.parse,r.nodeName=B,"function"==typeof define&&define.amd&&define("jquery",[],function(){return r});var Vb=a.jQuery,Wb=a.$;return r.noConflict=function(b){return a.$===r&&(a.$=Wb),b&&a.jQuery===r&&(a.jQuery=Vb),r},b||(a.jQuery=a.$=r),r});
diff --git a/_static/js/modernizr.min.js b/_static/js/modernizr.min.js
deleted file mode 100755
index 558c094bab1..00000000000
--- a/_static/js/modernizr.min.js
+++ /dev/null
@@ -1,4 +0,0 @@
-/* Modernizr 2.6.2 (Custom Build) | MIT & BSD
- * Build: https://modernizr.com/download/#-fontface-backgroundsize-borderimage-borderradius-boxshadow-flexbox-hsla-multiplebgs-opacity-rgba-textshadow-cssanimations-csscolumns-generatedcontent-cssgradients-cssreflections-csstransforms-csstransforms3d-csstransitions-applicationcache-canvas-canvastext-draganddrop-hashchange-history-audio-video-indexeddb-input-inputtypes-localstorage-postmessage-sessionstorage-websockets-websqldatabase-webworkers-geolocation-inlinesvg-smil-svg-svgclippaths-touch-webgl-shiv-mq-cssclasses-addtest-prefixed-teststyles-testprop-testallprops-hasevent-prefixes-domprefixes-load
- */
-;window.Modernizr=function(a,b,c){function D(a){j.cssText=a}function E(a,b){return D(n.join(a+";")+(b||""))}function F(a,b){return typeof a===b}function G(a,b){return!!~(""+a).indexOf(b)}function H(a,b){for(var d in a){var e=a[d];if(!G(e,"-")&&j[e]!==c)return b=="pfx"?e:!0}return!1}function I(a,b,d){for(var e in a){var f=b[a[e]];if(f!==c)return d===!1?a[e]:F(f,"function")?f.bind(d||b):f}return!1}function J(a,b,c){var d=a.charAt(0).toUpperCase()+a.slice(1),e=(a+" "+p.join(d+" ")+d).split(" ");return F(b,"string")||F(b,"undefined")?H(e,b):(e=(a+" "+q.join(d+" ")+d).split(" "),I(e,b,c))}function K(){e.input=function(c){for(var d=0,e=c.length;d<e;d++)u[c[d]]=c[d]in k;return u.list&&(u.list=!!b.createElement("datalist")&&!!a.HTMLDataListElement),u}("autocomplete autofocus list placeholder max min multiple pattern required step".split(" ")),e.inputtypes=function(a){for(var d=0,e,f,h,i=a.length;d<i;d++)k.setAttribute("type",f=a[d]),e=k.type!=="text",e&&(k.value=l,k.style.cssText="position:absolute;visibility:hidden;",/^range$/.test(f)&&k.style.WebkitAppearance!==c?(g.appendChild(k),h=b.defaultView,e=h.getComputedStyle&&h.getComputedStyle(k,null).WebkitAppearance!=="textfield"&&k.offsetHeight!==0,g.removeChild(k)):/^(search|tel)$/.test(f)||(/^(url|email)$/.test(f)?e=k.checkValidity&&k.checkValidity()===!1:e=k.value!=l)),t[a[d]]=!!e;return t}("search tel url email datetime date month week time datetime-local number range color".split(" "))}var d="2.6.2",e={},f=!0,g=b.documentElement,h="modernizr",i=b.createElement(h),j=i.style,k=b.createElement("input"),l=":)",m={}.toString,n=" -webkit- -moz- -o- -ms- ".split(" "),o="Webkit Moz O ms",p=o.split(" "),q=o.toLowerCase().split(" "),r={svg:"https://www.w3.org/2000/svg"},s={},t={},u={},v=[],w=v.slice,x,y=function(a,c,d,e){var f,i,j,k,l=b.createElement("div"),m=b.body,n=m||b.createElement("body");if(parseInt(d,10))while(d--)j=b.createElement("div"),j.id=e?e[d]:h+(d+1),l.appendChild(j);return f=["&#173;",'<style id="s',h,'">',a,"</style>"].join(""),l.id=h,(m?l:n).innerHTML+=f,n.appendChild(l),m||(n.style.background="",n.style.overflow="hidden",k=g.style.overflow,g.style.overflow="hidden",g.appendChild(n)),i=c(l,a),m?l.parentNode.removeChild(l):(n.parentNode.removeChild(n),g.style.overflow=k),!!i},z=function(b){var c=a.matchMedia||a.msMatchMedia;if(c)return c(b).matches;var d;return y("@media "+b+" { #"+h+" { position: absolute; } }",function(b){d=(a.getComputedStyle?getComputedStyle(b,null):b.currentStyle)["position"]=="absolute"}),d},A=function(){function d(d,e){e=e||b.createElement(a[d]||"div"),d="on"+d;var f=d in e;return f||(e.setAttribute||(e=b.createElement("div")),e.setAttribute&&e.removeAttribute&&(e.setAttribute(d,""),f=F(e[d],"function"),F(e[d],"undefined")||(e[d]=c),e.removeAttribute(d))),e=null,f}var a={select:"input",change:"input",submit:"form",reset:"form",error:"img",load:"img",abort:"img"};return d}(),B={}.hasOwnProperty,C;!F(B,"undefined")&&!F(B.call,"undefined")?C=function(a,b){return B.call(a,b)}:C=function(a,b){return b in a&&F(a.constructor.prototype[b],"undefined")},Function.prototype.bind||(Function.prototype.bind=function(b){var c=this;if(typeof c!="function")throw new TypeError;var d=w.call(arguments,1),e=function(){if(this instanceof e){var a=function(){};a.prototype=c.prototype;var f=new a,g=c.apply(f,d.concat(w.call(arguments)));return Object(g)===g?g:f}return c.apply(b,d.concat(w.call(arguments)))};return e}),s.flexbox=function(){return J("flexWrap")},s.canvas=function(){var a=b.createElement("canvas");return!!a.getContext&&!!a.getContext("2d")},s.canvastext=function(){return!!e.canvas&&!!F(b.createElement("canvas").getContext("2d").fillText,"function")},s.webgl=function(){return!!a.WebGLRenderingContext},s.touch=function(){var c;return"ontouchstart"in a||a.DocumentTouch&&b instanceof DocumentTouch?c=!0:y(["@media (",n.join("touch-enabled),("),h,")","{#modernizr{top:9px;position:absolute}}"].join(""),function(a){c=a.offsetTop===9}),c},s.geolocation=function(){return"geolocation"in navigator},s.postmessage=function(){return!!a.postMessage},s.websqldatabase=function(){return!!a.openDatabase},s.indexedDB=function(){return!!J("indexedDB",a)},s.hashchange=function(){return A("hashchange",a)&&(b.documentMode===c||b.documentMode>7)},s.history=function(){return!!a.history&&!!history.pushState},s.draganddrop=function(){var a=b.createElement("div");return"draggable"in a||"ondragstart"in a&&"ondrop"in a},s.websockets=function(){return"WebSocket"in a||"MozWebSocket"in a},s.rgba=function(){return D("background-color:rgba(150,255,150,.5)"),G(j.backgroundColor,"rgba")},s.hsla=function(){return D("background-color:hsla(120,40%,100%,.5)"),G(j.backgroundColor,"rgba")||G(j.backgroundColor,"hsla")},s.multiplebgs=function(){return D("background:url(https://),url(https://),red url(https://)"),/(url\s*\(.*?){3}/.test(j.background)},s.backgroundsize=function(){return J("backgroundSize")},s.borderimage=function(){return J("borderImage")},s.borderradius=function(){return J("borderRadius")},s.boxshadow=function(){return J("boxShadow")},s.textshadow=function(){return b.createElement("div").style.textShadow===""},s.opacity=function(){return E("opacity:.55"),/^0.55$/.test(j.opacity)},s.cssanimations=function(){return J("animationName")},s.csscolumns=function(){return J("columnCount")},s.cssgradients=function(){var a="background-image:",b="gradient(linear,left top,right bottom,from(#9f9),to(white));",c="linear-gradient(left top,#9f9, white);";return D((a+"-webkit- ".split(" ").join(b+a)+n.join(c+a)).slice(0,-a.length)),G(j.backgroundImage,"gradient")},s.cssreflections=function(){return J("boxReflect")},s.csstransforms=function(){return!!J("transform")},s.csstransforms3d=function(){var a=!!J("perspective");return a&&"webkitPerspective"in g.style&&y("@media (transform-3d),(-webkit-transform-3d){#modernizr{left:9px;position:absolute;height:3px;}}",function(b,c){a=b.offsetLeft===9&&b.offsetHeight===3}),a},s.csstransitions=function(){return J("transition")},s.fontface=function(){var a;return y('@font-face {font-family:"font";src:url("https://")}',function(c,d){var e=b.getElementById("smodernizr"),f=e.sheet||e.styleSheet,g=f?f.cssRules&&f.cssRules[0]?f.cssRules[0].cssText:f.cssText||"":"";a=/src/i.test(g)&&g.indexOf(d.split(" ")[0])===0}),a},s.generatedcontent=function(){var a;return y(["#",h,"{font:0/0 a}#",h,':after{content:"',l,'";visibility:hidden;font:3px/1 a}'].join(""),function(b){a=b.offsetHeight>=3}),a},s.video=function(){var a=b.createElement("video"),c=!1;try{if(c=!!a.canPlayType)c=new Boolean(c),c.ogg=a.canPlayType('video/ogg; codecs="theora"').replace(/^no$/,""),c.h264=a.canPlayType('video/mp4; codecs="avc1.42E01E"').replace(/^no$/,""),c.webm=a.canPlayType('video/webm; codecs="vp8, vorbis"').replace(/^no$/,"")}catch(d){}return c},s.audio=function(){var a=b.createElement("audio"),c=!1;try{if(c=!!a.canPlayType)c=new Boolean(c),c.ogg=a.canPlayType('audio/ogg; codecs="vorbis"').replace(/^no$/,""),c.mp3=a.canPlayType("audio/mpeg;").replace(/^no$/,""),c.wav=a.canPlayType('audio/wav; codecs="1"').replace(/^no$/,""),c.m4a=(a.canPlayType("audio/x-m4a;")||a.canPlayType("audio/aac;")).replace(/^no$/,"")}catch(d){}return c},s.localstorage=function(){try{return localStorage.setItem(h,h),localStorage.removeItem(h),!0}catch(a){return!1}},s.sessionstorage=function(){try{return sessionStorage.setItem(h,h),sessionStorage.removeItem(h),!0}catch(a){return!1}},s.webworkers=function(){return!!a.Worker},s.applicationcache=function(){return!!a.applicationCache},s.svg=function(){return!!b.createElementNS&&!!b.createElementNS(r.svg,"svg").createSVGRect},s.inlinesvg=function(){var a=b.createElement("div");return a.innerHTML="<svg/>",(a.firstChild&&a.firstChild.namespaceURI)==r.svg},s.smil=function(){return!!b.createElementNS&&/SVGAnimate/.test(m.call(b.createElementNS(r.svg,"animate")))},s.svgclippaths=function(){return!!b.createElementNS&&/SVGClipPath/.test(m.call(b.createElementNS(r.svg,"clipPath")))};for(var L in s)C(s,L)&&(x=L.toLowerCase(),e[x]=s[L](),v.push((e[x]?"":"no-")+x));return e.input||K(),e.addTest=function(a,b){if(typeof a=="object")for(var d in a)C(a,d)&&e.addTest(d,a[d]);else{a=a.toLowerCase();if(e[a]!==c)return e;b=typeof b=="function"?b():b,typeof f!="undefined"&&f&&(g.className+=" "+(b?"":"no-")+a),e[a]=b}return e},D(""),i=k=null,function(a,b){function k(a,b){var c=a.createElement("p"),d=a.getElementsByTagName("head")[0]||a.documentElement;return c.innerHTML="x<style>"+b+"</style>",d.insertBefore(c.lastChild,d.firstChild)}function l(){var a=r.elements;return typeof a=="string"?a.split(" "):a}function m(a){var b=i[a[g]];return b||(b={},h++,a[g]=h,i[h]=b),b}function n(a,c,f){c||(c=b);if(j)return c.createElement(a);f||(f=m(c));var g;return f.cache[a]?g=f.cache[a].cloneNode():e.test(a)?g=(f.cache[a]=f.createElem(a)).cloneNode():g=f.createElem(a),g.canHaveChildren&&!d.test(a)?f.frag.appendChild(g):g}function o(a,c){a||(a=b);if(j)return a.createDocumentFragment();c=c||m(a);var d=c.frag.cloneNode(),e=0,f=l(),g=f.length;for(;e<g;e++)d.createElement(f[e]);return d}function p(a,b){b.cache||(b.cache={},b.createElem=a.createElement,b.createFrag=a.createDocumentFragment,b.frag=b.createFrag()),a.createElement=function(c){return r.shivMethods?n(c,a,b):b.createElem(c)},a.createDocumentFragment=Function("h,f","return function(){var n=f.cloneNode(),c=n.createElement;h.shivMethods&&("+l().join().replace(/\w+/g,function(a){return b.createElem(a),b.frag.createElement(a),'c("'+a+'")'})+");return n}")(r,b.frag)}function q(a){a||(a=b);var c=m(a);return r.shivCSS&&!f&&!c.hasCSS&&(c.hasCSS=!!k(a,"article,aside,figcaption,figure,footer,header,hgroup,nav,section{display:block}mark{background:#FF0;color:#000}")),j||p(a,c),a}var c=a.html5||{},d=/^<|^(?:button|map|select|textarea|object|iframe|option|optgroup)$/i,e=/^(?:a|b|code|div|fieldset|h1|h2|h3|h4|h5|h6|i|label|li|ol|p|q|span|strong|style|table|tbody|td|th|tr|ul)$/i,f,g="_html5shiv",h=0,i={},j;(function(){try{var a=b.createElement("a");a.innerHTML="<xyz></xyz>",f="hidden"in a,j=a.childNodes.length==1||function(){b.createElement("a");var a=b.createDocumentFragment();return typeof a.cloneNode=="undefined"||typeof a.createDocumentFragment=="undefined"||typeof a.createElement=="undefined"}()}catch(c){f=!0,j=!0}})();var r={elements:c.elements||"abbr article aside audio bdi canvas data datalist details figcaption figure footer header hgroup mark meter nav output progress section summary time video",shivCSS:c.shivCSS!==!1,supportsUnknownElements:j,shivMethods:c.shivMethods!==!1,type:"default",shivDocument:q,createElement:n,createDocumentFragment:o};a.html5=r,q(b)}(this,b),e._version=d,e._prefixes=n,e._domPrefixes=q,e._cssomPrefixes=p,e.mq=z,e.hasEvent=A,e.testProp=function(a){return H([a])},e.testAllProps=J,e.testStyles=y,e.prefixed=function(a,b,c){return b?J(a,b,c):J(a,"pfx")},g.className=g.className.replace(/(^|\s)no-js(\s|$)/,"$1$2")+(f?" js "+v.join(" "):""),e}(this,this.document),function(a,b,c){function d(a){return"[object Function]"==o.call(a)}function e(a){return"string"==typeof a}function f(){}function g(a){return!a||"loaded"==a||"complete"==a||"uninitialized"==a}function h(){var a=p.shift();q=1,a?a.t?m(function(){("c"==a.t?B.injectCss:B.injectJs)(a.s,0,a.a,a.x,a.e,1)},0):(a(),h()):q=0}function i(a,c,d,e,f,i,j){function k(b){if(!o&&g(l.readyState)&&(u.r=o=1,!q&&h(),l.onload=l.onreadystatechange=null,b)){"img"!=a&&m(function(){t.removeChild(l)},50);for(var d in y[c])y[c].hasOwnProperty(d)&&y[c][d].onload()}}var j=j||B.errorTimeout,l=b.createElement(a),o=0,r=0,u={t:d,s:c,e:f,a:i,x:j};1===y[c]&&(r=1,y[c]=[]),"object"==a?l.data=c:(l.src=c,l.type=a),l.width=l.height="0",l.onerror=l.onload=l.onreadystatechange=function(){k.call(this,r)},p.splice(e,0,u),"img"!=a&&(r||2===y[c]?(t.insertBefore(l,s?null:n),m(k,j)):y[c].push(l))}function j(a,b,c,d,f){return q=0,b=b||"j",e(a)?i("c"==b?v:u,a,b,this.i++,c,d,f):(p.splice(this.i++,0,a),1==p.length&&h()),this}function k(){var a=B;return a.loader={load:j,i:0},a}var l=b.documentElement,m=a.setTimeout,n=b.getElementsByTagName("script")[0],o={}.toString,p=[],q=0,r="MozAppearance"in l.style,s=r&&!!b.createRange().compareNode,t=s?l:n.parentNode,l=a.opera&&"[object Opera]"==o.call(a.opera),l=!!b.attachEvent&&!l,u=r?"object":l?"script":"img",v=l?"script":u,w=Array.isArray||function(a){return"[object Array]"==o.call(a)},x=[],y={},z={timeout:function(a,b){return b.length&&(a.timeout=b[0]),a}},A,B;B=function(a){function b(a){var a=a.split("!"),b=x.length,c=a.pop(),d=a.length,c={url:c,origUrl:c,prefixes:a},e,f,g;for(f=0;f<d;f++)g=a[f].split("="),(e=z[g.shift()])&&(c=e(c,g));for(f=0;f<b;f++)c=x[f](c);return c}function g(a,e,f,g,h){var i=b(a),j=i.autoCallback;i.url.split(".").pop().split("?").shift(),i.bypass||(e&&(e=d(e)?e:e[a]||e[g]||e[a.split("/").pop().split("?")[0]]),i.instead?i.instead(a,e,f,g,h):(y[i.url]?i.noexec=!0:y[i.url]=1,f.load(i.url,i.forceCSS||!i.forceJS&&"css"==i.url.split(".").pop().split("?").shift()?"c":c,i.noexec,i.attrs,i.timeout),(d(e)||d(j))&&f.load(function(){k(),e&&e(i.origUrl,h,g),j&&j(i.origUrl,h,g),y[i.url]=2})))}function h(a,b){function c(a,c){if(a){if(e(a))c||(j=function(){var a=[].slice.call(arguments);k.apply(this,a),l()}),g(a,j,b,0,h);else if(Object(a)===a)for(n in m=function(){var b=0,c;for(c in a)a.hasOwnProperty(c)&&b++;return b}(),a)a.hasOwnProperty(n)&&(!c&&!--m&&(d(j)?j=function(){var a=[].slice.call(arguments);k.apply(this,a),l()}:j[n]=function(a){return function(){var b=[].slice.call(arguments);a&&a.apply(this,b),l()}}(k[n])),g(a[n],j,b,n,h))}else!c&&l()}var h=!!a.test,i=a.load||a.both,j=a.callback||f,k=j,l=a.complete||f,m,n;c(h?a.yep:a.nope,!!i),i&&c(i)}var i,j,l=this.yepnope.loader;if(e(a))g(a,0,l,0);else if(w(a))for(i=0;i<a.length;i++)j=a[i],e(j)?g(j,0,l,0):w(j)?B(j):Object(j)===j&&h(j,l);else Object(a)===a&&h(a,l)},B.addPrefix=function(a,b){z[a]=b},B.addFilter=function(a){x.push(a)},B.errorTimeout=1e4,null==b.readyState&&b.addEventListener&&(b.readyState="loading",b.addEventListener("DOMContentLoaded",A=function(){b.removeEventListener("DOMContentLoaded",A,0),b.readyState="complete"},0)),a.yepnope=k(),a.yepnope.executeStack=h,a.yepnope.injectJs=function(a,c,d,e,i,j){var k=b.createElement("script"),l,o,e=e||B.errorTimeout;k.src=a;for(o in d)k.setAttribute(o,d[o]);c=j?h:c||f,k.onreadystatechange=k.onload=function(){!l&&g(k.readyState)&&(l=1,c(),k.onload=k.onreadystatechange=null)},m(function(){l||(l=1,c(1))},e),i?k.onload():n.parentNode.insertBefore(k,n)},a.yepnope.injectCss=function(a,c,d,e,g,i){var e=b.createElement("link"),j,c=i?h:c||f;e.href=a,e.rel="stylesheet",e.type="text/css";for(j in d)e.setAttribute(j,d[j]);g||(n.parentNode.insertBefore(e,n),m(c,0))}}(this,document),Modernizr.load=function(){yepnope.apply(window,[].slice.call(arguments,0))};
diff --git a/_static/mnist.pkl.gz b/_static/mnist.pkl.gz
new file mode 100644
index 00000000000..6a739549cc6
Binary files /dev/null and b/_static/mnist.pkl.gz differ
diff --git a/_static/pencil-16.png b/_static/pencil-16.png
new file mode 100644
index 00000000000..6a4f1cf688e
Binary files /dev/null and b/_static/pencil-16.png differ
diff --git a/_static/searchtools.js b/_static/searchtools.js
deleted file mode 100755
index 41b83367764..00000000000
--- a/_static/searchtools.js
+++ /dev/null
@@ -1,761 +0,0 @@
-/*
- * searchtools.js_t
- * ~~~~~~~~~~~~~~~~
- *
- * Sphinx JavaScript utilities for the full-text search.
- *
- * :copyright: Copyright 2007-2018 by the Sphinx team, see AUTHORS.
- * :license: BSD, see LICENSE for details.
- *
- */
-
-
-/* Non-minified version JS is _stemmer.js if file is provided */ 
-/**
- * Porter Stemmer
- */
-var Stemmer = function() {
-
-  var step2list = {
-    ational: 'ate',
-    tional: 'tion',
-    enci: 'ence',
-    anci: 'ance',
-    izer: 'ize',
-    bli: 'ble',
-    alli: 'al',
-    entli: 'ent',
-    eli: 'e',
-    ousli: 'ous',
-    ization: 'ize',
-    ation: 'ate',
-    ator: 'ate',
-    alism: 'al',
-    iveness: 'ive',
-    fulness: 'ful',
-    ousness: 'ous',
-    aliti: 'al',
-    iviti: 'ive',
-    biliti: 'ble',
-    logi: 'log'
-  };
-
-  var step3list = {
-    icate: 'ic',
-    ative: '',
-    alize: 'al',
-    iciti: 'ic',
-    ical: 'ic',
-    ful: '',
-    ness: ''
-  };
-
-  var c = "[^aeiou]";          // consonant
-  var v = "[aeiouy]";          // vowel
-  var C = c + "[^aeiouy]*";    // consonant sequence
-  var V = v + "[aeiou]*";      // vowel sequence
-
-  var mgr0 = "^(" + C + ")?" + V + C;                      // [C]VC... is m>0
-  var meq1 = "^(" + C + ")?" + V + C + "(" + V + ")?$";    // [C]VC[V] is m=1
-  var mgr1 = "^(" + C + ")?" + V + C + V + C;              // [C]VCVC... is m>1
-  var s_v   = "^(" + C + ")?" + v;                         // vowel in stem
-
-  this.stemWord = function (w) {
-    var stem;
-    var suffix;
-    var firstch;
-    var origword = w;
-
-    if (w.length < 3)
-      return w;
-
-    var re;
-    var re2;
-    var re3;
-    var re4;
-
-    firstch = w.substr(0,1);
-    if (firstch == "y")
-      w = firstch.toUpperCase() + w.substr(1);
-
-    // Step 1a
-    re = /^(.+?)(ss|i)es$/;
-    re2 = /^(.+?)([^s])s$/;
-
-    if (re.test(w))
-      w = w.replace(re,"$1$2");
-    else if (re2.test(w))
-      w = w.replace(re2,"$1$2");
-
-    // Step 1b
-    re = /^(.+?)eed$/;
-    re2 = /^(.+?)(ed|ing)$/;
-    if (re.test(w)) {
-      var fp = re.exec(w);
-      re = new RegExp(mgr0);
-      if (re.test(fp[1])) {
-        re = /.$/;
-        w = w.replace(re,"");
-      }
-    }
-    else if (re2.test(w)) {
-      var fp = re2.exec(w);
-      stem = fp[1];
-      re2 = new RegExp(s_v);
-      if (re2.test(stem)) {
-        w = stem;
-        re2 = /(at|bl|iz)$/;
-        re3 = new RegExp("([^aeiouylsz])\\1$");
-        re4 = new RegExp("^" + C + v + "[^aeiouwxy]$");
-        if (re2.test(w))
-          w = w + "e";
-        else if (re3.test(w)) {
-          re = /.$/;
-          w = w.replace(re,"");
-        }
-        else if (re4.test(w))
-          w = w + "e";
-      }
-    }
-
-    // Step 1c
-    re = /^(.+?)y$/;
-    if (re.test(w)) {
-      var fp = re.exec(w);
-      stem = fp[1];
-      re = new RegExp(s_v);
-      if (re.test(stem))
-        w = stem + "i";
-    }
-
-    // Step 2
-    re = /^(.+?)(ational|tional|enci|anci|izer|bli|alli|entli|eli|ousli|ization|ation|ator|alism|iveness|fulness|ousness|aliti|iviti|biliti|logi)$/;
-    if (re.test(w)) {
-      var fp = re.exec(w);
-      stem = fp[1];
-      suffix = fp[2];
-      re = new RegExp(mgr0);
-      if (re.test(stem))
-        w = stem + step2list[suffix];
-    }
-
-    // Step 3
-    re = /^(.+?)(icate|ative|alize|iciti|ical|ful|ness)$/;
-    if (re.test(w)) {
-      var fp = re.exec(w);
-      stem = fp[1];
-      suffix = fp[2];
-      re = new RegExp(mgr0);
-      if (re.test(stem))
-        w = stem + step3list[suffix];
-    }
-
-    // Step 4
-    re = /^(.+?)(al|ance|ence|er|ic|able|ible|ant|ement|ment|ent|ou|ism|ate|iti|ous|ive|ize)$/;
-    re2 = /^(.+?)(s|t)(ion)$/;
-    if (re.test(w)) {
-      var fp = re.exec(w);
-      stem = fp[1];
-      re = new RegExp(mgr1);
-      if (re.test(stem))
-        w = stem;
-    }
-    else if (re2.test(w)) {
-      var fp = re2.exec(w);
-      stem = fp[1] + fp[2];
-      re2 = new RegExp(mgr1);
-      if (re2.test(stem))
-        w = stem;
-    }
-
-    // Step 5
-    re = /^(.+?)e$/;
-    if (re.test(w)) {
-      var fp = re.exec(w);
-      stem = fp[1];
-      re = new RegExp(mgr1);
-      re2 = new RegExp(meq1);
-      re3 = new RegExp("^" + C + v + "[^aeiouwxy]$");
-      if (re.test(stem) || (re2.test(stem) && !(re3.test(stem))))
-        w = stem;
-    }
-    re = /ll$/;
-    re2 = new RegExp(mgr1);
-    if (re.test(w) && re2.test(w)) {
-      re = /.$/;
-      w = w.replace(re,"");
-    }
-
-    // and turn initial Y back to y
-    if (firstch == "y")
-      w = firstch.toLowerCase() + w.substr(1);
-    return w;
-  }
-}
-
-
-
-/**
- * Simple result scoring code.
- */
-var Scorer = {
-  // Implement the following function to further tweak the score for each result
-  // The function takes a result array [filename, title, anchor, descr, score]
-  // and returns the new score.
-  /*
-  score: function(result) {
-    return result[4];
-  },
-  */
-
-  // query matches the full name of an object
-  objNameMatch: 11,
-  // or matches in the last dotted part of the object name
-  objPartialMatch: 6,
-  // Additive scores depending on the priority of the object
-  objPrio: {0:  15,   // used to be importantResults
-            1:  5,   // used to be objectResults
-            2: -5},  // used to be unimportantResults
-  //  Used when the priority is not in the mapping.
-  objPrioDefault: 0,
-
-  // query found in title
-  title: 15,
-  // query found in terms
-  term: 5
-};
-
-
-
-
-
-var splitChars = (function() {
-    var result = {};
-    var singles = [96, 180, 187, 191, 215, 247, 749, 885, 903, 907, 909, 930, 1014, 1648,
-         1748, 1809, 2416, 2473, 2481, 2526, 2601, 2609, 2612, 2615, 2653, 2702,
-         2706, 2729, 2737, 2740, 2857, 2865, 2868, 2910, 2928, 2948, 2961, 2971,
-         2973, 3085, 3089, 3113, 3124, 3213, 3217, 3241, 3252, 3295, 3341, 3345,
-         3369, 3506, 3516, 3633, 3715, 3721, 3736, 3744, 3748, 3750, 3756, 3761,
-         3781, 3912, 4239, 4347, 4681, 4695, 4697, 4745, 4785, 4799, 4801, 4823,
-         4881, 5760, 5901, 5997, 6313, 7405, 8024, 8026, 8028, 8030, 8117, 8125,
-         8133, 8181, 8468, 8485, 8487, 8489, 8494, 8527, 11311, 11359, 11687, 11695,
-         11703, 11711, 11719, 11727, 11735, 12448, 12539, 43010, 43014, 43019, 43587,
-         43696, 43713, 64286, 64297, 64311, 64317, 64319, 64322, 64325, 65141];
-    var i, j, start, end;
-    for (i = 0; i < singles.length; i++) {
-        result[singles[i]] = true;
-    }
-    var ranges = [[0, 47], [58, 64], [91, 94], [123, 169], [171, 177], [182, 184], [706, 709],
-         [722, 735], [741, 747], [751, 879], [888, 889], [894, 901], [1154, 1161],
-         [1318, 1328], [1367, 1368], [1370, 1376], [1416, 1487], [1515, 1519], [1523, 1568],
-         [1611, 1631], [1642, 1645], [1750, 1764], [1767, 1773], [1789, 1790], [1792, 1807],
-         [1840, 1868], [1958, 1968], [1970, 1983], [2027, 2035], [2038, 2041], [2043, 2047],
-         [2070, 2073], [2075, 2083], [2085, 2087], [2089, 2307], [2362, 2364], [2366, 2383],
-         [2385, 2391], [2402, 2405], [2419, 2424], [2432, 2436], [2445, 2446], [2449, 2450],
-         [2483, 2485], [2490, 2492], [2494, 2509], [2511, 2523], [2530, 2533], [2546, 2547],
-         [2554, 2564], [2571, 2574], [2577, 2578], [2618, 2648], [2655, 2661], [2672, 2673],
-         [2677, 2692], [2746, 2748], [2750, 2767], [2769, 2783], [2786, 2789], [2800, 2820],
-         [2829, 2830], [2833, 2834], [2874, 2876], [2878, 2907], [2914, 2917], [2930, 2946],
-         [2955, 2957], [2966, 2968], [2976, 2978], [2981, 2983], [2987, 2989], [3002, 3023],
-         [3025, 3045], [3059, 3076], [3130, 3132], [3134, 3159], [3162, 3167], [3170, 3173],
-         [3184, 3191], [3199, 3204], [3258, 3260], [3262, 3293], [3298, 3301], [3312, 3332],
-         [3386, 3388], [3390, 3423], [3426, 3429], [3446, 3449], [3456, 3460], [3479, 3481],
-         [3518, 3519], [3527, 3584], [3636, 3647], [3655, 3663], [3674, 3712], [3717, 3718],
-         [3723, 3724], [3726, 3731], [3752, 3753], [3764, 3772], [3774, 3775], [3783, 3791],
-         [3802, 3803], [3806, 3839], [3841, 3871], [3892, 3903], [3949, 3975], [3980, 4095],
-         [4139, 4158], [4170, 4175], [4182, 4185], [4190, 4192], [4194, 4196], [4199, 4205],
-         [4209, 4212], [4226, 4237], [4250, 4255], [4294, 4303], [4349, 4351], [4686, 4687],
-         [4702, 4703], [4750, 4751], [4790, 4791], [4806, 4807], [4886, 4887], [4955, 4968],
-         [4989, 4991], [5008, 5023], [5109, 5120], [5741, 5742], [5787, 5791], [5867, 5869],
-         [5873, 5887], [5906, 5919], [5938, 5951], [5970, 5983], [6001, 6015], [6068, 6102],
-         [6104, 6107], [6109, 6111], [6122, 6127], [6138, 6159], [6170, 6175], [6264, 6271],
-         [6315, 6319], [6390, 6399], [6429, 6469], [6510, 6511], [6517, 6527], [6572, 6592],
-         [6600, 6607], [6619, 6655], [6679, 6687], [6741, 6783], [6794, 6799], [6810, 6822],
-         [6824, 6916], [6964, 6980], [6988, 6991], [7002, 7042], [7073, 7085], [7098, 7167],
-         [7204, 7231], [7242, 7244], [7294, 7400], [7410, 7423], [7616, 7679], [7958, 7959],
-         [7966, 7967], [8006, 8007], [8014, 8015], [8062, 8063], [8127, 8129], [8141, 8143],
-         [8148, 8149], [8156, 8159], [8173, 8177], [8189, 8303], [8306, 8307], [8314, 8318],
-         [8330, 8335], [8341, 8449], [8451, 8454], [8456, 8457], [8470, 8472], [8478, 8483],
-         [8506, 8507], [8512, 8516], [8522, 8525], [8586, 9311], [9372, 9449], [9472, 10101],
-         [10132, 11263], [11493, 11498], [11503, 11516], [11518, 11519], [11558, 11567],
-         [11622, 11630], [11632, 11647], [11671, 11679], [11743, 11822], [11824, 12292],
-         [12296, 12320], [12330, 12336], [12342, 12343], [12349, 12352], [12439, 12444],
-         [12544, 12548], [12590, 12592], [12687, 12689], [12694, 12703], [12728, 12783],
-         [12800, 12831], [12842, 12880], [12896, 12927], [12938, 12976], [12992, 13311],
-         [19894, 19967], [40908, 40959], [42125, 42191], [42238, 42239], [42509, 42511],
-         [42540, 42559], [42592, 42593], [42607, 42622], [42648, 42655], [42736, 42774],
-         [42784, 42785], [42889, 42890], [42893, 43002], [43043, 43055], [43062, 43071],
-         [43124, 43137], [43188, 43215], [43226, 43249], [43256, 43258], [43260, 43263],
-         [43302, 43311], [43335, 43359], [43389, 43395], [43443, 43470], [43482, 43519],
-         [43561, 43583], [43596, 43599], [43610, 43615], [43639, 43641], [43643, 43647],
-         [43698, 43700], [43703, 43704], [43710, 43711], [43715, 43738], [43742, 43967],
-         [44003, 44015], [44026, 44031], [55204, 55215], [55239, 55242], [55292, 55295],
-         [57344, 63743], [64046, 64047], [64110, 64111], [64218, 64255], [64263, 64274],
-         [64280, 64284], [64434, 64466], [64830, 64847], [64912, 64913], [64968, 65007],
-         [65020, 65135], [65277, 65295], [65306, 65312], [65339, 65344], [65371, 65381],
-         [65471, 65473], [65480, 65481], [65488, 65489], [65496, 65497]];
-    for (i = 0; i < ranges.length; i++) {
-        start = ranges[i][0];
-        end = ranges[i][1];
-        for (j = start; j <= end; j++) {
-            result[j] = true;
-        }
-    }
-    return result;
-})();
-
-function splitQuery(query) {
-    var result = [];
-    var start = -1;
-    for (var i = 0; i < query.length; i++) {
-        if (splitChars[query.charCodeAt(i)]) {
-            if (start !== -1) {
-                result.push(query.slice(start, i));
-                start = -1;
-            }
-        } else if (start === -1) {
-            start = i;
-        }
-    }
-    if (start !== -1) {
-        result.push(query.slice(start));
-    }
-    return result;
-}
-
-
-
-
-/**
- * Search Module
- */
-var Search = {
-
-  _index : null,
-  _queued_query : null,
-  _pulse_status : -1,
-
-  init : function() {
-      var params = $.getQueryParameters();
-      if (params.q) {
-          var query = params.q[0];
-          $('input[name="q"]')[0].value = query;
-          this.performSearch(query);
-      }
-  },
-
-  loadIndex : function(url) {
-    $.ajax({type: "GET", url: url, data: null,
-            dataType: "script", cache: true,
-            complete: function(jqxhr, textstatus) {
-              if (textstatus != "success") {
-                document.getElementById("searchindexloader").src = url;
-              }
-            }});
-  },
-
-  setIndex : function(index) {
-    var q;
-    this._index = index;
-    if ((q = this._queued_query) !== null) {
-      this._queued_query = null;
-      Search.query(q);
-    }
-  },
-
-  hasIndex : function() {
-      return this._index !== null;
-  },
-
-  deferQuery : function(query) {
-      this._queued_query = query;
-  },
-
-  stopPulse : function() {
-      this._pulse_status = 0;
-  },
-
-  startPulse : function() {
-    if (this._pulse_status >= 0)
-        return;
-    function pulse() {
-      var i;
-      Search._pulse_status = (Search._pulse_status + 1) % 4;
-      var dotString = '';
-      for (i = 0; i < Search._pulse_status; i++)
-        dotString += '.';
-      Search.dots.text(dotString);
-      if (Search._pulse_status > -1)
-        window.setTimeout(pulse, 500);
-    }
-    pulse();
-  },
-
-  /**
-   * perform a search for something (or wait until index is loaded)
-   */
-  performSearch : function(query) {
-    // create the required interface elements
-    this.out = $('#search-results');
-    this.title = $('<h2>' + _('Searching') + '</h2>').appendTo(this.out);
-    this.dots = $('<span></span>').appendTo(this.title);
-    this.status = $('<p style="display: none"></p>').appendTo(this.out);
-    this.output = $('<ul class="search"/>').appendTo(this.out);
-
-    $('#search-progress').text(_('Preparing search...'));
-    this.startPulse();
-
-    // index already loaded, the browser was quick!
-    if (this.hasIndex())
-      this.query(query);
-    else
-      this.deferQuery(query);
-  },
-
-  /**
-   * execute search (requires search index to be loaded)
-   */
-  query : function(query) {
-    var i;
-    var stopwords = ["a","and","are","as","at","be","but","by","for","if","in","into","is","it","near","no","not","of","on","or","such","that","the","their","then","there","these","they","this","to","was","will","with"];
-
-    // stem the searchterms and add them to the correct list
-    var stemmer = new Stemmer();
-    var searchterms = [];
-    var excluded = [];
-    var hlterms = [];
-    var tmp = splitQuery(query);
-    var objectterms = [];
-    for (i = 0; i < tmp.length; i++) {
-      if (tmp[i] !== "") {
-          objectterms.push(tmp[i].toLowerCase());
-      }
-
-      if ($u.indexOf(stopwords, tmp[i].toLowerCase()) != -1 || tmp[i].match(/^\d+$/) ||
-          tmp[i] === "") {
-        // skip this "word"
-        continue;
-      }
-      // stem the word
-      var word = stemmer.stemWord(tmp[i].toLowerCase());
-      // prevent stemmer from cutting word smaller than two chars
-      if(word.length < 3 && tmp[i].length >= 3) {
-        word = tmp[i];
-      }
-      var toAppend;
-      // select the correct list
-      if (word[0] == '-') {
-        toAppend = excluded;
-        word = word.substr(1);
-      }
-      else {
-        toAppend = searchterms;
-        hlterms.push(tmp[i].toLowerCase());
-      }
-      // only add if not already in the list
-      if (!$u.contains(toAppend, word))
-        toAppend.push(word);
-    }
-    var highlightstring = '?highlight=' + $.urlencode(hlterms.join(" "));
-
-    // console.debug('SEARCH: searching for:');
-    // console.info('required: ', searchterms);
-    // console.info('excluded: ', excluded);
-
-    // prepare search
-    var terms = this._index.terms;
-    var titleterms = this._index.titleterms;
-
-    // array of [filename, title, anchor, descr, score]
-    var results = [];
-    $('#search-progress').empty();
-
-    // lookup as object
-    for (i = 0; i < objectterms.length; i++) {
-      var others = [].concat(objectterms.slice(0, i),
-                             objectterms.slice(i+1, objectterms.length));
-      results = results.concat(this.performObjectSearch(objectterms[i], others));
-    }
-
-    // lookup as search terms in fulltext
-    results = results.concat(this.performTermsSearch(searchterms, excluded, terms, titleterms));
-
-    // let the scorer override scores with a custom scoring function
-    if (Scorer.score) {
-      for (i = 0; i < results.length; i++)
-        results[i][4] = Scorer.score(results[i]);
-    }
-
-    // now sort the results by score (in opposite order of appearance, since the
-    // display function below uses pop() to retrieve items) and then
-    // alphabetically
-    results.sort(function(a, b) {
-      var left = a[4];
-      var right = b[4];
-      if (left > right) {
-        return 1;
-      } else if (left < right) {
-        return -1;
-      } else {
-        // same score: sort alphabetically
-        left = a[1].toLowerCase();
-        right = b[1].toLowerCase();
-        return (left > right) ? -1 : ((left < right) ? 1 : 0);
-      }
-    });
-
-    // for debugging
-    //Search.lastresults = results.slice();  // a copy
-    //console.info('search results:', Search.lastresults);
-
-    // print the results
-    var resultCount = results.length;
-    function displayNextItem() {
-      // results left, load the summary and display it
-      if (results.length) {
-        var item = results.pop();
-        var listItem = $('<li style="display:none"></li>');
-        if (DOCUMENTATION_OPTIONS.FILE_SUFFIX === '') {
-          // dirhtml builder
-          var dirname = item[0] + '/';
-          if (dirname.match(/\/index\/$/)) {
-            dirname = dirname.substring(0, dirname.length-6);
-          } else if (dirname == 'index/') {
-            dirname = '';
-          }
-          listItem.append($('<a/>').attr('href',
-            DOCUMENTATION_OPTIONS.URL_ROOT + dirname +
-            highlightstring + item[2]).html(item[1]));
-        } else {
-          // normal html builders
-          listItem.append($('<a/>').attr('href',
-            item[0] + DOCUMENTATION_OPTIONS.FILE_SUFFIX +
-            highlightstring + item[2]).html(item[1]));
-        }
-        if (item[3]) {
-          listItem.append($('<span> (' + item[3] + ')</span>'));
-          Search.output.append(listItem);
-          listItem.slideDown(5, function() {
-            displayNextItem();
-          });
-        } else if (DOCUMENTATION_OPTIONS.HAS_SOURCE) {
-          var suffix = DOCUMENTATION_OPTIONS.SOURCELINK_SUFFIX;
-          if (suffix === undefined) {
-            suffix = '.txt';
-          }
-          $.ajax({url: DOCUMENTATION_OPTIONS.URL_ROOT + '_sources/' + item[5] + (item[5].slice(-suffix.length) === suffix ? '' : suffix),
-                  dataType: "text",
-                  complete: function(jqxhr, textstatus) {
-                    var data = jqxhr.responseText;
-                    if (data !== '' && data !== undefined) {
-                      listItem.append(Search.makeSearchSummary(data, searchterms, hlterms));
-                    }
-                    Search.output.append(listItem);
-                    listItem.slideDown(5, function() {
-                      displayNextItem();
-                    });
-                  }});
-        } else {
-          // no source available, just display title
-          Search.output.append(listItem);
-          listItem.slideDown(5, function() {
-            displayNextItem();
-          });
-        }
-      }
-      // search finished, update title and status message
-      else {
-        Search.stopPulse();
-        Search.title.text(_('Search Results'));
-        if (!resultCount)
-          Search.status.text(_('Your search did not match any documents. Please make sure that all words are spelled correctly and that you\'ve selected enough categories.'));
-        else
-            Search.status.text(_('Search finished, found %s page(s) matching the search query.').replace('%s', resultCount));
-        Search.status.fadeIn(500);
-      }
-    }
-    displayNextItem();
-  },
-
-  /**
-   * search for object names
-   */
-  performObjectSearch : function(object, otherterms) {
-    var filenames = this._index.filenames;
-    var docnames = this._index.docnames;
-    var objects = this._index.objects;
-    var objnames = this._index.objnames;
-    var titles = this._index.titles;
-
-    var i;
-    var results = [];
-
-    for (var prefix in objects) {
-      for (var name in objects[prefix]) {
-        var fullname = (prefix ? prefix + '.' : '') + name;
-        if (fullname.toLowerCase().indexOf(object) > -1) {
-          var score = 0;
-          var parts = fullname.split('.');
-          // check for different match types: exact matches of full name or
-          // "last name" (i.e. last dotted part)
-          if (fullname == object || parts[parts.length - 1] == object) {
-            score += Scorer.objNameMatch;
-          // matches in last name
-          } else if (parts[parts.length - 1].indexOf(object) > -1) {
-            score += Scorer.objPartialMatch;
-          }
-          var match = objects[prefix][name];
-          var objname = objnames[match[1]][2];
-          var title = titles[match[0]];
-          // If more than one term searched for, we require other words to be
-          // found in the name/title/description
-          if (otherterms.length > 0) {
-            var haystack = (prefix + ' ' + name + ' ' +
-                            objname + ' ' + title).toLowerCase();
-            var allfound = true;
-            for (i = 0; i < otherterms.length; i++) {
-              if (haystack.indexOf(otherterms[i]) == -1) {
-                allfound = false;
-                break;
-              }
-            }
-            if (!allfound) {
-              continue;
-            }
-          }
-          var descr = objname + _(', in ') + title;
-
-          var anchor = match[3];
-          if (anchor === '')
-            anchor = fullname;
-          else if (anchor == '-')
-            anchor = objnames[match[1]][1] + '-' + fullname;
-          // add custom score for some objects according to scorer
-          if (Scorer.objPrio.hasOwnProperty(match[2])) {
-            score += Scorer.objPrio[match[2]];
-          } else {
-            score += Scorer.objPrioDefault;
-          }
-          results.push([docnames[match[0]], fullname, '#'+anchor, descr, score, filenames[match[0]]]);
-        }
-      }
-    }
-
-    return results;
-  },
-
-  /**
-   * search for full-text terms in the index
-   */
-  performTermsSearch : function(searchterms, excluded, terms, titleterms) {
-    var docnames = this._index.docnames;
-    var filenames = this._index.filenames;
-    var titles = this._index.titles;
-
-    var i, j, file;
-    var fileMap = {};
-    var scoreMap = {};
-    var results = [];
-
-    // perform the search on the required terms
-    for (i = 0; i < searchterms.length; i++) {
-      var word = searchterms[i];
-      var files = [];
-      var _o = [
-        {files: terms[word], score: Scorer.term},
-        {files: titleterms[word], score: Scorer.title}
-      ];
-
-      // no match but word was a required one
-      if ($u.every(_o, function(o){return o.files === undefined;})) {
-        break;
-      }
-      // found search word in contents
-      $u.each(_o, function(o) {
-        var _files = o.files;
-        if (_files === undefined)
-          return
-
-        if (_files.length === undefined)
-          _files = [_files];
-        files = files.concat(_files);
-
-        // set score for the word in each file to Scorer.term
-        for (j = 0; j < _files.length; j++) {
-          file = _files[j];
-          if (!(file in scoreMap))
-            scoreMap[file] = {}
-          scoreMap[file][word] = o.score;
-        }
-      });
-
-      // create the mapping
-      for (j = 0; j < files.length; j++) {
-        file = files[j];
-        if (file in fileMap)
-          fileMap[file].push(word);
-        else
-          fileMap[file] = [word];
-      }
-    }
-
-    // now check if the files don't contain excluded terms
-    for (file in fileMap) {
-      var valid = true;
-
-      // check if all requirements are matched
-      if (fileMap[file].length != searchterms.length)
-          continue;
-
-      // ensure that none of the excluded terms is in the search result
-      for (i = 0; i < excluded.length; i++) {
-        if (terms[excluded[i]] == file ||
-            titleterms[excluded[i]] == file ||
-            $u.contains(terms[excluded[i]] || [], file) ||
-            $u.contains(titleterms[excluded[i]] || [], file)) {
-          valid = false;
-          break;
-        }
-      }
-
-      // if we have still a valid result we can add it to the result list
-      if (valid) {
-        // select one (max) score for the file.
-        // for better ranking, we should calculate ranking by using words statistics like basic tf-idf...
-        var score = $u.max($u.map(fileMap[file], function(w){return scoreMap[file][w]}));
-        results.push([docnames[file], titles[file], '', null, score, filenames[file]]);
-      }
-    }
-    return results;
-  },
-
-  /**
-   * helper function to return a node containing the
-   * search summary for a given text. keywords is a list
-   * of stemmed words, hlwords is the list of normal, unstemmed
-   * words. the first one is used to find the occurrence, the
-   * latter for highlighting it.
-   */
-  makeSearchSummary : function(text, keywords, hlwords) {
-    var textLower = text.toLowerCase();
-    var start = 0;
-    $.each(keywords, function() {
-      var i = textLower.indexOf(this.toLowerCase());
-      if (i > -1)
-        start = i;
-    });
-    start = Math.max(start - 120, 0);
-    var excerpt = ((start > 0) ? '...' : '') +
-      $.trim(text.substr(start, 240)) +
-      ((start + 240 - text.length) ? '...' : '');
-    var rv = $('<div class="context"></div>').text(excerpt);
-    $.each(hlwords, function() {
-      rv = rv.highlightText(this, 'highlighted');
-    });
-    return rv;
-  }
-};
-
-$(document).ready(function() {
-  Search.init();
-});
\ No newline at end of file
diff --git a/_static/torchvision_finetuning_instance_segmentation.ipynb b/_static/torchvision_finetuning_instance_segmentation.ipynb
deleted file mode 100644
index 79fef91f3ae..00000000000
--- a/_static/torchvision_finetuning_instance_segmentation.ipynb
+++ /dev/null
@@ -1,2605 +0,0 @@
-{
-  "nbformat": 4,
-  "nbformat_minor": 0,
-  "metadata": {
-    "colab": {
-      "name": "torchvision_finetuning_instance_segmentation.ipynb",
-      "version": "0.3.2",
-      "provenance": [],
-      "collapsed_sections": []
-    },
-    "kernelspec": {
-      "name": "python3",
-      "display_name": "Python 3"
-    },
-    "accelerator": "GPU"
-  },
-  "cells": [
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "DfPPQ6ztJhv4",
-        "colab_type": "text"
-      },
-      "source": [
-        "# TorchVision 0.3 Object Detection finetuning tutorial\n",
-        "\n",
-        "For this tutorial, we will be finetuning a pre-trained [Mask R-CNN](https://arxiv.org/abs/1703.06870) model in the [*Penn-Fudan Database for Pedestrian Detection and Segmentation*](https://www.cis.upenn.edu/~jshi/ped_html/). It contains 170 images with 345 instances of pedestrians, and we will use it to illustrate how to use the new features in torchvision in order to train an instance segmentation model on a custom dataset.\n",
-        "\n",
-        "First, we need to install `pycocotools`. This library will be used for computing the evaluation metrics following the COCO metric for intersection over union."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "DBIoe_tHTQgV",
-        "colab_type": "code",
-        "outputId": "de73add6-c54a-4d53-960e-ac0032ab4009",
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 10356
-        }
-      },
-      "source": [
-        "%%shell\n",
-        "\n",
-        "CURRENT_DIR=`pwd`\n",
-        "echo $CURRENT_DIR\n",
-        "\n",
-        "# Install pycocotools\n",
-        "git clone https://github.com/cocodataset/cocoapi.git\n",
-        "cd cocoapi/PythonAPI\n",
-        "python setup.py build_ext install\n",
-        "\n",
-        "cd $CURRENT_DIR\n",
-        "\n",
-        "######################################################\n",
-        "# TODO remove this once torchvision 0.3 is present by\n",
-        "# default in Colab\n",
-        "######################################################\n",
-        "pip uninstall -y torchvision\n",
-        "git clone https://github.com/pytorch/vision.git\n",
-        "cd vision\n",
-        "git checkout v0.3.0\n",
-        "python setup.py install\n",
-        "# why do we need this?\n",
-        "cp -r build/lib.linux-x86_64-3.6/torchvision /usr/local/lib/python3.6/dist-packages/"
-      ],
-      "execution_count": 0,
-      "outputs": [
-        {
-          "output_type": "stream",
-          "text": [
-            "/content\n",
-            "Cloning into 'cocoapi'...\n",
-            "remote: Enumerating objects: 953, done.\u001b[K\n",
-            "remote: Total 953 (delta 0), reused 0 (delta 0), pack-reused 953\u001b[K\n",
-            "Receiving objects: 100% (953/953), 11.70 MiB | 29.29 MiB/s, done.\n",
-            "Resolving deltas: 100% (566/566), done.\n",
-            "running build_ext\n",
-            "cythoning pycocotools/_mask.pyx to pycocotools/_mask.c\n",
-            "/usr/local/lib/python3.6/dist-packages/Cython/Compiler/Main.py:367: FutureWarning: Cython directive 'language_level' not set, using 2 for now (Py2). This will change in a later release! File: /content/cocoapi/PythonAPI/pycocotools/_mask.pyx\n",
-            "  tree = Parsing.p_module(s, pxd, full_module_name)\n",
-            "building 'pycocotools._mask' extension\n",
-            "creating build\n",
-            "creating build/common\n",
-            "creating build/temp.linux-x86_64-3.6\n",
-            "creating build/temp.linux-x86_64-3.6/pycocotools\n",
-            "x86_64-linux-gnu-gcc -pthread -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -Wdate-time -D_FORTIFY_SOURCE=2 -fPIC -I/usr/local/lib/python3.6/dist-packages/numpy/core/include -I../common -I/usr/include/python3.6m -c ../common/maskApi.c -o build/temp.linux-x86_64-3.6/../common/maskApi.o -Wno-cpp -Wno-unused-function -std=c99\n",
-            "\u001b[01m\u001b[K../common/maskApi.c:\u001b[m\u001b[K In function ‘\u001b[01m\u001b[KrleDecode\u001b[m\u001b[K’:\n",
-            "\u001b[01m\u001b[K../common/maskApi.c:46:7:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[Kthis ‘\u001b[01m\u001b[Kfor\u001b[m\u001b[K’ clause does not guard... [\u001b[01;35m\u001b[K-Wmisleading-indentation\u001b[m\u001b[K]\n",
-            "       \u001b[01;35m\u001b[Kfor\u001b[m\u001b[K( k=0; k<R[i].cnts[j]; k++ ) *(M++)=v; v=!v; }}\n",
-            "       \u001b[01;35m\u001b[K^~~\u001b[m\u001b[K\n",
-            "\u001b[01m\u001b[K../common/maskApi.c:46:49:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[K...this statement, but the latter is misleadingly indented as if it were guarded by the ‘\u001b[01m\u001b[Kfor\u001b[m\u001b[K’\n",
-            "       for( k=0; k<R[i].cnts[j]; k++ ) *(M++)=v; \u001b[01;36m\u001b[Kv\u001b[m\u001b[K=!v; }}\n",
-            "                                                 \u001b[01;36m\u001b[K^\u001b[m\u001b[K\n",
-            "\u001b[01m\u001b[K../common/maskApi.c:\u001b[m\u001b[K In function ‘\u001b[01m\u001b[KrleFrPoly\u001b[m\u001b[K’:\n",
-            "\u001b[01m\u001b[K../common/maskApi.c:166:3:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[Kthis ‘\u001b[01m\u001b[Kfor\u001b[m\u001b[K’ clause does not guard... [\u001b[01;35m\u001b[K-Wmisleading-indentation\u001b[m\u001b[K]\n",
-            "   \u001b[01;35m\u001b[Kfor\u001b[m\u001b[K(j=0; j<k; j++) x[j]=(int)(scale*xy[j*2+0]+.5); x[k]=x[0];\n",
-            "   \u001b[01;35m\u001b[K^~~\u001b[m\u001b[K\n",
-            "\u001b[01m\u001b[K../common/maskApi.c:166:54:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[K...this statement, but the latter is misleadingly indented as if it were guarded by the ‘\u001b[01m\u001b[Kfor\u001b[m\u001b[K’\n",
-            "   for(j=0; j<k; j++) x[j]=(int)(scale*xy[j*2+0]+.5); \u001b[01;36m\u001b[Kx\u001b[m\u001b[K[k]=x[0];\n",
-            "                                                      \u001b[01;36m\u001b[K^\u001b[m\u001b[K\n",
-            "\u001b[01m\u001b[K../common/maskApi.c:167:3:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[Kthis ‘\u001b[01m\u001b[Kfor\u001b[m\u001b[K’ clause does not guard... [\u001b[01;35m\u001b[K-Wmisleading-indentation\u001b[m\u001b[K]\n",
-            "   \u001b[01;35m\u001b[Kfor\u001b[m\u001b[K(j=0; j<k; j++) y[j]=(int)(scale*xy[j*2+1]+.5); y[k]=y[0];\n",
-            "   \u001b[01;35m\u001b[K^~~\u001b[m\u001b[K\n",
-            "\u001b[01m\u001b[K../common/maskApi.c:167:54:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[K...this statement, but the latter is misleadingly indented as if it were guarded by the ‘\u001b[01m\u001b[Kfor\u001b[m\u001b[K’\n",
-            "   for(j=0; j<k; j++) y[j]=(int)(scale*xy[j*2+1]+.5); \u001b[01;36m\u001b[Ky\u001b[m\u001b[K[k]=y[0];\n",
-            "                                                      \u001b[01;36m\u001b[K^\u001b[m\u001b[K\n",
-            "\u001b[01m\u001b[K../common/maskApi.c:\u001b[m\u001b[K In function ‘\u001b[01m\u001b[KrleToString\u001b[m\u001b[K’:\n",
-            "\u001b[01m\u001b[K../common/maskApi.c:212:7:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[Kthis ‘\u001b[01m\u001b[Kif\u001b[m\u001b[K’ clause does not guard... [\u001b[01;35m\u001b[K-Wmisleading-indentation\u001b[m\u001b[K]\n",
-            "       \u001b[01;35m\u001b[Kif\u001b[m\u001b[K(more) c |= 0x20; c+=48; s[p++]=c;\n",
-            "       \u001b[01;35m\u001b[K^~\u001b[m\u001b[K\n",
-            "\u001b[01m\u001b[K../common/maskApi.c:212:27:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[K...this statement, but the latter is misleadingly indented as if it were guarded by the ‘\u001b[01m\u001b[Kif\u001b[m\u001b[K’\n",
-            "       if(more) c |= 0x20; \u001b[01;36m\u001b[Kc\u001b[m\u001b[K+=48; s[p++]=c;\n",
-            "                           \u001b[01;36m\u001b[K^\u001b[m\u001b[K\n",
-            "\u001b[01m\u001b[K../common/maskApi.c:\u001b[m\u001b[K In function ‘\u001b[01m\u001b[KrleFrString\u001b[m\u001b[K’:\n",
-            "\u001b[01m\u001b[K../common/maskApi.c:220:3:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[Kthis ‘\u001b[01m\u001b[Kwhile\u001b[m\u001b[K’ clause does not guard... [\u001b[01;35m\u001b[K-Wmisleading-indentation\u001b[m\u001b[K]\n",
-            "   \u001b[01;35m\u001b[Kwhile\u001b[m\u001b[K( s[m] ) m++; cnts=malloc(sizeof(uint)*m); m=0;\n",
-            "   \u001b[01;35m\u001b[K^~~~~\u001b[m\u001b[K\n",
-            "\u001b[01m\u001b[K../common/maskApi.c:220:22:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[K...this statement, but the latter is misleadingly indented as if it were guarded by the ‘\u001b[01m\u001b[Kwhile\u001b[m\u001b[K’\n",
-            "   while( s[m] ) m++; \u001b[01;36m\u001b[Kcnts\u001b[m\u001b[K=malloc(sizeof(uint)*m); m=0;\n",
-            "                      \u001b[01;36m\u001b[K^~~~\u001b[m\u001b[K\n",
-            "\u001b[01m\u001b[K../common/maskApi.c:228:5:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[Kthis ‘\u001b[01m\u001b[Kif\u001b[m\u001b[K’ clause does not guard... [\u001b[01;35m\u001b[K-Wmisleading-indentation\u001b[m\u001b[K]\n",
-            "     \u001b[01;35m\u001b[Kif\u001b[m\u001b[K(m>2) x+=(long) cnts[m-2]; cnts[m++]=(uint) x;\n",
-            "     \u001b[01;35m\u001b[K^~\u001b[m\u001b[K\n",
-            "\u001b[01m\u001b[K../common/maskApi.c:228:34:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[K...this statement, but the latter is misleadingly indented as if it were guarded by the ‘\u001b[01m\u001b[Kif\u001b[m\u001b[K’\n",
-            "     if(m>2) x+=(long) cnts[m-2]; \u001b[01;36m\u001b[Kcnts\u001b[m\u001b[K[m++]=(uint) x;\n",
-            "                                  \u001b[01;36m\u001b[K^~~~\u001b[m\u001b[K\n",
-            "\u001b[01m\u001b[K../common/maskApi.c:\u001b[m\u001b[K In function ‘\u001b[01m\u001b[KrleToBbox\u001b[m\u001b[K’:\n",
-            "\u001b[01m\u001b[K../common/maskApi.c:141:31:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[Kxp\u001b[m\u001b[K’ may be used uninitialized in this function [\u001b[01;35m\u001b[K-Wmaybe-uninitialized\u001b[m\u001b[K]\n",
-            "       if(j%2==0) xp=x; else if\u001b[01;35m\u001b[K(\u001b[m\u001b[Kxp<x) { ys=0; ye=h-1; }\n",
-            "                               \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
-            "x86_64-linux-gnu-gcc -pthread -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -Wdate-time -D_FORTIFY_SOURCE=2 -fPIC -I/usr/local/lib/python3.6/dist-packages/numpy/core/include -I../common -I/usr/include/python3.6m -c pycocotools/_mask.c -o build/temp.linux-x86_64-3.6/pycocotools/_mask.o -Wno-cpp -Wno-unused-function -std=c99\n",
-            "creating build/lib.linux-x86_64-3.6\n",
-            "creating build/lib.linux-x86_64-3.6/pycocotools\n",
-            "x86_64-linux-gnu-gcc -pthread -shared -Wl,-O1 -Wl,-Bsymbolic-functions -Wl,-Bsymbolic-functions -Wl,-z,relro -Wl,-Bsymbolic-functions -Wl,-z,relro -g -fstack-protector-strong -Wformat -Werror=format-security -Wdate-time -D_FORTIFY_SOURCE=2 build/temp.linux-x86_64-3.6/../common/maskApi.o build/temp.linux-x86_64-3.6/pycocotools/_mask.o -o build/lib.linux-x86_64-3.6/pycocotools/_mask.cpython-36m-x86_64-linux-gnu.so\n",
-            "running install\n",
-            "running bdist_egg\n",
-            "running egg_info\n",
-            "creating pycocotools.egg-info\n",
-            "writing pycocotools.egg-info/PKG-INFO\n",
-            "writing dependency_links to pycocotools.egg-info/dependency_links.txt\n",
-            "writing requirements to pycocotools.egg-info/requires.txt\n",
-            "writing top-level names to pycocotools.egg-info/top_level.txt\n",
-            "writing manifest file 'pycocotools.egg-info/SOURCES.txt'\n",
-            "writing manifest file 'pycocotools.egg-info/SOURCES.txt'\n",
-            "installing library code to build/bdist.linux-x86_64/egg\n",
-            "running install_lib\n",
-            "running build_py\n",
-            "copying pycocotools/coco.py -> build/lib.linux-x86_64-3.6/pycocotools\n",
-            "copying pycocotools/__init__.py -> build/lib.linux-x86_64-3.6/pycocotools\n",
-            "copying pycocotools/cocoeval.py -> build/lib.linux-x86_64-3.6/pycocotools\n",
-            "copying pycocotools/mask.py -> build/lib.linux-x86_64-3.6/pycocotools\n",
-            "creating build/bdist.linux-x86_64\n",
-            "creating build/bdist.linux-x86_64/egg\n",
-            "creating build/bdist.linux-x86_64/egg/pycocotools\n",
-            "copying build/lib.linux-x86_64-3.6/pycocotools/coco.py -> build/bdist.linux-x86_64/egg/pycocotools\n",
-            "copying build/lib.linux-x86_64-3.6/pycocotools/__init__.py -> build/bdist.linux-x86_64/egg/pycocotools\n",
-            "copying build/lib.linux-x86_64-3.6/pycocotools/_mask.cpython-36m-x86_64-linux-gnu.so -> build/bdist.linux-x86_64/egg/pycocotools\n",
-            "copying build/lib.linux-x86_64-3.6/pycocotools/cocoeval.py -> build/bdist.linux-x86_64/egg/pycocotools\n",
-            "copying build/lib.linux-x86_64-3.6/pycocotools/mask.py -> build/bdist.linux-x86_64/egg/pycocotools\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/pycocotools/coco.py to coco.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/pycocotools/__init__.py to __init__.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/pycocotools/cocoeval.py to cocoeval.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/pycocotools/mask.py to mask.cpython-36.pyc\n",
-            "creating stub loader for pycocotools/_mask.cpython-36m-x86_64-linux-gnu.so\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/pycocotools/_mask.py to _mask.cpython-36.pyc\n",
-            "creating build/bdist.linux-x86_64/egg/EGG-INFO\n",
-            "copying pycocotools.egg-info/PKG-INFO -> build/bdist.linux-x86_64/egg/EGG-INFO\n",
-            "copying pycocotools.egg-info/SOURCES.txt -> build/bdist.linux-x86_64/egg/EGG-INFO\n",
-            "copying pycocotools.egg-info/dependency_links.txt -> build/bdist.linux-x86_64/egg/EGG-INFO\n",
-            "copying pycocotools.egg-info/requires.txt -> build/bdist.linux-x86_64/egg/EGG-INFO\n",
-            "copying pycocotools.egg-info/top_level.txt -> build/bdist.linux-x86_64/egg/EGG-INFO\n",
-            "writing build/bdist.linux-x86_64/egg/EGG-INFO/native_libs.txt\n",
-            "zip_safe flag not set; analyzing archive contents...\n",
-            "pycocotools.__pycache__._mask.cpython-36: module references __file__\n",
-            "creating dist\n",
-            "creating 'dist/pycocotools-2.0-py3.6-linux-x86_64.egg' and adding 'build/bdist.linux-x86_64/egg' to it\n",
-            "removing 'build/bdist.linux-x86_64/egg' (and everything under it)\n",
-            "Processing pycocotools-2.0-py3.6-linux-x86_64.egg\n",
-            "creating /usr/local/lib/python3.6/dist-packages/pycocotools-2.0-py3.6-linux-x86_64.egg\n",
-            "Extracting pycocotools-2.0-py3.6-linux-x86_64.egg to /usr/local/lib/python3.6/dist-packages\n",
-            "Adding pycocotools 2.0 to easy-install.pth file\n",
-            "\n",
-            "Installed /usr/local/lib/python3.6/dist-packages/pycocotools-2.0-py3.6-linux-x86_64.egg\n",
-            "Processing dependencies for pycocotools==2.0\n",
-            "Searching for matplotlib==3.0.3\n",
-            "Best match: matplotlib 3.0.3\n",
-            "Adding matplotlib 3.0.3 to easy-install.pth file\n",
-            "\n",
-            "Using /usr/local/lib/python3.6/dist-packages\n",
-            "Searching for Cython==0.29.7\n",
-            "Best match: Cython 0.29.7\n",
-            "Adding Cython 0.29.7 to easy-install.pth file\n",
-            "Installing cygdb script to /usr/local/bin\n",
-            "Installing cython script to /usr/local/bin\n",
-            "Installing cythonize script to /usr/local/bin\n",
-            "\n",
-            "Using /usr/local/lib/python3.6/dist-packages\n",
-            "Searching for setuptools==41.0.1\n",
-            "Best match: setuptools 41.0.1\n",
-            "Adding setuptools 41.0.1 to easy-install.pth file\n",
-            "Installing easy_install script to /usr/local/bin\n",
-            "Installing easy_install-3.6 script to /usr/local/bin\n",
-            "\n",
-            "Using /usr/local/lib/python3.6/dist-packages\n",
-            "Searching for python-dateutil==2.5.3\n",
-            "Best match: python-dateutil 2.5.3\n",
-            "Adding python-dateutil 2.5.3 to easy-install.pth file\n",
-            "\n",
-            "Using /usr/local/lib/python3.6/dist-packages\n",
-            "Searching for cycler==0.10.0\n",
-            "Best match: cycler 0.10.0\n",
-            "Adding cycler 0.10.0 to easy-install.pth file\n",
-            "\n",
-            "Using /usr/local/lib/python3.6/dist-packages\n",
-            "Searching for kiwisolver==1.1.0\n",
-            "Best match: kiwisolver 1.1.0\n",
-            "Adding kiwisolver 1.1.0 to easy-install.pth file\n",
-            "\n",
-            "Using /usr/local/lib/python3.6/dist-packages\n",
-            "Searching for numpy==1.16.3\n",
-            "Best match: numpy 1.16.3\n",
-            "Adding numpy 1.16.3 to easy-install.pth file\n",
-            "Installing f2py script to /usr/local/bin\n",
-            "Installing f2py3 script to /usr/local/bin\n",
-            "Installing f2py3.6 script to /usr/local/bin\n",
-            "\n",
-            "Using /usr/local/lib/python3.6/dist-packages\n",
-            "Searching for pyparsing==2.4.0\n",
-            "Best match: pyparsing 2.4.0\n",
-            "Adding pyparsing 2.4.0 to easy-install.pth file\n",
-            "\n",
-            "Using /usr/local/lib/python3.6/dist-packages\n",
-            "Searching for six==1.12.0\n",
-            "Best match: six 1.12.0\n",
-            "Adding six 1.12.0 to easy-install.pth file\n",
-            "\n",
-            "Using /usr/local/lib/python3.6/dist-packages\n",
-            "Finished processing dependencies for pycocotools==2.0\n",
-            "Uninstalling torchvision-0.2.2.post3:\n",
-            "  Successfully uninstalled torchvision-0.2.2.post3\n",
-            "Cloning into 'vision'...\n",
-            "remote: Enumerating objects: 91, done.\u001b[K\n",
-            "remote: Counting objects: 100% (91/91), done.\u001b[K\n",
-            "remote: Compressing objects: 100% (58/58), done.\u001b[K\n",
-            "remote: Total 3006 (delta 42), reused 68 (delta 33), pack-reused 2915\u001b[K\n",
-            "Receiving objects: 100% (3006/3006), 2.50 MiB | 16.98 MiB/s, done.\n",
-            "Resolving deltas: 100% (1927/1927), done.\n",
-            "Branch 'v0.3.0' set up to track remote branch 'v0.3.0' from 'origin'.\n",
-            "Switched to a new branch 'v0.3.0'\n",
-            "Building wheel torchvision-0.3.0a0+684c064\n",
-            "running install\n",
-            "running bdist_egg\n",
-            "running egg_info\n",
-            "creating torchvision.egg-info\n",
-            "writing torchvision.egg-info/PKG-INFO\n",
-            "writing dependency_links to torchvision.egg-info/dependency_links.txt\n",
-            "writing requirements to torchvision.egg-info/requires.txt\n",
-            "writing top-level names to torchvision.egg-info/top_level.txt\n",
-            "writing manifest file 'torchvision.egg-info/SOURCES.txt'\n",
-            "reading manifest template 'MANIFEST.in'\n",
-            "warning: no previously-included files matching '__pycache__' found under directory '*'\n",
-            "warning: no previously-included files matching '*.py[co]' found under directory '*'\n",
-            "writing manifest file 'torchvision.egg-info/SOURCES.txt'\n",
-            "installing library code to build/bdist.linux-x86_64/egg\n",
-            "running install_lib\n",
-            "running build_py\n",
-            "creating build\n",
-            "creating build/lib.linux-x86_64-3.6\n",
-            "creating build/lib.linux-x86_64-3.6/torchvision\n",
-            "copying torchvision/__init__.py -> build/lib.linux-x86_64-3.6/torchvision\n",
-            "copying torchvision/utils.py -> build/lib.linux-x86_64-3.6/torchvision\n",
-            "copying torchvision/version.py -> build/lib.linux-x86_64-3.6/torchvision\n",
-            "creating build/lib.linux-x86_64-3.6/torchvision/transforms\n",
-            "copying torchvision/transforms/__init__.py -> build/lib.linux-x86_64-3.6/torchvision/transforms\n",
-            "copying torchvision/transforms/functional.py -> build/lib.linux-x86_64-3.6/torchvision/transforms\n",
-            "copying torchvision/transforms/transforms.py -> build/lib.linux-x86_64-3.6/torchvision/transforms\n",
-            "creating build/lib.linux-x86_64-3.6/torchvision/datasets\n",
-            "copying torchvision/datasets/coco.py -> build/lib.linux-x86_64-3.6/torchvision/datasets\n",
-            "copying torchvision/datasets/__init__.py -> build/lib.linux-x86_64-3.6/torchvision/datasets\n",
-            "copying torchvision/datasets/mnist.py -> build/lib.linux-x86_64-3.6/torchvision/datasets\n",
-            "copying torchvision/datasets/phototour.py -> build/lib.linux-x86_64-3.6/torchvision/datasets\n",
-            "copying torchvision/datasets/sbu.py -> build/lib.linux-x86_64-3.6/torchvision/datasets\n",
-            "copying torchvision/datasets/stl10.py -> build/lib.linux-x86_64-3.6/torchvision/datasets\n",
-            "copying torchvision/datasets/omniglot.py -> build/lib.linux-x86_64-3.6/torchvision/datasets\n",
-            "copying torchvision/datasets/voc.py -> build/lib.linux-x86_64-3.6/torchvision/datasets\n",
-            "copying torchvision/datasets/semeion.py -> build/lib.linux-x86_64-3.6/torchvision/datasets\n",
-            "copying torchvision/datasets/vision.py -> build/lib.linux-x86_64-3.6/torchvision/datasets\n",
-            "copying torchvision/datasets/celeba.py -> build/lib.linux-x86_64-3.6/torchvision/datasets\n",
-            "copying torchvision/datasets/fakedata.py -> build/lib.linux-x86_64-3.6/torchvision/datasets\n",
-            "copying torchvision/datasets/imagenet.py -> build/lib.linux-x86_64-3.6/torchvision/datasets\n",
-            "copying torchvision/datasets/utils.py -> build/lib.linux-x86_64-3.6/torchvision/datasets\n",
-            "copying torchvision/datasets/cityscapes.py -> build/lib.linux-x86_64-3.6/torchvision/datasets\n",
-            "copying torchvision/datasets/caltech.py -> build/lib.linux-x86_64-3.6/torchvision/datasets\n",
-            "copying torchvision/datasets/svhn.py -> build/lib.linux-x86_64-3.6/torchvision/datasets\n",
-            "copying torchvision/datasets/sbd.py -> build/lib.linux-x86_64-3.6/torchvision/datasets\n",
-            "copying torchvision/datasets/cifar.py -> build/lib.linux-x86_64-3.6/torchvision/datasets\n",
-            "copying torchvision/datasets/flickr.py -> build/lib.linux-x86_64-3.6/torchvision/datasets\n",
-            "copying torchvision/datasets/lsun.py -> build/lib.linux-x86_64-3.6/torchvision/datasets\n",
-            "copying torchvision/datasets/folder.py -> build/lib.linux-x86_64-3.6/torchvision/datasets\n",
-            "creating build/lib.linux-x86_64-3.6/torchvision/ops\n",
-            "copying torchvision/ops/roi_align.py -> build/lib.linux-x86_64-3.6/torchvision/ops\n",
-            "copying torchvision/ops/__init__.py -> build/lib.linux-x86_64-3.6/torchvision/ops\n",
-            "copying torchvision/ops/boxes.py -> build/lib.linux-x86_64-3.6/torchvision/ops\n",
-            "copying torchvision/ops/poolers.py -> build/lib.linux-x86_64-3.6/torchvision/ops\n",
-            "copying torchvision/ops/misc.py -> build/lib.linux-x86_64-3.6/torchvision/ops\n",
-            "copying torchvision/ops/roi_pool.py -> build/lib.linux-x86_64-3.6/torchvision/ops\n",
-            "copying torchvision/ops/_utils.py -> build/lib.linux-x86_64-3.6/torchvision/ops\n",
-            "copying torchvision/ops/feature_pyramid_network.py -> build/lib.linux-x86_64-3.6/torchvision/ops\n",
-            "creating build/lib.linux-x86_64-3.6/torchvision/models\n",
-            "copying torchvision/models/inception.py -> build/lib.linux-x86_64-3.6/torchvision/models\n",
-            "copying torchvision/models/alexnet.py -> build/lib.linux-x86_64-3.6/torchvision/models\n",
-            "copying torchvision/models/squeezenet.py -> build/lib.linux-x86_64-3.6/torchvision/models\n",
-            "copying torchvision/models/__init__.py -> build/lib.linux-x86_64-3.6/torchvision/models\n",
-            "copying torchvision/models/vgg.py -> build/lib.linux-x86_64-3.6/torchvision/models\n",
-            "copying torchvision/models/googlenet.py -> build/lib.linux-x86_64-3.6/torchvision/models\n",
-            "copying torchvision/models/densenet.py -> build/lib.linux-x86_64-3.6/torchvision/models\n",
-            "copying torchvision/models/shufflenetv2.py -> build/lib.linux-x86_64-3.6/torchvision/models\n",
-            "copying torchvision/models/utils.py -> build/lib.linux-x86_64-3.6/torchvision/models\n",
-            "copying torchvision/models/mobilenet.py -> build/lib.linux-x86_64-3.6/torchvision/models\n",
-            "copying torchvision/models/resnet.py -> build/lib.linux-x86_64-3.6/torchvision/models\n",
-            "copying torchvision/models/_utils.py -> build/lib.linux-x86_64-3.6/torchvision/models\n",
-            "creating build/lib.linux-x86_64-3.6/torchvision/models/detection\n",
-            "copying torchvision/models/detection/mask_rcnn.py -> build/lib.linux-x86_64-3.6/torchvision/models/detection\n",
-            "copying torchvision/models/detection/image_list.py -> build/lib.linux-x86_64-3.6/torchvision/models/detection\n",
-            "copying torchvision/models/detection/faster_rcnn.py -> build/lib.linux-x86_64-3.6/torchvision/models/detection\n",
-            "copying torchvision/models/detection/__init__.py -> build/lib.linux-x86_64-3.6/torchvision/models/detection\n",
-            "copying torchvision/models/detection/transform.py -> build/lib.linux-x86_64-3.6/torchvision/models/detection\n",
-            "copying torchvision/models/detection/generalized_rcnn.py -> build/lib.linux-x86_64-3.6/torchvision/models/detection\n",
-            "copying torchvision/models/detection/rpn.py -> build/lib.linux-x86_64-3.6/torchvision/models/detection\n",
-            "copying torchvision/models/detection/keypoint_rcnn.py -> build/lib.linux-x86_64-3.6/torchvision/models/detection\n",
-            "copying torchvision/models/detection/_utils.py -> build/lib.linux-x86_64-3.6/torchvision/models/detection\n",
-            "copying torchvision/models/detection/roi_heads.py -> build/lib.linux-x86_64-3.6/torchvision/models/detection\n",
-            "copying torchvision/models/detection/backbone_utils.py -> build/lib.linux-x86_64-3.6/torchvision/models/detection\n",
-            "creating build/lib.linux-x86_64-3.6/torchvision/models/segmentation\n",
-            "copying torchvision/models/segmentation/deeplabv3.py -> build/lib.linux-x86_64-3.6/torchvision/models/segmentation\n",
-            "copying torchvision/models/segmentation/segmentation.py -> build/lib.linux-x86_64-3.6/torchvision/models/segmentation\n",
-            "copying torchvision/models/segmentation/__init__.py -> build/lib.linux-x86_64-3.6/torchvision/models/segmentation\n",
-            "copying torchvision/models/segmentation/fcn.py -> build/lib.linux-x86_64-3.6/torchvision/models/segmentation\n",
-            "copying torchvision/models/segmentation/_utils.py -> build/lib.linux-x86_64-3.6/torchvision/models/segmentation\n",
-            "running build_ext\n",
-            "building 'torchvision._C' extension\n",
-            "creating build/temp.linux-x86_64-3.6\n",
-            "creating build/temp.linux-x86_64-3.6/content\n",
-            "creating build/temp.linux-x86_64-3.6/content/vision\n",
-            "creating build/temp.linux-x86_64-3.6/content/vision/torchvision\n",
-            "creating build/temp.linux-x86_64-3.6/content/vision/torchvision/csrc\n",
-            "creating build/temp.linux-x86_64-3.6/content/vision/torchvision/csrc/cpu\n",
-            "creating build/temp.linux-x86_64-3.6/content/vision/torchvision/csrc/cuda\n",
-            "x86_64-linux-gnu-gcc -pthread -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -Wdate-time -D_FORTIFY_SOURCE=2 -fPIC -DWITH_CUDA -I/content/vision/torchvision/csrc -I/usr/local/lib/python3.6/dist-packages/torch/include -I/usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include -I/usr/local/lib/python3.6/dist-packages/torch/include/TH -I/usr/local/lib/python3.6/dist-packages/torch/include/THC -I/usr/local/cuda/include -I/usr/include/python3.6m -c /content/vision/torchvision/csrc/vision.cpp -o build/temp.linux-x86_64-3.6/content/vision/torchvision/csrc/vision.o -O0 -DTORCH_API_INCLUDE_EXTENSION_H -DTORCH_EXTENSION_NAME=_C -D_GLIBCXX_USE_CXX11_ABI=0 -std=c++11\n",
-            "x86_64-linux-gnu-gcc -pthread -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -Wdate-time -D_FORTIFY_SOURCE=2 -fPIC -DWITH_CUDA -I/content/vision/torchvision/csrc -I/usr/local/lib/python3.6/dist-packages/torch/include -I/usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include -I/usr/local/lib/python3.6/dist-packages/torch/include/TH -I/usr/local/lib/python3.6/dist-packages/torch/include/THC -I/usr/local/cuda/include -I/usr/include/python3.6m -c /content/vision/torchvision/csrc/cpu/ROIAlign_cpu.cpp -o build/temp.linux-x86_64-3.6/content/vision/torchvision/csrc/cpu/ROIAlign_cpu.o -O0 -DTORCH_API_INCLUDE_EXTENSION_H -DTORCH_EXTENSION_NAME=_C -D_GLIBCXX_USE_CXX11_ABI=0 -std=c++11\n",
-            "In file included from \u001b[01m\u001b[K/usr/local/lib/python3.6/dist-packages/torch/include/ATen/ATen.h:9:0\u001b[m\u001b[K,\n",
-            "                 from \u001b[01m\u001b[K/usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include/torch/types.h:3\u001b[m\u001b[K,\n",
-            "                 from \u001b[01m\u001b[K/usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include/torch/data/dataloader_options.h:4\u001b[m\u001b[K,\n",
-            "                 from \u001b[01m\u001b[K/usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include/torch/data/dataloader/base.h:3\u001b[m\u001b[K,\n",
-            "                 from \u001b[01m\u001b[K/usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include/torch/data/dataloader/stateful.h:3\u001b[m\u001b[K,\n",
-            "                 from \u001b[01m\u001b[K/usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include/torch/data/dataloader.h:3\u001b[m\u001b[K,\n",
-            "                 from \u001b[01m\u001b[K/usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include/torch/data.h:3\u001b[m\u001b[K,\n",
-            "                 from \u001b[01m\u001b[K/usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include/torch/all.h:4\u001b[m\u001b[K,\n",
-            "                 from \u001b[01m\u001b[K/usr/local/lib/python3.6/dist-packages/torch/include/torch/extension.h:4\u001b[m\u001b[K,\n",
-            "                 from \u001b[01m\u001b[K/content/vision/torchvision/csrc/cpu/vision.h:2\u001b[m\u001b[K,\n",
-            "                 from \u001b[01m\u001b[K/content/vision/torchvision/csrc/cpu/ROIAlign_cpu.cpp:2\u001b[m\u001b[K:\n",
-            "\u001b[01m\u001b[K/content/vision/torchvision/csrc/cpu/ROIAlign_cpu.cpp:\u001b[m\u001b[K In lambda function:\n",
-            "\u001b[01m\u001b[K/usr/local/lib/python3.6/dist-packages/torch/include/ATen/Dispatch.h:84:52:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[Kc10::ScalarType detail::scalar_type(const at::DeprecatedTypeProperties&)\u001b[m\u001b[K’ is deprecated [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
-            "     at::ScalarType _st = ::detail::scalar_type(TYPE\u001b[01;35m\u001b[K)\u001b[m\u001b[K;                        \\\n",
-            "                                                    \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
-            "\u001b[01m\u001b[K/content/vision/torchvision/csrc/cpu/ROIAlign_cpu.cpp:406:3:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kin expansion of macro ‘\u001b[01m\u001b[KAT_DISPATCH_FLOATING_TYPES_AND_HALF\u001b[m\u001b[K’\n",
-            "   \u001b[01;36m\u001b[KA\u001b[m\u001b[KT_DISPATCH_FLOATING_TYPES_AND_HALF(input.type(), \"ROIAlign_forward\", [&] {\n",
-            "   \u001b[01;36m\u001b[K^\u001b[m\u001b[K\n",
-            "\u001b[01m\u001b[K/usr/local/lib/python3.6/dist-packages/torch/include/ATen/Dispatch.h:47:23:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
-            " inline at::ScalarType \u001b[01;36m\u001b[Kscalar_type\u001b[m\u001b[K(const at::DeprecatedTypeProperties &t) {\n",
-            "                       \u001b[01;36m\u001b[K^~~~~~~~~~~\u001b[m\u001b[K\n",
-            "\u001b[01m\u001b[K/content/vision/torchvision/csrc/cpu/ROIAlign_cpu.cpp:\u001b[m\u001b[K In lambda function:\n",
-            "\u001b[01m\u001b[K/usr/local/lib/python3.6/dist-packages/torch/include/ATen/Dispatch.h:84:52:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[Kc10::ScalarType detail::scalar_type(const at::DeprecatedTypeProperties&)\u001b[m\u001b[K’ is deprecated [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
-            "     at::ScalarType _st = ::detail::scalar_type(TYPE\u001b[01;35m\u001b[K)\u001b[m\u001b[K;                        \\\n",
-            "                                                    \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
-            "\u001b[01m\u001b[K/content/vision/torchvision/csrc/cpu/ROIAlign_cpu.cpp:456:3:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kin expansion of macro ‘\u001b[01m\u001b[KAT_DISPATCH_FLOATING_TYPES_AND_HALF\u001b[m\u001b[K’\n",
-            "   \u001b[01;36m\u001b[KA\u001b[m\u001b[KT_DISPATCH_FLOATING_TYPES_AND_HALF(grad.type(), \"ROIAlign_forward\", [&] {\n",
-            "   \u001b[01;36m\u001b[K^\u001b[m\u001b[K\n",
-            "\u001b[01m\u001b[K/usr/local/lib/python3.6/dist-packages/torch/include/ATen/Dispatch.h:47:23:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
-            " inline at::ScalarType \u001b[01;36m\u001b[Kscalar_type\u001b[m\u001b[K(const at::DeprecatedTypeProperties &t) {\n",
-            "                       \u001b[01;36m\u001b[K^~~~~~~~~~~\u001b[m\u001b[K\n",
-            "x86_64-linux-gnu-gcc -pthread -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -Wdate-time -D_FORTIFY_SOURCE=2 -fPIC -DWITH_CUDA -I/content/vision/torchvision/csrc -I/usr/local/lib/python3.6/dist-packages/torch/include -I/usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include -I/usr/local/lib/python3.6/dist-packages/torch/include/TH -I/usr/local/lib/python3.6/dist-packages/torch/include/THC -I/usr/local/cuda/include -I/usr/include/python3.6m -c /content/vision/torchvision/csrc/cpu/nms_cpu.cpp -o build/temp.linux-x86_64-3.6/content/vision/torchvision/csrc/cpu/nms_cpu.o -O0 -DTORCH_API_INCLUDE_EXTENSION_H -DTORCH_EXTENSION_NAME=_C -D_GLIBCXX_USE_CXX11_ABI=0 -std=c++11\n",
-            "In file included from \u001b[01m\u001b[K/usr/local/lib/python3.6/dist-packages/torch/include/ATen/ATen.h:9:0\u001b[m\u001b[K,\n",
-            "                 from \u001b[01m\u001b[K/usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include/torch/types.h:3\u001b[m\u001b[K,\n",
-            "                 from \u001b[01m\u001b[K/usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include/torch/data/dataloader_options.h:4\u001b[m\u001b[K,\n",
-            "                 from \u001b[01m\u001b[K/usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include/torch/data/dataloader/base.h:3\u001b[m\u001b[K,\n",
-            "                 from \u001b[01m\u001b[K/usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include/torch/data/dataloader/stateful.h:3\u001b[m\u001b[K,\n",
-            "                 from \u001b[01m\u001b[K/usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include/torch/data/dataloader.h:3\u001b[m\u001b[K,\n",
-            "                 from \u001b[01m\u001b[K/usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include/torch/data.h:3\u001b[m\u001b[K,\n",
-            "                 from \u001b[01m\u001b[K/usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include/torch/all.h:4\u001b[m\u001b[K,\n",
-            "                 from \u001b[01m\u001b[K/usr/local/lib/python3.6/dist-packages/torch/include/torch/extension.h:4\u001b[m\u001b[K,\n",
-            "                 from \u001b[01m\u001b[K/content/vision/torchvision/csrc/cpu/vision.h:2\u001b[m\u001b[K,\n",
-            "                 from \u001b[01m\u001b[K/content/vision/torchvision/csrc/cpu/nms_cpu.cpp:1\u001b[m\u001b[K:\n",
-            "\u001b[01m\u001b[K/content/vision/torchvision/csrc/cpu/nms_cpu.cpp:\u001b[m\u001b[K In lambda function:\n",
-            "\u001b[01m\u001b[K/usr/local/lib/python3.6/dist-packages/torch/include/ATen/Dispatch.h:71:52:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[Kc10::ScalarType detail::scalar_type(const at::DeprecatedTypeProperties&)\u001b[m\u001b[K’ is deprecated [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
-            "     at::ScalarType _st = ::detail::scalar_type(TYPE\u001b[01;35m\u001b[K)\u001b[m\u001b[K;                        \\\n",
-            "                                                    \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
-            "\u001b[01m\u001b[K/content/vision/torchvision/csrc/cpu/nms_cpu.cpp:77:3:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kin expansion of macro ‘\u001b[01m\u001b[KAT_DISPATCH_FLOATING_TYPES\u001b[m\u001b[K’\n",
-            "   \u001b[01;36m\u001b[KAT_DISPATCH_FLOATING_TYPES\u001b[m\u001b[K(dets.type(), \"nms\", [&] {\n",
-            "   \u001b[01;36m\u001b[K^~~~~~~~~~~~~~~~~~~~~~~~~~\u001b[m\u001b[K\n",
-            "\u001b[01m\u001b[K/usr/local/lib/python3.6/dist-packages/torch/include/ATen/Dispatch.h:47:23:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
-            " inline at::ScalarType \u001b[01;36m\u001b[Kscalar_type\u001b[m\u001b[K(const at::DeprecatedTypeProperties &t) {\n",
-            "                       \u001b[01;36m\u001b[K^~~~~~~~~~~\u001b[m\u001b[K\n",
-            "x86_64-linux-gnu-gcc -pthread -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -Wdate-time -D_FORTIFY_SOURCE=2 -fPIC -DWITH_CUDA -I/content/vision/torchvision/csrc -I/usr/local/lib/python3.6/dist-packages/torch/include -I/usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include -I/usr/local/lib/python3.6/dist-packages/torch/include/TH -I/usr/local/lib/python3.6/dist-packages/torch/include/THC -I/usr/local/cuda/include -I/usr/include/python3.6m -c /content/vision/torchvision/csrc/cpu/ROIPool_cpu.cpp -o build/temp.linux-x86_64-3.6/content/vision/torchvision/csrc/cpu/ROIPool_cpu.o -O0 -DTORCH_API_INCLUDE_EXTENSION_H -DTORCH_EXTENSION_NAME=_C -D_GLIBCXX_USE_CXX11_ABI=0 -std=c++11\n",
-            "In file included from \u001b[01m\u001b[K/usr/local/lib/python3.6/dist-packages/torch/include/ATen/ATen.h:9:0\u001b[m\u001b[K,\n",
-            "                 from \u001b[01m\u001b[K/content/vision/torchvision/csrc/cpu/ROIPool_cpu.cpp:1\u001b[m\u001b[K:\n",
-            "\u001b[01m\u001b[K/content/vision/torchvision/csrc/cpu/ROIPool_cpu.cpp:\u001b[m\u001b[K In lambda function:\n",
-            "\u001b[01m\u001b[K/usr/local/lib/python3.6/dist-packages/torch/include/ATen/Dispatch.h:84:52:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[Kc10::ScalarType detail::scalar_type(const at::DeprecatedTypeProperties&)\u001b[m\u001b[K’ is deprecated [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
-            "     at::ScalarType _st = ::detail::scalar_type(TYPE\u001b[01;35m\u001b[K)\u001b[m\u001b[K;                        \\\n",
-            "                                                    \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
-            "\u001b[01m\u001b[K/content/vision/torchvision/csrc/cpu/ROIPool_cpu.cpp:152:3:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kin expansion of macro ‘\u001b[01m\u001b[KAT_DISPATCH_FLOATING_TYPES_AND_HALF\u001b[m\u001b[K’\n",
-            "   \u001b[01;36m\u001b[KA\u001b[m\u001b[KT_DISPATCH_FLOATING_TYPES_AND_HALF(input.type(), \"ROIPool_forward\", [&] {\n",
-            "   \u001b[01;36m\u001b[K^\u001b[m\u001b[K\n",
-            "\u001b[01m\u001b[K/usr/local/lib/python3.6/dist-packages/torch/include/ATen/Dispatch.h:47:23:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
-            " inline at::ScalarType \u001b[01;36m\u001b[Kscalar_type\u001b[m\u001b[K(const at::DeprecatedTypeProperties &t) {\n",
-            "                       \u001b[01;36m\u001b[K^~~~~~~~~~~\u001b[m\u001b[K\n",
-            "\u001b[01m\u001b[K/content/vision/torchvision/csrc/cpu/ROIPool_cpu.cpp:\u001b[m\u001b[K In lambda function:\n",
-            "\u001b[01m\u001b[K/usr/local/lib/python3.6/dist-packages/torch/include/ATen/Dispatch.h:84:52:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[Kc10::ScalarType detail::scalar_type(const at::DeprecatedTypeProperties&)\u001b[m\u001b[K’ is deprecated [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
-            "     at::ScalarType _st = ::detail::scalar_type(TYPE\u001b[01;35m\u001b[K)\u001b[m\u001b[K;                        \\\n",
-            "                                                    \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
-            "\u001b[01m\u001b[K/content/vision/torchvision/csrc/cpu/ROIPool_cpu.cpp:206:3:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kin expansion of macro ‘\u001b[01m\u001b[KAT_DISPATCH_FLOATING_TYPES_AND_HALF\u001b[m\u001b[K’\n",
-            "   \u001b[01;36m\u001b[KA\u001b[m\u001b[KT_DISPATCH_FLOATING_TYPES_AND_HALF(grad.type(), \"ROIPool_backward\", [&] {\n",
-            "   \u001b[01;36m\u001b[K^\u001b[m\u001b[K\n",
-            "\u001b[01m\u001b[K/usr/local/lib/python3.6/dist-packages/torch/include/ATen/Dispatch.h:47:23:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
-            " inline at::ScalarType \u001b[01;36m\u001b[Kscalar_type\u001b[m\u001b[K(const at::DeprecatedTypeProperties &t) {\n",
-            "                       \u001b[01;36m\u001b[K^~~~~~~~~~~\u001b[m\u001b[K\n",
-            "/usr/local/cuda/bin/nvcc -DWITH_CUDA -I/content/vision/torchvision/csrc -I/usr/local/lib/python3.6/dist-packages/torch/include -I/usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include -I/usr/local/lib/python3.6/dist-packages/torch/include/TH -I/usr/local/lib/python3.6/dist-packages/torch/include/THC -I/usr/local/cuda/include -I/usr/include/python3.6m -c /content/vision/torchvision/csrc/cuda/ROIAlign_cuda.cu -o build/temp.linux-x86_64-3.6/content/vision/torchvision/csrc/cuda/ROIAlign_cuda.o -D__CUDA_NO_HALF_OPERATORS__ -D__CUDA_NO_HALF_CONVERSIONS__ -D__CUDA_NO_HALF2_OPERATORS__ --compiler-options '-fPIC' -DTORCH_API_INCLUDE_EXTENSION_H -DTORCH_EXTENSION_NAME=_C -D_GLIBCXX_USE_CXX11_ABI=0 -std=c++11\n",
-            "/usr/local/lib/python3.6/dist-packages/torch/include/ATen/cuda/NumericLimits.cuh(83): warning: calling a constexpr __host__ function(\"from_bits\") from a __host__ __device__ function(\"lowest\") is not allowed. The experimental flag '--expt-relaxed-constexpr' can be used to allow this.\n",
-            "\n",
-            "/usr/local/lib/python3.6/dist-packages/torch/include/ATen/cuda/NumericLimits.cuh(84): warning: calling a constexpr __host__ function(\"from_bits\") from a __host__ __device__ function(\"max\") is not allowed. The experimental flag '--expt-relaxed-constexpr' can be used to allow this.\n",
-            "\n",
-            "/usr/local/lib/python3.6/dist-packages/torch/include/ATen/cuda/NumericLimits.cuh(85): warning: calling a constexpr __host__ function(\"from_bits\") from a __host__ __device__ function(\"lower_bound\") is not allowed. The experimental flag '--expt-relaxed-constexpr' can be used to allow this.\n",
-            "\n",
-            "/usr/local/lib/python3.6/dist-packages/torch/include/ATen/cuda/NumericLimits.cuh(86): warning: calling a constexpr __host__ function(\"from_bits\") from a __host__ __device__ function(\"upper_bound\") is not allowed. The experimental flag '--expt-relaxed-constexpr' can be used to allow this.\n",
-            "\n",
-            "\u001b[01m\u001b[K/content/vision/torchvision/csrc/cuda/ROIAlign_cuda.cu:\u001b[m\u001b[K In lambda function:\n",
-            "\u001b[01m\u001b[K/content/vision/torchvision/csrc/cuda/ROIAlign_cuda.cu:337:120:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[Kc10::ScalarType detail::scalar_type(const at::DeprecatedTypeProperties&)\u001b[m\u001b[K’ is deprecated [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
-            "   AT_DISPATCH_FLOATING_TYPES_AND_HALF(input.type(), \"ROIAlign_forward\", [&] {\n",
-            "                                                                                                                        \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
-            "\u001b[01m\u001b[K/usr/local/lib/python3.6/dist-packages/torch/include/ATen/Dispatch.h:47:1:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
-            " \u001b[01;36m\u001b[Kinline at::\u001b[m\u001b[KScalarType scalar_type(const at::DeprecatedTypeProperties &t) {\n",
-            " \u001b[01;36m\u001b[K^~~~~~~~~~~\u001b[m\u001b[K\n",
-            "\u001b[01m\u001b[K/content/vision/torchvision/csrc/cuda/ROIAlign_cuda.cu:\u001b[m\u001b[K In lambda function:\n",
-            "\u001b[01m\u001b[K/content/vision/torchvision/csrc/cuda/ROIAlign_cuda.cu:396:118:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[Kc10::ScalarType detail::scalar_type(const at::DeprecatedTypeProperties&)\u001b[m\u001b[K’ is deprecated [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
-            "   AT_DISPATCH_FLOATING_TYPES_AND_HALF(grad.type(), \"ROIAlign_backward\", [&] {\n",
-            "                                                                                                                      \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
-            "\u001b[01m\u001b[K/usr/local/lib/python3.6/dist-packages/torch/include/ATen/Dispatch.h:47:1:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
-            " \u001b[01;36m\u001b[Kinline at::\u001b[m\u001b[KScalarType scalar_type(const at::DeprecatedTypeProperties &t) {\n",
-            " \u001b[01;36m\u001b[K^~~~~~~~~~~\u001b[m\u001b[K\n",
-            "/usr/local/cuda/bin/nvcc -DWITH_CUDA -I/content/vision/torchvision/csrc -I/usr/local/lib/python3.6/dist-packages/torch/include -I/usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include -I/usr/local/lib/python3.6/dist-packages/torch/include/TH -I/usr/local/lib/python3.6/dist-packages/torch/include/THC -I/usr/local/cuda/include -I/usr/include/python3.6m -c /content/vision/torchvision/csrc/cuda/ROIPool_cuda.cu -o build/temp.linux-x86_64-3.6/content/vision/torchvision/csrc/cuda/ROIPool_cuda.o -D__CUDA_NO_HALF_OPERATORS__ -D__CUDA_NO_HALF_CONVERSIONS__ -D__CUDA_NO_HALF2_OPERATORS__ --compiler-options '-fPIC' -DTORCH_API_INCLUDE_EXTENSION_H -DTORCH_EXTENSION_NAME=_C -D_GLIBCXX_USE_CXX11_ABI=0 -std=c++11\n",
-            "/usr/local/lib/python3.6/dist-packages/torch/include/ATen/cuda/NumericLimits.cuh(83): warning: calling a constexpr __host__ function(\"from_bits\") from a __host__ __device__ function(\"lowest\") is not allowed. The experimental flag '--expt-relaxed-constexpr' can be used to allow this.\n",
-            "\n",
-            "/usr/local/lib/python3.6/dist-packages/torch/include/ATen/cuda/NumericLimits.cuh(84): warning: calling a constexpr __host__ function(\"from_bits\") from a __host__ __device__ function(\"max\") is not allowed. The experimental flag '--expt-relaxed-constexpr' can be used to allow this.\n",
-            "\n",
-            "/usr/local/lib/python3.6/dist-packages/torch/include/ATen/cuda/NumericLimits.cuh(85): warning: calling a constexpr __host__ function(\"from_bits\") from a __host__ __device__ function(\"lower_bound\") is not allowed. The experimental flag '--expt-relaxed-constexpr' can be used to allow this.\n",
-            "\n",
-            "/usr/local/lib/python3.6/dist-packages/torch/include/ATen/cuda/NumericLimits.cuh(86): warning: calling a constexpr __host__ function(\"from_bits\") from a __host__ __device__ function(\"upper_bound\") is not allowed. The experimental flag '--expt-relaxed-constexpr' can be used to allow this.\n",
-            "\n",
-            "\u001b[01m\u001b[K/content/vision/torchvision/csrc/cuda/ROIPool_cuda.cu:\u001b[m\u001b[K In lambda function:\n",
-            "\u001b[01m\u001b[K/content/vision/torchvision/csrc/cuda/ROIPool_cuda.cu:157:120:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[Kc10::ScalarType detail::scalar_type(const at::DeprecatedTypeProperties&)\u001b[m\u001b[K’ is deprecated [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
-            "   AT_DISPATCH_FLOATING_TYPES_AND_HALF(input.type(), \"ROIPool_forward\", [&] {\n",
-            "                                                                                                                        \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
-            "\u001b[01m\u001b[K/usr/local/lib/python3.6/dist-packages/torch/include/ATen/Dispatch.h:47:1:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
-            " \u001b[01;36m\u001b[Kinline at::\u001b[m\u001b[KScalarType scalar_type(const at::DeprecatedTypeProperties &t) {\n",
-            " \u001b[01;36m\u001b[K^~~~~~~~~~~\u001b[m\u001b[K\n",
-            "\u001b[01m\u001b[K/content/vision/torchvision/csrc/cuda/ROIPool_cuda.cu:\u001b[m\u001b[K In lambda function:\n",
-            "\u001b[01m\u001b[K/content/vision/torchvision/csrc/cuda/ROIPool_cuda.cu:221:118:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[Kc10::ScalarType detail::scalar_type(const at::DeprecatedTypeProperties&)\u001b[m\u001b[K’ is deprecated [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
-            "   AT_DISPATCH_FLOATING_TYPES_AND_HALF(grad.type(), \"ROIPool_backward\", [&] {\n",
-            "                                                                                                                      \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
-            "\u001b[01m\u001b[K/usr/local/lib/python3.6/dist-packages/torch/include/ATen/Dispatch.h:47:1:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
-            " \u001b[01;36m\u001b[Kinline at::\u001b[m\u001b[KScalarType scalar_type(const at::DeprecatedTypeProperties &t) {\n",
-            " \u001b[01;36m\u001b[K^~~~~~~~~~~\u001b[m\u001b[K\n",
-            "/usr/local/cuda/bin/nvcc -DWITH_CUDA -I/content/vision/torchvision/csrc -I/usr/local/lib/python3.6/dist-packages/torch/include -I/usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include -I/usr/local/lib/python3.6/dist-packages/torch/include/TH -I/usr/local/lib/python3.6/dist-packages/torch/include/THC -I/usr/local/cuda/include -I/usr/include/python3.6m -c /content/vision/torchvision/csrc/cuda/nms_cuda.cu -o build/temp.linux-x86_64-3.6/content/vision/torchvision/csrc/cuda/nms_cuda.o -D__CUDA_NO_HALF_OPERATORS__ -D__CUDA_NO_HALF_CONVERSIONS__ -D__CUDA_NO_HALF2_OPERATORS__ --compiler-options '-fPIC' -DTORCH_API_INCLUDE_EXTENSION_H -DTORCH_EXTENSION_NAME=_C -D_GLIBCXX_USE_CXX11_ABI=0 -std=c++11\n",
-            "/usr/local/lib/python3.6/dist-packages/torch/include/ATen/cuda/NumericLimits.cuh(83): warning: calling a constexpr __host__ function(\"from_bits\") from a __host__ __device__ function(\"lowest\") is not allowed. The experimental flag '--expt-relaxed-constexpr' can be used to allow this.\n",
-            "\n",
-            "/usr/local/lib/python3.6/dist-packages/torch/include/ATen/cuda/NumericLimits.cuh(84): warning: calling a constexpr __host__ function(\"from_bits\") from a __host__ __device__ function(\"max\") is not allowed. The experimental flag '--expt-relaxed-constexpr' can be used to allow this.\n",
-            "\n",
-            "/usr/local/lib/python3.6/dist-packages/torch/include/ATen/cuda/NumericLimits.cuh(85): warning: calling a constexpr __host__ function(\"from_bits\") from a __host__ __device__ function(\"lower_bound\") is not allowed. The experimental flag '--expt-relaxed-constexpr' can be used to allow this.\n",
-            "\n",
-            "/usr/local/lib/python3.6/dist-packages/torch/include/ATen/cuda/NumericLimits.cuh(86): warning: calling a constexpr __host__ function(\"from_bits\") from a __host__ __device__ function(\"upper_bound\") is not allowed. The experimental flag '--expt-relaxed-constexpr' can be used to allow this.\n",
-            "\n",
-            "\u001b[01m\u001b[K/content/vision/torchvision/csrc/cuda/nms_cuda.cu:\u001b[m\u001b[K In lambda function:\n",
-            "\u001b[01m\u001b[K/content/vision/torchvision/csrc/cuda/nms_cuda.cu:95:134:\u001b[m\u001b[K \u001b[01;35m\u001b[Kwarning: \u001b[m\u001b[K‘\u001b[01m\u001b[Kc10::ScalarType detail::scalar_type(const at::DeprecatedTypeProperties&)\u001b[m\u001b[K’ is deprecated [\u001b[01;35m\u001b[K-Wdeprecated-declarations\u001b[m\u001b[K]\n",
-            "   AT_DISPATCH_FLOATING_TYPES_AND_HALF(\n",
-            "                                                                                                                                      \u001b[01;35m\u001b[K^\u001b[m\u001b[K\n",
-            "\u001b[01m\u001b[K/usr/local/lib/python3.6/dist-packages/torch/include/ATen/Dispatch.h:47:1:\u001b[m\u001b[K \u001b[01;36m\u001b[Knote: \u001b[m\u001b[Kdeclared here\n",
-            " \u001b[01;36m\u001b[Kinline at::\u001b[m\u001b[KScalarType scalar_type(const at::DeprecatedTypeProperties &t) {\n",
-            " \u001b[01;36m\u001b[K^~~~~~~~~~~\u001b[m\u001b[K\n",
-            "x86_64-linux-gnu-g++ -pthread -shared -Wl,-O1 -Wl,-Bsymbolic-functions -Wl,-Bsymbolic-functions -Wl,-z,relro -Wl,-Bsymbolic-functions -Wl,-z,relro -g -fstack-protector-strong -Wformat -Werror=format-security -Wdate-time -D_FORTIFY_SOURCE=2 build/temp.linux-x86_64-3.6/content/vision/torchvision/csrc/vision.o build/temp.linux-x86_64-3.6/content/vision/torchvision/csrc/cpu/ROIAlign_cpu.o build/temp.linux-x86_64-3.6/content/vision/torchvision/csrc/cpu/nms_cpu.o build/temp.linux-x86_64-3.6/content/vision/torchvision/csrc/cpu/ROIPool_cpu.o build/temp.linux-x86_64-3.6/content/vision/torchvision/csrc/cuda/ROIAlign_cuda.o build/temp.linux-x86_64-3.6/content/vision/torchvision/csrc/cuda/ROIPool_cuda.o build/temp.linux-x86_64-3.6/content/vision/torchvision/csrc/cuda/nms_cuda.o -L/usr/local/cuda/lib64 -lcudart -o build/lib.linux-x86_64-3.6/torchvision/_C.cpython-36m-x86_64-linux-gnu.so\n",
-            "creating build/bdist.linux-x86_64\n",
-            "creating build/bdist.linux-x86_64/egg\n",
-            "creating build/bdist.linux-x86_64/egg/torchvision\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/__init__.py -> build/bdist.linux-x86_64/egg/torchvision\n",
-            "creating build/bdist.linux-x86_64/egg/torchvision/transforms\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/transforms/__init__.py -> build/bdist.linux-x86_64/egg/torchvision/transforms\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/transforms/functional.py -> build/bdist.linux-x86_64/egg/torchvision/transforms\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/transforms/transforms.py -> build/bdist.linux-x86_64/egg/torchvision/transforms\n",
-            "creating build/bdist.linux-x86_64/egg/torchvision/datasets\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/datasets/coco.py -> build/bdist.linux-x86_64/egg/torchvision/datasets\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/datasets/__init__.py -> build/bdist.linux-x86_64/egg/torchvision/datasets\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/datasets/mnist.py -> build/bdist.linux-x86_64/egg/torchvision/datasets\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/datasets/phototour.py -> build/bdist.linux-x86_64/egg/torchvision/datasets\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/datasets/sbu.py -> build/bdist.linux-x86_64/egg/torchvision/datasets\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/datasets/stl10.py -> build/bdist.linux-x86_64/egg/torchvision/datasets\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/datasets/omniglot.py -> build/bdist.linux-x86_64/egg/torchvision/datasets\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/datasets/voc.py -> build/bdist.linux-x86_64/egg/torchvision/datasets\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/datasets/semeion.py -> build/bdist.linux-x86_64/egg/torchvision/datasets\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/datasets/vision.py -> build/bdist.linux-x86_64/egg/torchvision/datasets\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/datasets/celeba.py -> build/bdist.linux-x86_64/egg/torchvision/datasets\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/datasets/fakedata.py -> build/bdist.linux-x86_64/egg/torchvision/datasets\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/datasets/imagenet.py -> build/bdist.linux-x86_64/egg/torchvision/datasets\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/datasets/utils.py -> build/bdist.linux-x86_64/egg/torchvision/datasets\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/datasets/cityscapes.py -> build/bdist.linux-x86_64/egg/torchvision/datasets\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/datasets/caltech.py -> build/bdist.linux-x86_64/egg/torchvision/datasets\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/datasets/svhn.py -> build/bdist.linux-x86_64/egg/torchvision/datasets\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/datasets/sbd.py -> build/bdist.linux-x86_64/egg/torchvision/datasets\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/datasets/cifar.py -> build/bdist.linux-x86_64/egg/torchvision/datasets\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/datasets/flickr.py -> build/bdist.linux-x86_64/egg/torchvision/datasets\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/datasets/lsun.py -> build/bdist.linux-x86_64/egg/torchvision/datasets\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/datasets/folder.py -> build/bdist.linux-x86_64/egg/torchvision/datasets\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/_C.cpython-36m-x86_64-linux-gnu.so -> build/bdist.linux-x86_64/egg/torchvision\n",
-            "creating build/bdist.linux-x86_64/egg/torchvision/ops\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/ops/roi_align.py -> build/bdist.linux-x86_64/egg/torchvision/ops\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/ops/__init__.py -> build/bdist.linux-x86_64/egg/torchvision/ops\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/ops/boxes.py -> build/bdist.linux-x86_64/egg/torchvision/ops\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/ops/poolers.py -> build/bdist.linux-x86_64/egg/torchvision/ops\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/ops/misc.py -> build/bdist.linux-x86_64/egg/torchvision/ops\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/ops/roi_pool.py -> build/bdist.linux-x86_64/egg/torchvision/ops\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/ops/_utils.py -> build/bdist.linux-x86_64/egg/torchvision/ops\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/ops/feature_pyramid_network.py -> build/bdist.linux-x86_64/egg/torchvision/ops\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/utils.py -> build/bdist.linux-x86_64/egg/torchvision\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/version.py -> build/bdist.linux-x86_64/egg/torchvision\n",
-            "creating build/bdist.linux-x86_64/egg/torchvision/models\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/models/inception.py -> build/bdist.linux-x86_64/egg/torchvision/models\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/models/alexnet.py -> build/bdist.linux-x86_64/egg/torchvision/models\n",
-            "creating build/bdist.linux-x86_64/egg/torchvision/models/detection\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/models/detection/mask_rcnn.py -> build/bdist.linux-x86_64/egg/torchvision/models/detection\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/models/detection/image_list.py -> build/bdist.linux-x86_64/egg/torchvision/models/detection\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/models/detection/faster_rcnn.py -> build/bdist.linux-x86_64/egg/torchvision/models/detection\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/models/detection/__init__.py -> build/bdist.linux-x86_64/egg/torchvision/models/detection\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/models/detection/transform.py -> build/bdist.linux-x86_64/egg/torchvision/models/detection\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/models/detection/generalized_rcnn.py -> build/bdist.linux-x86_64/egg/torchvision/models/detection\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/models/detection/rpn.py -> build/bdist.linux-x86_64/egg/torchvision/models/detection\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/models/detection/keypoint_rcnn.py -> build/bdist.linux-x86_64/egg/torchvision/models/detection\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/models/detection/_utils.py -> build/bdist.linux-x86_64/egg/torchvision/models/detection\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/models/detection/roi_heads.py -> build/bdist.linux-x86_64/egg/torchvision/models/detection\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/models/detection/backbone_utils.py -> build/bdist.linux-x86_64/egg/torchvision/models/detection\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/models/squeezenet.py -> build/bdist.linux-x86_64/egg/torchvision/models\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/models/__init__.py -> build/bdist.linux-x86_64/egg/torchvision/models\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/models/vgg.py -> build/bdist.linux-x86_64/egg/torchvision/models\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/models/googlenet.py -> build/bdist.linux-x86_64/egg/torchvision/models\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/models/densenet.py -> build/bdist.linux-x86_64/egg/torchvision/models\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/models/shufflenetv2.py -> build/bdist.linux-x86_64/egg/torchvision/models\n",
-            "creating build/bdist.linux-x86_64/egg/torchvision/models/segmentation\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/models/segmentation/deeplabv3.py -> build/bdist.linux-x86_64/egg/torchvision/models/segmentation\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/models/segmentation/segmentation.py -> build/bdist.linux-x86_64/egg/torchvision/models/segmentation\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/models/segmentation/__init__.py -> build/bdist.linux-x86_64/egg/torchvision/models/segmentation\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/models/segmentation/fcn.py -> build/bdist.linux-x86_64/egg/torchvision/models/segmentation\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/models/segmentation/_utils.py -> build/bdist.linux-x86_64/egg/torchvision/models/segmentation\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/models/utils.py -> build/bdist.linux-x86_64/egg/torchvision/models\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/models/mobilenet.py -> build/bdist.linux-x86_64/egg/torchvision/models\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/models/resnet.py -> build/bdist.linux-x86_64/egg/torchvision/models\n",
-            "copying build/lib.linux-x86_64-3.6/torchvision/models/_utils.py -> build/bdist.linux-x86_64/egg/torchvision/models\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/__init__.py to __init__.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/transforms/__init__.py to __init__.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/transforms/functional.py to functional.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/transforms/transforms.py to transforms.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/datasets/coco.py to coco.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/datasets/__init__.py to __init__.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/datasets/mnist.py to mnist.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/datasets/phototour.py to phototour.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/datasets/sbu.py to sbu.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/datasets/stl10.py to stl10.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/datasets/omniglot.py to omniglot.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/datasets/voc.py to voc.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/datasets/semeion.py to semeion.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/datasets/vision.py to vision.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/datasets/celeba.py to celeba.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/datasets/fakedata.py to fakedata.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/datasets/imagenet.py to imagenet.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/datasets/utils.py to utils.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/datasets/cityscapes.py to cityscapes.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/datasets/caltech.py to caltech.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/datasets/svhn.py to svhn.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/datasets/sbd.py to sbd.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/datasets/cifar.py to cifar.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/datasets/flickr.py to flickr.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/datasets/lsun.py to lsun.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/datasets/folder.py to folder.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/ops/roi_align.py to roi_align.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/ops/__init__.py to __init__.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/ops/boxes.py to boxes.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/ops/poolers.py to poolers.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/ops/misc.py to misc.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/ops/roi_pool.py to roi_pool.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/ops/_utils.py to _utils.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/ops/feature_pyramid_network.py to feature_pyramid_network.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/utils.py to utils.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/version.py to version.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/models/inception.py to inception.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/models/alexnet.py to alexnet.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/models/detection/mask_rcnn.py to mask_rcnn.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/models/detection/image_list.py to image_list.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/models/detection/faster_rcnn.py to faster_rcnn.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/models/detection/__init__.py to __init__.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/models/detection/transform.py to transform.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/models/detection/generalized_rcnn.py to generalized_rcnn.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/models/detection/rpn.py to rpn.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/models/detection/keypoint_rcnn.py to keypoint_rcnn.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/models/detection/_utils.py to _utils.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/models/detection/roi_heads.py to roi_heads.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/models/detection/backbone_utils.py to backbone_utils.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/models/squeezenet.py to squeezenet.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/models/__init__.py to __init__.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/models/vgg.py to vgg.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/models/googlenet.py to googlenet.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/models/densenet.py to densenet.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/models/shufflenetv2.py to shufflenetv2.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/models/segmentation/deeplabv3.py to deeplabv3.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/models/segmentation/segmentation.py to segmentation.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/models/segmentation/__init__.py to __init__.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/models/segmentation/fcn.py to fcn.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/models/segmentation/_utils.py to _utils.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/models/utils.py to utils.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/models/mobilenet.py to mobilenet.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/models/resnet.py to resnet.cpython-36.pyc\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/models/_utils.py to _utils.cpython-36.pyc\n",
-            "creating stub loader for torchvision/_C.cpython-36m-x86_64-linux-gnu.so\n",
-            "byte-compiling build/bdist.linux-x86_64/egg/torchvision/_C.py to _C.cpython-36.pyc\n",
-            "creating build/bdist.linux-x86_64/egg/EGG-INFO\n",
-            "copying torchvision.egg-info/PKG-INFO -> build/bdist.linux-x86_64/egg/EGG-INFO\n",
-            "copying torchvision.egg-info/SOURCES.txt -> build/bdist.linux-x86_64/egg/EGG-INFO\n",
-            "copying torchvision.egg-info/dependency_links.txt -> build/bdist.linux-x86_64/egg/EGG-INFO\n",
-            "copying torchvision.egg-info/requires.txt -> build/bdist.linux-x86_64/egg/EGG-INFO\n",
-            "copying torchvision.egg-info/top_level.txt -> build/bdist.linux-x86_64/egg/EGG-INFO\n",
-            "copying torchvision.egg-info/zip-safe -> build/bdist.linux-x86_64/egg/EGG-INFO\n",
-            "writing build/bdist.linux-x86_64/egg/EGG-INFO/native_libs.txt\n",
-            "creating dist\n",
-            "creating 'dist/torchvision-0.3.0a0+684c064-py3.6-linux-x86_64.egg' and adding 'build/bdist.linux-x86_64/egg' to it\n",
-            "removing 'build/bdist.linux-x86_64/egg' (and everything under it)\n",
-            "Processing torchvision-0.3.0a0+684c064-py3.6-linux-x86_64.egg\n",
-            "Copying torchvision-0.3.0a0+684c064-py3.6-linux-x86_64.egg to /usr/local/lib/python3.6/dist-packages\n",
-            "Adding torchvision 0.3.0a0+684c064 to easy-install.pth file\n",
-            "\n",
-            "Installed /usr/local/lib/python3.6/dist-packages/torchvision-0.3.0a0+684c064-py3.6-linux-x86_64.egg\n",
-            "Processing dependencies for torchvision==0.3.0a0+684c064\n",
-            "Searching for Pillow==4.3.0\n",
-            "Best match: Pillow 4.3.0\n",
-            "Adding Pillow 4.3.0 to easy-install.pth file\n",
-            "\n",
-            "Using /usr/local/lib/python3.6/dist-packages\n",
-            "Searching for torch==1.1.0\n",
-            "Best match: torch 1.1.0\n",
-            "Adding torch 1.1.0 to easy-install.pth file\n",
-            "Installing convert-caffe2-to-onnx script to /usr/local/bin\n",
-            "Installing convert-onnx-to-caffe2 script to /usr/local/bin\n",
-            "\n",
-            "Using /usr/local/lib/python3.6/dist-packages\n",
-            "Searching for six==1.12.0\n",
-            "Best match: six 1.12.0\n",
-            "Adding six 1.12.0 to easy-install.pth file\n",
-            "\n",
-            "Using /usr/local/lib/python3.6/dist-packages\n",
-            "Searching for numpy==1.16.3\n",
-            "Best match: numpy 1.16.3\n",
-            "Adding numpy 1.16.3 to easy-install.pth file\n",
-            "Installing f2py script to /usr/local/bin\n",
-            "Installing f2py3 script to /usr/local/bin\n",
-            "Installing f2py3.6 script to /usr/local/bin\n",
-            "\n",
-            "Using /usr/local/lib/python3.6/dist-packages\n",
-            "Searching for olefile==0.46\n",
-            "Best match: olefile 0.46\n",
-            "Adding olefile 0.46 to easy-install.pth file\n",
-            "\n",
-            "Using /usr/local/lib/python3.6/dist-packages\n",
-            "Finished processing dependencies for torchvision==0.3.0a0+684c064\n"
-          ],
-          "name": "stdout"
-        },
-        {
-          "output_type": "execute_result",
-          "data": {
-            "text/plain": [
-              ""
-            ]
-          },
-          "metadata": {
-            "tags": []
-          },
-          "execution_count": 1
-        }
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "5Sd4jlGp2eLm",
-        "colab_type": "text"
-      },
-      "source": [
-        "## Defining the Dataset\n",
-        "\n",
-        "The [torchvision reference scripts for training object detection, instance segmentation and person keypoint detection](https://github.com/pytorch/vision/tree/v0.3.0/references/detection) allows for easily supporting adding new custom datasets.\n",
-        "The dataset should inherit from the standard `torch.utils.data.Dataset` class, and implement `__len__` and `__getitem__`.\n",
-        "\n",
-        "The only specificity that we require is that the dataset `__getitem__` should return:\n",
-        "\n",
-        "* image: a PIL Image of size (H, W)\n",
-        "* target: a dict containing the following fields\n",
-        "    * `boxes` (`FloatTensor[N, 4]`): the coordinates of the `N` bounding boxes in `[x0, y0, x1, y1]` format, ranging from `0` to `W` and `0` to `H`\n",
-        "    * `labels` (`Int64Tensor[N]`): the label for each bounding box\n",
-        "    * `image_id` (`Int64Tensor[1]`): an image identifier. It should be unique between all the images in the dataset, and is used during evaluation\n",
-        "    * `area` (`Tensor[N]`): The area of the bounding box. This is used during evaluation with the COCO metric, to separate the metric scores between small, medium and large boxes.\n",
-        "    * `iscrowd` (`UInt8Tensor[N]`): instances with `iscrowd=True` will be ignored during evaluation.\n",
-        "    * (optionally) `masks` (`UInt8Tensor[N, H, W]`): The segmentation masks for each one of the objects\n",
-        "    * (optionally) `keypoints` (`FloatTensor[N, K, 3]`): For each one of the `N` objects, it contains the `K` keypoints in `[x, y, visibility]` format, defining the object. `visibility=0` means that the keypoint is not visible. Note that for data augmentation, the notion of flipping a keypoint is dependent on the data representation, and you should probably adapt `references/detection/transforms.py` for your new keypoint representation\n",
-        "\n",
-        "If your model returns the above methods, they will make it work for both training and evaluation, and will use the evaluation scripts from pycocotools.\n",
-        "\n",
-        "Additionally, if you want to use aspect ratio grouping during training (so that each batch only contains images with similar aspect ratio), then it is recommended to also implement a `get_height_and_width` method, which returns the height and the width of the image. If this method is not provided, we query all elements of the dataset via `__getitem__` , which loads the image in memory and is slower than if a custom method is provided.\n"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "bX0rqK-A3Nbl",
-        "colab_type": "text"
-      },
-      "source": [
-        "### Writing a custom dataset for Penn-Fudan\n",
-        "\n",
-        "Let's write a dataset for the Penn-Fudan dataset.\n",
-        "\n",
-        "First, let's download and extract the data, present in a zip file at https://www.cis.upenn.edu/~jshi/ped_html/PennFudanPed.zip"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "_t4TBwhHTdkd",
-        "colab_type": "code",
-        "outputId": "6aee5a89-b16b-4651-88c0-f050fe3f14c4",
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 9095
-        }
-      },
-      "source": [
-        "%%shell\n",
-        "\n",
-        "# download the Penn-Fudan dataset\n",
-        "wget https://www.cis.upenn.edu/~jshi/ped_html/PennFudanPed.zip .\n",
-        "# extract it in the current folder\n",
-        "unzip PennFudanPed.zip"
-      ],
-      "execution_count": 0,
-      "outputs": [
-        {
-          "output_type": "stream",
-          "text": [
-            "--2019-05-22 13:33:18--  https://www.cis.upenn.edu/~jshi/ped_html/PennFudanPed.zip\n",
-            "Resolving www.cis.upenn.edu (www.cis.upenn.edu)... 158.130.69.163, 2607:f470:8:64:5ea5::d\n",
-            "Connecting to www.cis.upenn.edu (www.cis.upenn.edu)|158.130.69.163|:443... connected.\n",
-            "HTTP request sent, awaiting response... 200 OK\n",
-            "Length: 53723336 (51M) [application/zip]\n",
-            "Saving to: ‘PennFudanPed.zip’\n",
-            "\n",
-            "PennFudanPed.zip    100%[===================>]  51.23M  65.0MB/s    in 0.8s    \n",
-            "\n",
-            "2019-05-22 13:33:19 (65.0 MB/s) - ‘PennFudanPed.zip’ saved [53723336/53723336]\n",
-            "\n",
-            "--2019-05-22 13:33:19--  http://./\n",
-            "Resolving . (.)... failed: No address associated with hostname.\n",
-            "wget: unable to resolve host address ‘.’\n",
-            "FINISHED --2019-05-22 13:33:19--\n",
-            "Total wall clock time: 1.0s\n",
-            "Downloaded: 1 files, 51M in 0.8s (65.0 MB/s)\n",
-            "Archive:  PennFudanPed.zip\n",
-            "   creating: PennFudanPed/\n",
-            "  inflating: PennFudanPed/added-object-list.txt  \n",
-            "   creating: PennFudanPed/Annotation/\n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00001.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00002.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00003.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00004.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00005.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00006.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00007.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00008.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00009.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00010.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00011.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00012.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00013.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00014.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00015.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00016.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00017.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00018.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00019.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00020.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00021.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00022.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00023.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00024.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00025.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00026.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00027.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00028.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00029.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00030.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00031.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00032.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00033.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00034.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00035.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00036.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00037.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00038.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00039.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00040.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00041.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00042.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00043.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00044.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00045.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00046.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00047.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00048.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00049.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00050.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00051.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00052.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00053.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00054.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00055.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00056.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00057.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00058.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00059.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00060.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00061.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00062.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00063.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00064.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00065.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00066.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00067.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00068.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00069.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00070.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00071.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00072.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00073.txt  \n",
-            "  inflating: PennFudanPed/Annotation/FudanPed00074.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00001.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00002.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00003.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00004.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00005.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00006.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00007.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00008.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00009.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00010.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00011.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00012.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00013.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00014.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00015.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00016.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00017.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00018.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00019.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00020.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00021.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00022.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00023.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00024.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00025.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00026.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00027.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00028.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00029.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00030.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00031.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00032.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00033.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00034.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00035.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00036.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00037.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00038.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00039.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00040.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00041.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00042.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00043.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00044.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00045.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00046.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00047.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00048.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00049.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00050.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00051.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00052.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00053.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00054.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00055.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00056.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00057.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00058.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00059.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00060.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00061.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00062.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00063.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00064.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00065.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00066.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00067.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00068.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00069.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00070.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00071.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00072.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00073.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00074.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00075.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00076.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00077.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00078.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00079.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00080.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00081.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00082.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00083.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00084.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00085.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00086.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00087.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00088.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00089.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00090.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00091.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00092.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00093.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00094.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00095.txt  \n",
-            "  inflating: PennFudanPed/Annotation/PennPed00096.txt  \n",
-            "   creating: PennFudanPed/PedMasks/\n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00001_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00002_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00003_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00004_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00005_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00006_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00007_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00008_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00009_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00010_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00011_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00012_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00013_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00014_mask.png  \n",
-            " extracting: PennFudanPed/PedMasks/FudanPed00015_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00016_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00017_mask.png  \n",
-            " extracting: PennFudanPed/PedMasks/FudanPed00018_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00019_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00020_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00021_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00022_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00023_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00024_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00025_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00026_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00027_mask.png  \n",
-            " extracting: PennFudanPed/PedMasks/FudanPed00028_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00029_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00030_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00031_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00032_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00033_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00034_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00035_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00036_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00037_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00038_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00039_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00040_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00041_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00042_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00043_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00044_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00045_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00046_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00047_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00048_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00049_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00050_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00051_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00052_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00053_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00054_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00055_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00056_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00057_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00058_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00059_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00060_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00061_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00062_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00063_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00064_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00065_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00066_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00067_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00068_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00069_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00070_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00071_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00072_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00073_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/FudanPed00074_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00001_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00002_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00003_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00004_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00005_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00006_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00007_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00008_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00009_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00010_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00011_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00012_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00013_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00014_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00015_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00016_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00017_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00018_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00019_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00020_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00021_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00022_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00023_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00024_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00025_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00026_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00027_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00028_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00029_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00030_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00031_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00032_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00033_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00034_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00035_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00036_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00037_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00038_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00039_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00040_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00041_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00042_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00043_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00044_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00045_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00046_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00047_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00048_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00049_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00050_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00051_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00052_mask.png  \n",
-            " extracting: PennFudanPed/PedMasks/PennPed00053_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00054_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00055_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00056_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00057_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00058_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00059_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00060_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00061_mask.png  \n",
-            " extracting: PennFudanPed/PedMasks/PennPed00062_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00063_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00064_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00065_mask.png  \n",
-            " extracting: PennFudanPed/PedMasks/PennPed00066_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00067_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00068_mask.png  \n",
-            " extracting: PennFudanPed/PedMasks/PennPed00069_mask.png  \n",
-            " extracting: PennFudanPed/PedMasks/PennPed00070_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00071_mask.png  \n",
-            " extracting: PennFudanPed/PedMasks/PennPed00072_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00073_mask.png  \n",
-            " extracting: PennFudanPed/PedMasks/PennPed00074_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00075_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00076_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00077_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00078_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00079_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00080_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00081_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00082_mask.png  \n",
-            " extracting: PennFudanPed/PedMasks/PennPed00083_mask.png  \n",
-            " extracting: PennFudanPed/PedMasks/PennPed00084_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00085_mask.png  \n",
-            " extracting: PennFudanPed/PedMasks/PennPed00086_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00087_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00088_mask.png  \n",
-            " extracting: PennFudanPed/PedMasks/PennPed00089_mask.png  \n",
-            " extracting: PennFudanPed/PedMasks/PennPed00090_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00091_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00092_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00093_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00094_mask.png  \n",
-            "  inflating: PennFudanPed/PedMasks/PennPed00095_mask.png  \n",
-            " extracting: PennFudanPed/PedMasks/PennPed00096_mask.png  \n",
-            "   creating: PennFudanPed/PNGImages/\n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00001.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00002.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00003.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00004.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00005.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00006.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00007.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00008.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00009.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00010.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00011.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00012.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00013.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00014.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00015.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00016.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00017.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00018.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00019.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00020.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00021.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00022.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00023.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00024.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00025.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00026.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00027.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00028.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00029.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00030.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00031.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00032.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00033.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00034.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00035.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00036.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00037.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00038.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00039.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00040.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00041.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00042.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00043.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00044.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00045.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00046.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00047.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00048.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00049.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00050.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00051.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00052.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00053.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00054.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00055.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00056.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00057.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00058.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00059.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00060.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00061.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00062.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00063.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00064.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00065.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00066.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00067.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00068.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00069.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00070.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00071.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00072.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00073.png  \n",
-            "  inflating: PennFudanPed/PNGImages/FudanPed00074.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00001.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00002.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00003.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00004.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00005.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00006.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00007.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00008.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00009.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00010.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00011.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00012.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00013.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00014.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00015.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00016.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00017.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00018.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00019.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00020.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00021.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00022.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00023.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00024.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00025.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00026.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00027.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00028.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00029.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00030.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00031.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00032.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00033.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00034.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00035.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00036.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00037.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00038.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00039.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00040.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00041.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00042.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00043.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00044.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00045.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00046.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00047.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00048.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00049.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00050.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00051.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00052.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00053.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00054.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00055.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00056.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00057.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00058.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00059.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00060.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00061.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00062.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00063.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00064.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00065.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00066.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00067.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00068.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00069.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00070.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00071.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00072.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00073.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00074.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00075.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00076.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00077.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00078.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00079.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00080.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00081.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00082.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00083.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00084.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00085.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00086.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00087.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00088.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00089.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00090.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00091.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00092.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00093.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00094.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00095.png  \n",
-            "  inflating: PennFudanPed/PNGImages/PennPed00096.png  \n",
-            "  inflating: PennFudanPed/readme.txt  \n"
-          ],
-          "name": "stdout"
-        },
-        {
-          "output_type": "execute_result",
-          "data": {
-            "text/plain": [
-              ""
-            ]
-          },
-          "metadata": {
-            "tags": []
-          },
-          "execution_count": 2
-        }
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "WfwuU-jI3j93",
-        "colab_type": "text"
-      },
-      "source": [
-        "Let's have a look at the dataset and how it is layed down.\n",
-        "\n",
-        "The data is structured as follows\n",
-        "```\n",
-        "PennFudanPed/\n",
-        "  PedMasks/\n",
-        "    FudanPed00001_mask.png\n",
-        "    FudanPed00002_mask.png\n",
-        "    FudanPed00003_mask.png\n",
-        "    FudanPed00004_mask.png\n",
-        "    ...\n",
-        "  PNGImages/\n",
-        "    FudanPed00001.png\n",
-        "    FudanPed00002.png\n",
-        "    FudanPed00003.png\n",
-        "    FudanPed00004.png\n",
-        "```\n",
-        "\n",
-        "Here is one example of an image in the dataset, with its corresponding instance segmentation mask"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "LDjuVFgexFfh",
-        "colab_type": "code",
-        "outputId": "ad7713d2-9c54-4e2e-fe68-034d283ab478",
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 553
-        }
-      },
-      "source": [
-        "from PIL import Image\n",
-        "Image.open('PennFudanPed/PNGImages/FudanPed00001.png')"
-      ],
-      "execution_count": 0,
-      "outputs": [
-        {
-          "output_type": "execute_result",
-          "data": {
-            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAi8AAAIYCAIAAAAqyZsGAAEAAElEQVR4nHz9V7MsSXImCCoxMycR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\n",
-            "text/plain": [
-              "<PIL.PngImagePlugin.PngImageFile image mode=RGB size=559x536 at 0x7F9EDEE0AEF0>"
-            ]
-          },
-          "metadata": {
-            "tags": []
-          },
-          "execution_count": 3
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "cFHKCvCTxiff",
-        "colab_type": "code",
-        "outputId": "5a78c0ef-9ad8-4106-f699-81eec13f33f8",
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 553
-        }
-      },
-      "source": [
-        "mask = Image.open('PennFudanPed/PedMasks/FudanPed00001_mask.png')\n",
-        "# each mask instance has a different color, from zero to N, where\n",
-        "# N is the number of instances. In order to make visualization easier,\n",
-        "# let's adda color palette to the mask.\n",
-        "mask.putpalette([\n",
-        "    0, 0, 0, # black background\n",
-        "    255, 0, 0, # index 1 is red\n",
-        "    255, 255, 0, # index 2 is yellow\n",
-        "    255, 153, 0, # index 3 is orange\n",
-        "])\n",
-        "mask"
-      ],
-      "execution_count": 0,
-      "outputs": [
-        {
-          "output_type": "execute_result",
-          "data": {
-            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAi8AAAIYAgMAAADYxeTCAAAADFBMVEUAAAD/AAD//wD/mQBMHVIj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\n",
-            "text/plain": [
-              "<PIL.PngImagePlugin.PngImageFile image mode=P size=559x536 at 0x7F9EDDF0F9B0>"
-            ]
-          },
-          "metadata": {
-            "tags": []
-          },
-          "execution_count": 4
-        }
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "C9Ee5NV54Dmj",
-        "colab_type": "text"
-      },
-      "source": [
-        "So each image has a corresponding segmentation mask, where each color correspond to a different instance. Let's write a `torch.utils.data.Dataset` class for this dataset."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "mTgWtixZTs3X",
-        "colab_type": "code",
-        "colab": {}
-      },
-      "source": [
-        "import os\n",
-        "import numpy as np\n",
-        "import torch\n",
-        "import torch.utils.data\n",
-        "from PIL import Image\n",
-        "\n",
-        "\n",
-        "class PennFudanDataset(torch.utils.data.Dataset):\n",
-        "    def __init__(self, root, transforms=None):\n",
-        "        self.root = root\n",
-        "        self.transforms = transforms\n",
-        "        # load all image files, sorting them to\n",
-        "        # ensure that they are aligned\n",
-        "        self.imgs = list(sorted(os.listdir(os.path.join(root, \"PNGImages\"))))\n",
-        "        self.masks = list(sorted(os.listdir(os.path.join(root, \"PedMasks\"))))\n",
-        "\n",
-        "    def __getitem__(self, idx):\n",
-        "        # load images ad masks\n",
-        "        img_path = os.path.join(self.root, \"PNGImages\", self.imgs[idx])\n",
-        "        mask_path = os.path.join(self.root, \"PedMasks\", self.masks[idx])\n",
-        "        img = Image.open(img_path).convert(\"RGB\")\n",
-        "        # note that we haven't converted the mask to RGB,\n",
-        "        # because each color corresponds to a different instance\n",
-        "        # with 0 being background\n",
-        "        mask = Image.open(mask_path)\n",
-        "\n",
-        "        mask = np.array(mask)\n",
-        "        # instances are encoded as different colors\n",
-        "        obj_ids = np.unique(mask)\n",
-        "        # first id is the background, so remove it\n",
-        "        obj_ids = obj_ids[1:]\n",
-        "\n",
-        "        # split the color-encoded mask into a set\n",
-        "        # of binary masks\n",
-        "        masks = mask == obj_ids[:, None, None]\n",
-        "\n",
-        "        # get bounding box coordinates for each mask\n",
-        "        num_objs = len(obj_ids)\n",
-        "        boxes = []\n",
-        "        for i in range(num_objs):\n",
-        "            pos = np.where(masks[i])\n",
-        "            xmin = np.min(pos[1])\n",
-        "            xmax = np.max(pos[1])\n",
-        "            ymin = np.min(pos[0])\n",
-        "            ymax = np.max(pos[0])\n",
-        "            boxes.append([xmin, ymin, xmax, ymax])\n",
-        "\n",
-        "        boxes = torch.as_tensor(boxes, dtype=torch.float32)\n",
-        "        # there is only one class\n",
-        "        labels = torch.ones((num_objs,), dtype=torch.int64)\n",
-        "        masks = torch.as_tensor(masks, dtype=torch.uint8)\n",
-        "\n",
-        "        image_id = torch.tensor([idx])\n",
-        "        area = (boxes[:, 3] - boxes[:, 1]) * (boxes[:, 2] - boxes[:, 0])\n",
-        "        # suppose all instances are not crowd\n",
-        "        iscrowd = torch.zeros((num_objs,), dtype=torch.int64)\n",
-        "\n",
-        "        target = {}\n",
-        "        target[\"boxes\"] = boxes\n",
-        "        target[\"labels\"] = labels\n",
-        "        target[\"masks\"] = masks\n",
-        "        target[\"image_id\"] = image_id\n",
-        "        target[\"area\"] = area\n",
-        "        target[\"iscrowd\"] = iscrowd\n",
-        "\n",
-        "        if self.transforms is not None:\n",
-        "            img, target = self.transforms(img, target)\n",
-        "\n",
-        "        return img, target\n",
-        "\n",
-        "    def __len__(self):\n",
-        "        return len(self.imgs)"
-      ],
-      "execution_count": 0,
-      "outputs": []
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "J6f3ZOTJ4Km9",
-        "colab_type": "text"
-      },
-      "source": [
-        "That's all for the dataset. Let's see how the outputs are structured for this dataset"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "ZEARO4B_ye0s",
-        "colab_type": "code",
-        "outputId": "03974749-b9ba-4d03-b3a6-9a566078b320",
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 326
-        }
-      },
-      "source": [
-        "dataset = PennFudanDataset('PennFudanPed/')\n",
-        "dataset[0]"
-      ],
-      "execution_count": 0,
-      "outputs": [
-        {
-          "output_type": "execute_result",
-          "data": {
-            "text/plain": [
-              "(<PIL.Image.Image image mode=RGB size=559x536 at 0x7F9EDDF1A400>,\n",
-              " {'area': tensor([35358., 36225.]), 'boxes': tensor([[159., 181., 301., 430.],\n",
-              "          [419., 170., 534., 485.]]), 'image_id': tensor([0]), 'iscrowd': tensor([0, 0]), 'labels': tensor([1, 1]), 'masks': tensor([[[0, 0, 0,  ..., 0, 0, 0],\n",
-              "           [0, 0, 0,  ..., 0, 0, 0],\n",
-              "           [0, 0, 0,  ..., 0, 0, 0],\n",
-              "           ...,\n",
-              "           [0, 0, 0,  ..., 0, 0, 0],\n",
-              "           [0, 0, 0,  ..., 0, 0, 0],\n",
-              "           [0, 0, 0,  ..., 0, 0, 0]],\n",
-              "  \n",
-              "          [[0, 0, 0,  ..., 0, 0, 0],\n",
-              "           [0, 0, 0,  ..., 0, 0, 0],\n",
-              "           [0, 0, 0,  ..., 0, 0, 0],\n",
-              "           ...,\n",
-              "           [0, 0, 0,  ..., 0, 0, 0],\n",
-              "           [0, 0, 0,  ..., 0, 0, 0],\n",
-              "           [0, 0, 0,  ..., 0, 0, 0]]], dtype=torch.uint8)})"
-            ]
-          },
-          "metadata": {
-            "tags": []
-          },
-          "execution_count": 6
-        }
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "lWOhcsir9Ahx",
-        "colab_type": "text"
-      },
-      "source": [
-        "So we can see that by default, the dataset returns a `PIL.Image` and a dictionary\n",
-        "containing several fields, including `boxes`, `labels` and `masks`."
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "RoAEkUgn4uEq",
-        "colab_type": "text"
-      },
-      "source": [
-        "## Defining your model\n",
-        "\n",
-        "In this tutorial, we will be using [Mask R-CNN](https://arxiv.org/abs/1703.06870), which is based on top of [Faster R-CNN](https://arxiv.org/abs/1506.01497). Faster R-CNN is a model that predicts both bounding boxes and class scores for potential objects in the image.\n",
-        "\n",
-        "![alt text](https://)\n",
-        "\n",
-        "Mask R-CNN adds an extra branch into Faster R-CNN, which also predicts segmentation masks for each instance.\n",
-        "\n",
-        "![alt text](https://)\n",
-        "\n",
-        "There are two common situations where one might want to modify one of the available models in torchvision modelzoo.\n",
-        "The first is when we want to start from a pre-trained model, and just finetune the last layer. The other is when we want to replace the backbone of the model with a different one (for faster predictions, for example).\n",
-        "\n",
-        "Let's go see how we would do one or another in the following sections.\n",
-        "\n",
-        "\n",
-        "### 1 - Finetuning from a pretrained model\n",
-        "\n",
-        "Let's suppose that you want to start from a model pre-trained on COCO and want to finetune it for your particular classes. Here is a possible way of doing it:\n",
-        "```\n",
-        "import torchvision\n",
-        "from torchvision.models.detection.faster_rcnn import FastRCNNPredictor\n",
-        "\n",
-        "# load a model pre-trained pre-trained on COCO\n",
-        "model = torchvision.models.detection.fasterrcnn_resnet50_fpn(pretrained=True)\n",
-        "\n",
-        "# replace the classifier with a new one, that has\n",
-        "# num_classes which is user-defined\n",
-        "num_classes = 2  # 1 class (person) + background\n",
-        "# get number of input features for the classifier\n",
-        "in_features = model.roi_heads.box_predictor.cls_score.in_features\n",
-        "# replace the pre-trained head with a new one\n",
-        "model.roi_heads.box_predictor = FastRCNNPredictor(in_features, num_classes) \n",
-        "```\n",
-        "\n",
-        "### 2 - Modifying the model to add a different backbone\n",
-        "\n",
-        "Another common situation arises when the user wants to replace the backbone of a detection\n",
-        "model with a different one. For example, the current default backbone (ResNet-50) might be too big for some applications, and smaller models might be necessary.\n",
-        "\n",
-        "Here is how we would go into leveraging the functions provided by torchvision to modify a backbone.\n",
-        "\n",
-        "```\n",
-        "import torchvision\n",
-        "from torchvision.models.detection import FasterRCNN\n",
-        "from torchvision.models.detection.rpn import AnchorGenerator\n",
-        "\n",
-        "# load a pre-trained model for classification and return\n",
-        "# only the features\n",
-        "backbone = torchvision.models.mobilenet_v2(pretrained=True).features\n",
-        "# FasterRCNN needs to know the number of\n",
-        "# output channels in a backbone. For mobilenet_v2, it's 1280\n",
-        "# so we need to add it here\n",
-        "backbone.out_channels = 1280\n",
-        "\n",
-        "# let's make the RPN generate 5 x 3 anchors per spatial\n",
-        "# location, with 5 different sizes and 3 different aspect\n",
-        "# ratios. We have a Tuple[Tuple[int]] because each feature\n",
-        "# map could potentially have different sizes and\n",
-        "# aspect ratios \n",
-        "anchor_generator = AnchorGenerator(sizes=((32, 64, 128, 256, 512),),\n",
-        "                                   aspect_ratios=((0.5, 1.0, 2.0),))\n",
-        "\n",
-        "# let's define what are the feature maps that we will\n",
-        "# use to perform the region of interest cropping, as well as\n",
-        "# the size of the crop after rescaling.\n",
-        "# if your backbone returns a Tensor, featmap_names is expected to\n",
-        "# be [0]. More generally, the backbone should return an\n",
-        "# OrderedDict[Tensor], and in featmap_names you can choose which\n",
-        "# feature maps to use.\n",
-        "roi_pooler = torchvision.ops.MultiScaleRoIAlign(featmap_names=[0],\n",
-        "                                                output_size=7,\n",
-        "                                                sampling_ratio=2)\n",
-        "\n",
-        "# put the pieces together inside a FasterRCNN model\n",
-        "model = FasterRCNN(backbone,\n",
-        "                   num_classes=2,\n",
-        "                   rpn_anchor_generator=anchor_generator,\n",
-        "                   box_roi_pool=roi_pooler)\n",
-        "```\n",
-        "\n",
-        "### An Instance segmentation model for PennFudan Dataset\n",
-        "\n",
-        "In our case, we want to fine-tune from a pre-trained model, given that our dataset is very small. So we will be following approach number 1.\n",
-        "\n",
-        "Here we want to also compute the instance segmentation masks, so we will be using Mask R-CNN:"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "YjNHjVMOyYlH",
-        "colab_type": "code",
-        "colab": {}
-      },
-      "source": [
-        "import torchvision\n",
-        "from torchvision.models.detection.faster_rcnn import FastRCNNPredictor\n",
-        "from torchvision.models.detection.mask_rcnn import MaskRCNNPredictor\n",
-        "\n",
-        "      \n",
-        "def get_instance_segmentation_model(num_classes):\n",
-        "    # load an instance segmentation model pre-trained on COCO\n",
-        "    model = torchvision.models.detection.maskrcnn_resnet50_fpn(pretrained=True)\n",
-        "\n",
-        "    # get the number of input features for the classifier\n",
-        "    in_features = model.roi_heads.box_predictor.cls_score.in_features\n",
-        "    # replace the pre-trained head with a new one\n",
-        "    model.roi_heads.box_predictor = FastRCNNPredictor(in_features, num_classes)\n",
-        "\n",
-        "    # now get the number of input features for the mask classifier\n",
-        "    in_features_mask = model.roi_heads.mask_predictor.conv5_mask.in_channels\n",
-        "    hidden_layer = 256\n",
-        "    # and replace the mask predictor with a new one\n",
-        "    model.roi_heads.mask_predictor = MaskRCNNPredictor(in_features_mask,\n",
-        "                                                       hidden_layer,\n",
-        "                                                       num_classes)\n",
-        "\n",
-        "    return model"
-      ],
-      "execution_count": 0,
-      "outputs": []
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "-WXLwePV5ieP",
-        "colab_type": "text"
-      },
-      "source": [
-        "That's it, this will make model be ready to be trained and evaluated on our custom dataset.\n",
-        "\n",
-        "## Training and evaluation functions\n",
-        "\n",
-        "In `references/detection/,` we have a number of helper functions to simplify training and evaluating detection models.\n",
-        "Here, we will use `references/detection/engine.py`, `references/detection/utils.py` and `references/detection/transforms.py`.\n",
-        "\n",
-        "Let's copy those files (and their dependencies) in here so that they are available in the notebook"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "UYDb7PBw55b-",
-        "colab_type": "code",
-        "outputId": "45309f6e-2fed-4c49-a2c0-381da0fb4aca",
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 68
-        }
-      },
-      "source": [
-        "%%shell\n",
-        "\n",
-        "# Download TorchVision repo to use some files from\n",
-        "# references/detection\n",
-        "git clone https://github.com/pytorch/vision.git\n",
-        "cd vision\n",
-        "git checkout v0.3.0\n",
-        "\n",
-        "cp references/detection/utils.py ../\n",
-        "cp references/detection/transforms.py ../\n",
-        "cp references/detection/coco_eval.py ../\n",
-        "cp references/detection/engine.py ../\n",
-        "cp references/detection/coco_utils.py ../"
-      ],
-      "execution_count": 0,
-      "outputs": [
-        {
-          "output_type": "stream",
-          "text": [
-            "fatal: destination path 'vision' already exists and is not an empty directory.\n",
-            "Already on 'v0.3.0'\n",
-            "Your branch is up to date with 'origin/v0.3.0'.\n"
-          ],
-          "name": "stdout"
-        },
-        {
-          "output_type": "execute_result",
-          "data": {
-            "text/plain": [
-              ""
-            ]
-          },
-          "metadata": {
-            "tags": []
-          },
-          "execution_count": 8
-        }
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "2u9e_pdv54nG",
-        "colab_type": "text"
-      },
-      "source": [
-        "\n",
-        "\n",
-        "Let's write some helper functions for data augmentation / transformation, which leverages the functions in `refereces/detection` that we have just copied:\n"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "l79ivkwKy357",
-        "colab_type": "code",
-        "colab": {}
-      },
-      "source": [
-        "from engine import train_one_epoch, evaluate\n",
-        "import utils\n",
-        "import transforms as T\n",
-        "\n",
-        "\n",
-        "def get_transform(train):\n",
-        "    transforms = []\n",
-        "    # converts the image, a PIL image, into a PyTorch Tensor\n",
-        "    transforms.append(T.ToTensor())\n",
-        "    if train:\n",
-        "        # during training, randomly flip the training images\n",
-        "        # and ground-truth for data augmentation\n",
-        "        transforms.append(T.RandomHorizontalFlip(0.5))\n",
-        "    return T.Compose(transforms)"
-      ],
-      "execution_count": 0,
-      "outputs": []
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "FzCLqiZk-sjf",
-        "colab_type": "text"
-      },
-      "source": [
-        "#### Note that we do not need to add a mean/std normalization nor image rescaling in the data transforms, as those are handled internally by the Mask R-CNN model."
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "3YFJGJxk6XEs",
-        "colab_type": "text"
-      },
-      "source": [
-        "### Putting everything together\n",
-        "\n",
-        "We now have the dataset class, the models and the data transforms. Let's instantiate them"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "a5dGaIezze3y",
-        "colab_type": "code",
-        "colab": {}
-      },
-      "source": [
-        "# use our dataset and defined transformations\n",
-        "dataset = PennFudanDataset('PennFudanPed', get_transform(train=True))\n",
-        "dataset_test = PennFudanDataset('PennFudanPed', get_transform(train=False))\n",
-        "\n",
-        "# split the dataset in train and test set\n",
-        "torch.manual_seed(1)\n",
-        "indices = torch.randperm(len(dataset)).tolist()\n",
-        "dataset = torch.utils.data.Subset(dataset, indices[:-50])\n",
-        "dataset_test = torch.utils.data.Subset(dataset_test, indices[-50:])\n",
-        "\n",
-        "# define training and validation data loaders\n",
-        "data_loader = torch.utils.data.DataLoader(\n",
-        "    dataset, batch_size=2, shuffle=True, num_workers=4,\n",
-        "    collate_fn=utils.collate_fn)\n",
-        "\n",
-        "data_loader_test = torch.utils.data.DataLoader(\n",
-        "    dataset_test, batch_size=1, shuffle=False, num_workers=4,\n",
-        "    collate_fn=utils.collate_fn)"
-      ],
-      "execution_count": 0,
-      "outputs": []
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "L5yvZUprj4ZN",
-        "colab_type": "text"
-      },
-      "source": [
-        "Now let's instantiate the model and the optimizer"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "zoenkCj18C4h",
-        "colab_type": "code",
-        "outputId": "44c71ea4-7778-40ec-c838-99ee45aace4d",
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 71
-        }
-      },
-      "source": [
-        "device = torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu')\n",
-        "\n",
-        "# our dataset has two classes only - background and person\n",
-        "num_classes = 2\n",
-        "\n",
-        "# get the model using our helper function\n",
-        "model = get_instance_segmentation_model(num_classes)\n",
-        "# move model to the right device\n",
-        "model.to(device)\n",
-        "\n",
-        "# construct an optimizer\n",
-        "params = [p for p in model.parameters() if p.requires_grad]\n",
-        "optimizer = torch.optim.SGD(params, lr=0.005,\n",
-        "                            momentum=0.9, weight_decay=0.0005)\n",
-        "\n",
-        "# and a learning rate scheduler which decreases the learning rate by\n",
-        "# 10x every 3 epochs\n",
-        "lr_scheduler = torch.optim.lr_scheduler.StepLR(optimizer,\n",
-        "                                               step_size=3,\n",
-        "                                               gamma=0.1)"
-      ],
-      "execution_count": 0,
-      "outputs": [
-        {
-          "output_type": "stream",
-          "text": [
-            "Downloading: \"https://download.pytorch.org/models/maskrcnn_resnet50_fpn_coco-bf2d0c1e.pth\" to /root/.cache/torch/checkpoints/maskrcnn_resnet50_fpn_coco-bf2d0c1e.pth\n",
-            "100%|██████████| 178090079/178090079 [00:02<00:00, 61358754.67it/s]\n"
-          ],
-          "name": "stderr"
-        }
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "XAd56lt4kDxc",
-        "colab_type": "text"
-      },
-      "source": [
-        "And now let's train the model for 10 epochs, evaluating at the end of every epoch."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "at-h4OWK0aoc",
-        "colab_type": "code",
-        "outputId": "80d9fbf0-100b-46b5-ea7d-fad8bd8bd4e5",
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 7517
-        }
-      },
-      "source": [
-        "# let's train it for 10 epochs\n",
-        "num_epochs = 10\n",
-        "\n",
-        "for epoch in range(num_epochs):\n",
-        "    # train for one epoch, printing every 10 iterations\n",
-        "    train_one_epoch(model, optimizer, data_loader, device, epoch, print_freq=10)\n",
-        "    # update the learning rate\n",
-        "    lr_scheduler.step()\n",
-        "    # evaluate on the test dataset\n",
-        "    evaluate(model, data_loader_test, device=device)"
-      ],
-      "execution_count": 0,
-      "outputs": [
-        {
-          "output_type": "stream",
-          "text": [
-            "Epoch: [0]  [ 0/60]  eta: 0:01:54  lr: 0.000090  loss: 3.5688 (3.5688)  loss_classifier: 0.7563 (0.7563)  loss_box_reg: 0.1544 (0.1544)  loss_mask: 2.6350 (2.6350)  loss_objectness: 0.0167 (0.0167)  loss_rpn_box_reg: 0.0064 (0.0064)  time: 1.9101  data: 0.4269  max mem: 3175\n",
-            "Epoch: [0]  [10/60]  eta: 0:00:35  lr: 0.000936  loss: 1.5702 (2.1186)  loss_classifier: 0.4521 (0.4978)  loss_box_reg: 0.1846 (0.1915)  loss_mask: 0.9227 (1.3971)  loss_objectness: 0.0173 (0.0219)  loss_rpn_box_reg: 0.0087 (0.0103)  time: 0.7126  data: 0.0450  max mem: 4552\n",
-            "Epoch: [0]  [20/60]  eta: 0:00:26  lr: 0.001783  loss: 0.8643 (1.4273)  loss_classifier: 0.2400 (0.3407)  loss_box_reg: 0.1589 (0.1740)  loss_mask: 0.3977 (0.8806)  loss_objectness: 0.0173 (0.0201)  loss_rpn_box_reg: 0.0090 (0.0119)  time: 0.5888  data: 0.0067  max mem: 4552\n",
-            "Epoch: [0]  [30/60]  eta: 0:00:19  lr: 0.002629  loss: 0.5349 (1.1192)  loss_classifier: 0.0967 (0.2569)  loss_box_reg: 0.1289 (0.1610)  loss_mask: 0.2496 (0.6734)  loss_objectness: 0.0102 (0.0163)  loss_rpn_box_reg: 0.0101 (0.0116)  time: 0.6026  data: 0.0066  max mem: 5310\n",
-            "Epoch: [0]  [40/60]  eta: 0:00:12  lr: 0.003476  loss: 0.4128 (0.9479)  loss_classifier: 0.0634 (0.2091)  loss_box_reg: 0.1078 (0.1524)  loss_mask: 0.2095 (0.5601)  loss_objectness: 0.0059 (0.0138)  loss_rpn_box_reg: 0.0113 (0.0125)  time: 0.6283  data: 0.0066  max mem: 5310\n",
-            "Epoch: [0]  [50/60]  eta: 0:00:06  lr: 0.004323  loss: 0.3223 (0.8260)  loss_classifier: 0.0453 (0.1783)  loss_box_reg: 0.0899 (0.1395)  loss_mask: 0.1734 (0.4838)  loss_objectness: 0.0038 (0.0118)  loss_rpn_box_reg: 0.0113 (0.0126)  time: 0.6311  data: 0.0070  max mem: 5310\n",
-            "Epoch: [0]  [59/60]  eta: 0:00:00  lr: 0.005000  loss: 0.2608 (0.7366)  loss_classifier: 0.0390 (0.1564)  loss_box_reg: 0.0574 (0.1245)  loss_mask: 0.1512 (0.4334)  loss_objectness: 0.0020 (0.0103)  loss_rpn_box_reg: 0.0102 (0.0121)  time: 0.6404  data: 0.0075  max mem: 5310\n",
-            "Epoch: [0] Total time: 0:00:38 (0.6413 s / it)\n",
-            "creating index...\n",
-            "index created!\n",
-            "Test:  [ 0/50]  eta: 0:00:28  model_time: 0.3890 (0.3890)  evaluator_time: 0.0042 (0.0042)  time: 0.5795  data: 0.1848  max mem: 5310\n",
-            "Test:  [49/50]  eta: 0:00:00  model_time: 0.1158 (0.1223)  evaluator_time: 0.0046 (0.0088)  time: 0.1289  data: 0.0036  max mem: 5310\n",
-            "Test: Total time: 0:00:07 (0.1421 s / it)\n",
-            "Averaged stats: model_time: 0.1158 (0.1223)  evaluator_time: 0.0046 (0.0088)\n",
-            "Accumulating evaluation results...\n",
-            "DONE (t=0.01s).\n",
-            "Accumulating evaluation results...\n",
-            "DONE (t=0.01s).\n",
-            "IoU metric: bbox\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.682\n",
-            " Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.982\n",
-            " Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.872\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = -1.000\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.406\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.693\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] = 0.311\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] = 0.742\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.742\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = -1.000\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.700\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.745\n",
-            "IoU metric: segm\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.704\n",
-            " Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.982\n",
-            " Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.910\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = -1.000\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.434\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.717\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] = 0.323\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] = 0.748\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.750\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = -1.000\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.688\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.754\n",
-            "Epoch: [1]  [ 0/60]  eta: 0:01:04  lr: 0.005000  loss: 0.3601 (0.3601)  loss_classifier: 0.0550 (0.0550)  loss_box_reg: 0.1111 (0.1111)  loss_mask: 0.1692 (0.1692)  loss_objectness: 0.0032 (0.0032)  loss_rpn_box_reg: 0.0217 (0.0217)  time: 1.0794  data: 0.4107  max mem: 5310\n",
-            "Epoch: [1]  [10/60]  eta: 0:00:37  lr: 0.005000  loss: 0.2678 (0.2754)  loss_classifier: 0.0542 (0.0497)  loss_box_reg: 0.0572 (0.0565)  loss_mask: 0.1510 (0.1532)  loss_objectness: 0.0016 (0.0019)  loss_rpn_box_reg: 0.0096 (0.0142)  time: 0.7499  data: 0.0436  max mem: 5310\n",
-            "Epoch: [1]  [20/60]  eta: 0:00:28  lr: 0.005000  loss: 0.2345 (0.2438)  loss_classifier: 0.0400 (0.0421)  loss_box_reg: 0.0362 (0.0445)  loss_mask: 0.1347 (0.1429)  loss_objectness: 0.0014 (0.0022)  loss_rpn_box_reg: 0.0095 (0.0121)  time: 0.6846  data: 0.0068  max mem: 5310\n",
-            "Epoch: [1]  [30/60]  eta: 0:00:20  lr: 0.005000  loss: 0.1942 (0.2286)  loss_classifier: 0.0235 (0.0373)  loss_box_reg: 0.0205 (0.0355)  loss_mask: 0.1293 (0.1434)  loss_objectness: 0.0005 (0.0017)  loss_rpn_box_reg: 0.0068 (0.0106)  time: 0.6301  data: 0.0066  max mem: 5310\n",
-            "Epoch: [1]  [40/60]  eta: 0:00:13  lr: 0.005000  loss: 0.1951 (0.2253)  loss_classifier: 0.0277 (0.0361)  loss_box_reg: 0.0173 (0.0324)  loss_mask: 0.1331 (0.1450)  loss_objectness: 0.0005 (0.0016)  loss_rpn_box_reg: 0.0074 (0.0102)  time: 0.6304  data: 0.0066  max mem: 5310\n",
-            "Epoch: [1]  [50/60]  eta: 0:00:06  lr: 0.005000  loss: 0.2011 (0.2242)  loss_classifier: 0.0348 (0.0370)  loss_box_reg: 0.0207 (0.0309)  loss_mask: 0.1337 (0.1438)  loss_objectness: 0.0007 (0.0016)  loss_rpn_box_reg: 0.0080 (0.0109)  time: 0.6441  data: 0.0068  max mem: 5310\n",
-            "Epoch: [1]  [59/60]  eta: 0:00:00  lr: 0.005000  loss: 0.2162 (0.2248)  loss_classifier: 0.0381 (0.0382)  loss_box_reg: 0.0253 (0.0307)  loss_mask: 0.1325 (0.1437)  loss_objectness: 0.0008 (0.0016)  loss_rpn_box_reg: 0.0085 (0.0106)  time: 0.6245  data: 0.0067  max mem: 5310\n",
-            "Epoch: [1] Total time: 0:00:39 (0.6548 s / it)\n",
-            "creating index...\n",
-            "index created!\n",
-            "Test:  [ 0/50]  eta: 0:00:17  model_time: 0.1625 (0.1625)  evaluator_time: 0.0040 (0.0040)  time: 0.3575  data: 0.1894  max mem: 5310\n",
-            "Test:  [49/50]  eta: 0:00:00  model_time: 0.1113 (0.1127)  evaluator_time: 0.0037 (0.0072)  time: 0.1226  data: 0.0034  max mem: 5310\n",
-            "Test: Total time: 0:00:06 (0.1306 s / it)\n",
-            "Averaged stats: model_time: 0.1113 (0.1127)  evaluator_time: 0.0037 (0.0072)\n",
-            "Accumulating evaluation results...\n",
-            "DONE (t=0.01s).\n",
-            "Accumulating evaluation results...\n",
-            "DONE (t=0.01s).\n",
-            "IoU metric: bbox\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.750\n",
-            " Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.983\n",
-            " Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.959\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = -1.000\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.440\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.762\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] = 0.353\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] = 0.803\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.803\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = -1.000\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.725\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.809\n",
-            "IoU metric: segm\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.734\n",
-            " Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.974\n",
-            " Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.889\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = -1.000\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.413\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.749\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] = 0.339\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] = 0.776\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.776\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = -1.000\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.662\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.784\n",
-            "Epoch: [2]  [ 0/60]  eta: 0:00:57  lr: 0.005000  loss: 0.2592 (0.2592)  loss_classifier: 0.0457 (0.0457)  loss_box_reg: 0.0357 (0.0357)  loss_mask: 0.1604 (0.1604)  loss_objectness: 0.0005 (0.0005)  loss_rpn_box_reg: 0.0169 (0.0169)  time: 0.9603  data: 0.4132  max mem: 5310\n",
-            "Epoch: [2]  [10/60]  eta: 0:00:31  lr: 0.005000  loss: 0.1793 (0.1962)  loss_classifier: 0.0260 (0.0358)  loss_box_reg: 0.0164 (0.0199)  loss_mask: 0.1189 (0.1288)  loss_objectness: 0.0010 (0.0015)  loss_rpn_box_reg: 0.0086 (0.0102)  time: 0.6373  data: 0.0410  max mem: 5310\n",
-            "Epoch: [2]  [20/60]  eta: 0:00:25  lr: 0.005000  loss: 0.2012 (0.2086)  loss_classifier: 0.0270 (0.0358)  loss_box_reg: 0.0164 (0.0226)  loss_mask: 0.1226 (0.1372)  loss_objectness: 0.0010 (0.0015)  loss_rpn_box_reg: 0.0102 (0.0115)  time: 0.6289  data: 0.0052  max mem: 5310\n",
-            "Epoch: [2]  [30/60]  eta: 0:00:18  lr: 0.005000  loss: 0.1754 (0.1926)  loss_classifier: 0.0270 (0.0320)  loss_box_reg: 0.0133 (0.0183)  loss_mask: 0.1226 (0.1313)  loss_objectness: 0.0005 (0.0011)  loss_rpn_box_reg: 0.0082 (0.0099)  time: 0.6294  data: 0.0067  max mem: 5310\n",
-            "Epoch: [2]  [40/60]  eta: 0:00:12  lr: 0.005000  loss: 0.1664 (0.1907)  loss_classifier: 0.0313 (0.0322)  loss_box_reg: 0.0121 (0.0178)  loss_mask: 0.1240 (0.1294)  loss_objectness: 0.0005 (0.0014)  loss_rpn_box_reg: 0.0079 (0.0098)  time: 0.6273  data: 0.0067  max mem: 5310\n",
-            "Epoch: [2]  [50/60]  eta: 0:00:06  lr: 0.005000  loss: 0.1771 (0.1862)  loss_classifier: 0.0285 (0.0308)  loss_box_reg: 0.0145 (0.0170)  loss_mask: 0.1263 (0.1278)  loss_objectness: 0.0005 (0.0013)  loss_rpn_box_reg: 0.0086 (0.0094)  time: 0.6417  data: 0.0068  max mem: 5310\n",
-            "Epoch: [2]  [59/60]  eta: 0:00:00  lr: 0.005000  loss: 0.1771 (0.1900)  loss_classifier: 0.0257 (0.0316)  loss_box_reg: 0.0158 (0.0180)  loss_mask: 0.1269 (0.1291)  loss_objectness: 0.0009 (0.0014)  loss_rpn_box_reg: 0.0077 (0.0099)  time: 0.6555  data: 0.0073  max mem: 5310\n",
-            "Epoch: [2] Total time: 0:00:38 (0.6433 s / it)\n",
-            "creating index...\n",
-            "index created!\n",
-            "Test:  [ 0/50]  eta: 0:00:18  model_time: 0.1615 (0.1615)  evaluator_time: 0.0041 (0.0041)  time: 0.3662  data: 0.1992  max mem: 5310\n",
-            "Test:  [49/50]  eta: 0:00:00  model_time: 0.1143 (0.1142)  evaluator_time: 0.0035 (0.0059)  time: 0.1230  data: 0.0034  max mem: 5310\n",
-            "Test: Total time: 0:00:06 (0.1307 s / it)\n",
-            "Averaged stats: model_time: 0.1143 (0.1142)  evaluator_time: 0.0035 (0.0059)\n",
-            "Accumulating evaluation results...\n",
-            "DONE (t=0.01s).\n",
-            "Accumulating evaluation results...\n",
-            "DONE (t=0.01s).\n",
-            "IoU metric: bbox\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.803\n",
-            " Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.990\n",
-            " Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.958\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = -1.000\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.474\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.814\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] = 0.363\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] = 0.840\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.840\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = -1.000\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.762\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.846\n",
-            "IoU metric: segm\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.764\n",
-            " Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.990\n",
-            " Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.922\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = -1.000\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.474\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.776\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] = 0.345\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] = 0.803\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.803\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = -1.000\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.725\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.809\n",
-            "Epoch: [3]  [ 0/60]  eta: 0:01:31  lr: 0.000500  loss: 0.2188 (0.2188)  loss_classifier: 0.0488 (0.0488)  loss_box_reg: 0.0222 (0.0222)  loss_mask: 0.1369 (0.1369)  loss_objectness: 0.0002 (0.0002)  loss_rpn_box_reg: 0.0106 (0.0106)  time: 1.5300  data: 0.7803  max mem: 5310\n",
-            "Epoch: [3]  [10/60]  eta: 0:00:35  lr: 0.000500  loss: 0.1462 (0.1512)  loss_classifier: 0.0216 (0.0238)  loss_box_reg: 0.0074 (0.0093)  loss_mask: 0.1066 (0.1111)  loss_objectness: 0.0005 (0.0006)  loss_rpn_box_reg: 0.0048 (0.0064)  time: 0.7073  data: 0.0738  max mem: 5310\n",
-            "Epoch: [3]  [20/60]  eta: 0:00:27  lr: 0.000500  loss: 0.1462 (0.1572)  loss_classifier: 0.0216 (0.0257)  loss_box_reg: 0.0068 (0.0108)  loss_mask: 0.1055 (0.1123)  loss_objectness: 0.0004 (0.0007)  loss_rpn_box_reg: 0.0052 (0.0077)  time: 0.6362  data: 0.0049  max mem: 5310\n",
-            "Epoch: [3]  [30/60]  eta: 0:00:20  lr: 0.000500  loss: 0.1587 (0.1656)  loss_classifier: 0.0256 (0.0275)  loss_box_reg: 0.0095 (0.0120)  loss_mask: 0.1156 (0.1169)  loss_objectness: 0.0005 (0.0009)  loss_rpn_box_reg: 0.0082 (0.0083)  time: 0.6555  data: 0.0066  max mem: 5310\n",
-            "Epoch: [3]  [40/60]  eta: 0:00:13  lr: 0.000500  loss: 0.1624 (0.1694)  loss_classifier: 0.0229 (0.0269)  loss_box_reg: 0.0107 (0.0128)  loss_mask: 0.1235 (0.1206)  loss_objectness: 0.0007 (0.0010)  loss_rpn_box_reg: 0.0076 (0.0082)  time: 0.6545  data: 0.0068  max mem: 5310\n",
-            "Epoch: [3]  [50/60]  eta: 0:00:06  lr: 0.000500  loss: 0.1547 (0.1647)  loss_classifier: 0.0229 (0.0262)  loss_box_reg: 0.0094 (0.0123)  loss_mask: 0.1069 (0.1176)  loss_objectness: 0.0003 (0.0009)  loss_rpn_box_reg: 0.0057 (0.0077)  time: 0.6276  data: 0.0068  max mem: 5310\n",
-            "Epoch: [3]  [59/60]  eta: 0:00:00  lr: 0.000500  loss: 0.1461 (0.1655)  loss_classifier: 0.0218 (0.0258)  loss_box_reg: 0.0084 (0.0123)  loss_mask: 0.1061 (0.1185)  loss_objectness: 0.0003 (0.0009)  loss_rpn_box_reg: 0.0056 (0.0079)  time: 0.6126  data: 0.0068  max mem: 5310\n",
-            "Epoch: [3] Total time: 0:00:39 (0.6519 s / it)\n",
-            "creating index...\n",
-            "index created!\n",
-            "Test:  [ 0/50]  eta: 0:00:18  model_time: 0.1630 (0.1630)  evaluator_time: 0.0038 (0.0038)  time: 0.3705  data: 0.2021  max mem: 5310\n",
-            "Test:  [49/50]  eta: 0:00:00  model_time: 0.1125 (0.1124)  evaluator_time: 0.0037 (0.0057)  time: 0.1215  data: 0.0036  max mem: 5310\n",
-            "Test: Total time: 0:00:06 (0.1294 s / it)\n",
-            "Averaged stats: model_time: 0.1125 (0.1124)  evaluator_time: 0.0037 (0.0057)\n",
-            "Accumulating evaluation results...\n",
-            "DONE (t=0.01s).\n",
-            "Accumulating evaluation results...\n",
-            "DONE (t=0.01s).\n",
-            "IoU metric: bbox\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.814\n",
-            " Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.991\n",
-            " Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.953\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = -1.000\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.543\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.823\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] = 0.371\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] = 0.855\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.855\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = -1.000\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.787\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.860\n",
-            "IoU metric: segm\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.760\n",
-            " Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.991\n",
-            " Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.918\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = -1.000\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.478\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.768\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] = 0.345\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] = 0.801\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.801\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = -1.000\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.750\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.805\n",
-            "Epoch: [4]  [ 0/60]  eta: 0:01:06  lr: 0.000500  loss: 0.1322 (0.1322)  loss_classifier: 0.0270 (0.0270)  loss_box_reg: 0.0052 (0.0052)  loss_mask: 0.0926 (0.0926)  loss_objectness: 0.0006 (0.0006)  loss_rpn_box_reg: 0.0069 (0.0069)  time: 1.1061  data: 0.5225  max mem: 5310\n",
-            "Epoch: [4]  [10/60]  eta: 0:00:32  lr: 0.000500  loss: 0.1779 (0.1740)  loss_classifier: 0.0281 (0.0279)  loss_box_reg: 0.0109 (0.0119)  loss_mask: 0.1205 (0.1249)  loss_objectness: 0.0003 (0.0020)  loss_rpn_box_reg: 0.0063 (0.0073)  time: 0.6471  data: 0.0514  max mem: 5310\n",
-            "Epoch: [4]  [20/60]  eta: 0:00:25  lr: 0.000500  loss: 0.1608 (0.1713)  loss_classifier: 0.0286 (0.0280)  loss_box_reg: 0.0116 (0.0126)  loss_mask: 0.1129 (0.1215)  loss_objectness: 0.0003 (0.0015)  loss_rpn_box_reg: 0.0059 (0.0077)  time: 0.6207  data: 0.0055  max mem: 5345\n",
-            "Epoch: [4]  [30/60]  eta: 0:00:19  lr: 0.000500  loss: 0.1483 (0.1668)  loss_classifier: 0.0242 (0.0268)  loss_box_reg: 0.0076 (0.0124)  loss_mask: 0.1040 (0.1189)  loss_objectness: 0.0004 (0.0012)  loss_rpn_box_reg: 0.0059 (0.0075)  time: 0.6336  data: 0.0070  max mem: 5345\n",
-            "Epoch: [4]  [40/60]  eta: 0:00:12  lr: 0.000500  loss: 0.1355 (0.1625)  loss_classifier: 0.0154 (0.0258)  loss_box_reg: 0.0067 (0.0115)  loss_mask: 0.1040 (0.1165)  loss_objectness: 0.0003 (0.0011)  loss_rpn_box_reg: 0.0070 (0.0075)  time: 0.6434  data: 0.0075  max mem: 5345\n",
-            "Epoch: [4]  [50/60]  eta: 0:00:06  lr: 0.000500  loss: 0.1472 (0.1608)  loss_classifier: 0.0202 (0.0249)  loss_box_reg: 0.0074 (0.0112)  loss_mask: 0.1040 (0.1161)  loss_objectness: 0.0003 (0.0011)  loss_rpn_box_reg: 0.0060 (0.0076)  time: 0.6428  data: 0.0071  max mem: 5345\n",
-            "Epoch: [4]  [59/60]  eta: 0:00:00  lr: 0.000500  loss: 0.1477 (0.1613)  loss_classifier: 0.0225 (0.0251)  loss_box_reg: 0.0092 (0.0113)  loss_mask: 0.1126 (0.1163)  loss_objectness: 0.0003 (0.0010)  loss_rpn_box_reg: 0.0065 (0.0076)  time: 0.6340  data: 0.0069  max mem: 5345\n",
-            "Epoch: [4] Total time: 0:00:38 (0.6423 s / it)\n",
-            "creating index...\n",
-            "index created!\n",
-            "Test:  [ 0/50]  eta: 0:00:17  model_time: 0.1500 (0.1500)  evaluator_time: 0.0040 (0.0040)  time: 0.3557  data: 0.2002  max mem: 5345\n",
-            "Test:  [49/50]  eta: 0:00:00  model_time: 0.1121 (0.1121)  evaluator_time: 0.0034 (0.0057)  time: 0.1219  data: 0.0034  max mem: 5345\n",
-            "Test: Total time: 0:00:06 (0.1286 s / it)\n",
-            "Averaged stats: model_time: 0.1121 (0.1121)  evaluator_time: 0.0034 (0.0057)\n",
-            "Accumulating evaluation results...\n",
-            "DONE (t=0.01s).\n",
-            "Accumulating evaluation results...\n",
-            "DONE (t=0.01s).\n",
-            "IoU metric: bbox\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.820\n",
-            " Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.991\n",
-            " Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.953\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = -1.000\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.537\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.831\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] = 0.376\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] = 0.860\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.860\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = -1.000\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.775\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.866\n",
-            "IoU metric: segm\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.769\n",
-            " Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.991\n",
-            " Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.910\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = -1.000\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.447\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.779\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] = 0.347\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] = 0.806\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.806\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = -1.000\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.738\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.811\n",
-            "Epoch: [5]  [ 0/60]  eta: 0:00:52  lr: 0.000500  loss: 0.1502 (0.1502)  loss_classifier: 0.0202 (0.0202)  loss_box_reg: 0.0114 (0.0114)  loss_mask: 0.1132 (0.1132)  loss_objectness: 0.0002 (0.0002)  loss_rpn_box_reg: 0.0052 (0.0052)  time: 0.8670  data: 0.2655  max mem: 5345\n",
-            "Epoch: [5]  [10/60]  eta: 0:00:32  lr: 0.000500  loss: 0.1636 (0.1717)  loss_classifier: 0.0243 (0.0294)  loss_box_reg: 0.0138 (0.0136)  loss_mask: 0.1141 (0.1192)  loss_objectness: 0.0003 (0.0006)  loss_rpn_box_reg: 0.0084 (0.0090)  time: 0.6526  data: 0.0301  max mem: 5345\n",
-            "Epoch: [5]  [20/60]  eta: 0:00:25  lr: 0.000500  loss: 0.1494 (0.1601)  loss_classifier: 0.0224 (0.0261)  loss_box_reg: 0.0092 (0.0117)  loss_mask: 0.1076 (0.1138)  loss_objectness: 0.0003 (0.0005)  loss_rpn_box_reg: 0.0083 (0.0080)  time: 0.6330  data: 0.0066  max mem: 5345\n",
-            "Epoch: [5]  [30/60]  eta: 0:00:18  lr: 0.000500  loss: 0.1496 (0.1594)  loss_classifier: 0.0195 (0.0251)  loss_box_reg: 0.0092 (0.0113)  loss_mask: 0.1076 (0.1146)  loss_objectness: 0.0002 (0.0005)  loss_rpn_box_reg: 0.0075 (0.0079)  time: 0.6204  data: 0.0066  max mem: 5345\n",
-            "Epoch: [5]  [40/60]  eta: 0:00:12  lr: 0.000500  loss: 0.1606 (0.1639)  loss_classifier: 0.0249 (0.0260)  loss_box_reg: 0.0108 (0.0124)  loss_mask: 0.1124 (0.1169)  loss_objectness: 0.0003 (0.0005)  loss_rpn_box_reg: 0.0072 (0.0081)  time: 0.6338  data: 0.0067  max mem: 5345\n",
-            "Epoch: [5]  [50/60]  eta: 0:00:06  lr: 0.000500  loss: 0.1578 (0.1641)  loss_classifier: 0.0230 (0.0257)  loss_box_reg: 0.0093 (0.0117)  loss_mask: 0.1112 (0.1180)  loss_objectness: 0.0004 (0.0006)  loss_rpn_box_reg: 0.0055 (0.0080)  time: 0.6592  data: 0.0070  max mem: 5345\n",
-            "Epoch: [5]  [59/60]  eta: 0:00:00  lr: 0.000500  loss: 0.1517 (0.1626)  loss_classifier: 0.0220 (0.0252)  loss_box_reg: 0.0081 (0.0111)  loss_mask: 0.1121 (0.1179)  loss_objectness: 0.0003 (0.0007)  loss_rpn_box_reg: 0.0053 (0.0078)  time: 0.6494  data: 0.0070  max mem: 5345\n",
-            "Epoch: [5] Total time: 0:00:38 (0.6447 s / it)\n",
-            "creating index...\n",
-            "index created!\n",
-            "Test:  [ 0/50]  eta: 0:00:17  model_time: 0.1581 (0.1581)  evaluator_time: 0.0041 (0.0041)  time: 0.3526  data: 0.1888  max mem: 5345\n",
-            "Test:  [49/50]  eta: 0:00:00  model_time: 0.1133 (0.1119)  evaluator_time: 0.0036 (0.0058)  time: 0.1216  data: 0.0035  max mem: 5345\n",
-            "Test: Total time: 0:00:06 (0.1288 s / it)\n",
-            "Averaged stats: model_time: 0.1133 (0.1119)  evaluator_time: 0.0036 (0.0058)\n",
-            "Accumulating evaluation results...\n",
-            "DONE (t=0.01s).\n",
-            "Accumulating evaluation results...\n",
-            "DONE (t=0.01s).\n",
-            "IoU metric: bbox\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.818\n",
-            " Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.990\n",
-            " Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.959\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = -1.000\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.531\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.828\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] = 0.374\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] = 0.858\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.858\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = -1.000\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.787\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.863\n",
-            "IoU metric: segm\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.764\n",
-            " Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.990\n",
-            " Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.916\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = -1.000\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.484\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.772\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] = 0.350\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] = 0.806\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.806\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = -1.000\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.762\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.809\n",
-            "Epoch: [6]  [ 0/60]  eta: 0:01:15  lr: 0.000050  loss: 0.1268 (0.1268)  loss_classifier: 0.0136 (0.0136)  loss_box_reg: 0.0076 (0.0076)  loss_mask: 0.0992 (0.0992)  loss_objectness: 0.0001 (0.0001)  loss_rpn_box_reg: 0.0063 (0.0063)  time: 1.2659  data: 0.4840  max mem: 5345\n",
-            "Epoch: [6]  [10/60]  eta: 0:00:34  lr: 0.000050  loss: 0.1542 (0.1612)  loss_classifier: 0.0221 (0.0240)  loss_box_reg: 0.0120 (0.0117)  loss_mask: 0.1061 (0.1164)  loss_objectness: 0.0002 (0.0004)  loss_rpn_box_reg: 0.0063 (0.0087)  time: 0.6829  data: 0.0505  max mem: 5345\n",
-            "Epoch: [6]  [20/60]  eta: 0:00:25  lr: 0.000050  loss: 0.1531 (0.1596)  loss_classifier: 0.0212 (0.0233)  loss_box_reg: 0.0076 (0.0108)  loss_mask: 0.1123 (0.1169)  loss_objectness: 0.0003 (0.0006)  loss_rpn_box_reg: 0.0059 (0.0080)  time: 0.6122  data: 0.0072  max mem: 5345\n",
-            "Epoch: [6]  [30/60]  eta: 0:00:18  lr: 0.000050  loss: 0.1465 (0.1650)  loss_classifier: 0.0202 (0.0256)  loss_box_reg: 0.0058 (0.0120)  loss_mask: 0.1123 (0.1186)  loss_objectness: 0.0004 (0.0009)  loss_rpn_box_reg: 0.0055 (0.0078)  time: 0.5959  data: 0.0069  max mem: 5345\n",
-            "Epoch: [6]  [40/60]  eta: 0:00:12  lr: 0.000050  loss: 0.1378 (0.1603)  loss_classifier: 0.0256 (0.0268)  loss_box_reg: 0.0068 (0.0109)  loss_mask: 0.0993 (0.1142)  loss_objectness: 0.0005 (0.0009)  loss_rpn_box_reg: 0.0052 (0.0074)  time: 0.6272  data: 0.0066  max mem: 5345\n",
-            "Epoch: [6]  [50/60]  eta: 0:00:06  lr: 0.000050  loss: 0.1372 (0.1623)  loss_classifier: 0.0256 (0.0264)  loss_box_reg: 0.0075 (0.0115)  loss_mask: 0.1033 (0.1161)  loss_objectness: 0.0003 (0.0009)  loss_rpn_box_reg: 0.0058 (0.0075)  time: 0.6603  data: 0.0066  max mem: 5345\n",
-            "Epoch: [6]  [59/60]  eta: 0:00:00  lr: 0.000050  loss: 0.1372 (0.1619)  loss_classifier: 0.0204 (0.0260)  loss_box_reg: 0.0082 (0.0116)  loss_mask: 0.1074 (0.1159)  loss_objectness: 0.0004 (0.0008)  loss_rpn_box_reg: 0.0070 (0.0075)  time: 0.6463  data: 0.0067  max mem: 5345\n",
-            "Epoch: [6] Total time: 0:00:38 (0.6395 s / it)\n",
-            "creating index...\n",
-            "index created!\n",
-            "Test:  [ 0/50]  eta: 0:00:17  model_time: 0.1552 (0.1552)  evaluator_time: 0.0040 (0.0040)  time: 0.3581  data: 0.1974  max mem: 5345\n",
-            "Test:  [49/50]  eta: 0:00:00  model_time: 0.1129 (0.1116)  evaluator_time: 0.0035 (0.0057)  time: 0.1212  data: 0.0034  max mem: 5345\n",
-            "Test: Total time: 0:00:06 (0.1282 s / it)\n",
-            "Averaged stats: model_time: 0.1129 (0.1116)  evaluator_time: 0.0035 (0.0057)\n",
-            "Accumulating evaluation results...\n",
-            "DONE (t=0.01s).\n",
-            "Accumulating evaluation results...\n",
-            "DONE (t=0.01s).\n",
-            "IoU metric: bbox\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.820\n",
-            " Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.990\n",
-            " Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.960\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = -1.000\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.596\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.831\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] = 0.378\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] = 0.861\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.861\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = -1.000\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.787\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.867\n",
-            "IoU metric: segm\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.767\n",
-            " Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.990\n",
-            " Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.916\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = -1.000\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.462\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.776\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] = 0.349\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] = 0.809\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.809\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = -1.000\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.762\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.813\n",
-            "Epoch: [7]  [ 0/60]  eta: 0:00:53  lr: 0.000050  loss: 0.1048 (0.1048)  loss_classifier: 0.0119 (0.0119)  loss_box_reg: 0.0030 (0.0030)  loss_mask: 0.0879 (0.0879)  loss_objectness: 0.0000 (0.0000)  loss_rpn_box_reg: 0.0020 (0.0020)  time: 0.8976  data: 0.3350  max mem: 5345\n",
-            "Epoch: [7]  [10/60]  eta: 0:00:31  lr: 0.000050  loss: 0.1401 (0.1356)  loss_classifier: 0.0189 (0.0191)  loss_box_reg: 0.0068 (0.0071)  loss_mask: 0.1048 (0.1042)  loss_objectness: 0.0002 (0.0003)  loss_rpn_box_reg: 0.0039 (0.0049)  time: 0.6264  data: 0.0366  max mem: 5345\n",
-            "Epoch: [7]  [20/60]  eta: 0:00:25  lr: 0.000050  loss: 0.1401 (0.1490)  loss_classifier: 0.0189 (0.0204)  loss_box_reg: 0.0068 (0.0087)  loss_mask: 0.1070 (0.1134)  loss_objectness: 0.0003 (0.0007)  loss_rpn_box_reg: 0.0044 (0.0057)  time: 0.6145  data: 0.0077  max mem: 5345\n",
-            "Epoch: [7]  [30/60]  eta: 0:00:19  lr: 0.000050  loss: 0.1424 (0.1498)  loss_classifier: 0.0211 (0.0213)  loss_box_reg: 0.0081 (0.0087)  loss_mask: 0.1076 (0.1126)  loss_objectness: 0.0005 (0.0008)  loss_rpn_box_reg: 0.0058 (0.0065)  time: 0.6514  data: 0.0081  max mem: 5370\n",
-            "Epoch: [7]  [40/60]  eta: 0:00:12  lr: 0.000050  loss: 0.1435 (0.1523)  loss_classifier: 0.0230 (0.0232)  loss_box_reg: 0.0090 (0.0091)  loss_mask: 0.1069 (0.1127)  loss_objectness: 0.0004 (0.0007)  loss_rpn_box_reg: 0.0057 (0.0065)  time: 0.6590  data: 0.0071  max mem: 5370\n",
-            "Epoch: [7]  [50/60]  eta: 0:00:06  lr: 0.000050  loss: 0.1519 (0.1545)  loss_classifier: 0.0251 (0.0239)  loss_box_reg: 0.0092 (0.0099)  loss_mask: 0.1141 (0.1131)  loss_objectness: 0.0003 (0.0007)  loss_rpn_box_reg: 0.0056 (0.0069)  time: 0.6489  data: 0.0068  max mem: 5370\n",
-            "Epoch: [7]  [59/60]  eta: 0:00:00  lr: 0.000050  loss: 0.1533 (0.1590)  loss_classifier: 0.0280 (0.0257)  loss_box_reg: 0.0101 (0.0109)  loss_mask: 0.1141 (0.1143)  loss_objectness: 0.0003 (0.0008)  loss_rpn_box_reg: 0.0084 (0.0073)  time: 0.6595  data: 0.0072  max mem: 5370\n",
-            "Epoch: [7] Total time: 0:00:38 (0.6479 s / it)\n",
-            "creating index...\n",
-            "index created!\n",
-            "Test:  [ 0/50]  eta: 0:00:18  model_time: 0.1607 (0.1607)  evaluator_time: 0.0041 (0.0041)  time: 0.3618  data: 0.1955  max mem: 5370\n",
-            "Test:  [49/50]  eta: 0:00:00  model_time: 0.1134 (0.1118)  evaluator_time: 0.0037 (0.0058)  time: 0.1218  data: 0.0036  max mem: 5370\n",
-            "Test: Total time: 0:00:06 (0.1283 s / it)\n",
-            "Averaged stats: model_time: 0.1134 (0.1118)  evaluator_time: 0.0037 (0.0058)\n",
-            "Accumulating evaluation results...\n",
-            "DONE (t=0.01s).\n",
-            "Accumulating evaluation results...\n",
-            "DONE (t=0.01s).\n",
-            "IoU metric: bbox\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.821\n",
-            " Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.990\n",
-            " Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.960\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = -1.000\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.596\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.832\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] = 0.380\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] = 0.862\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.862\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = -1.000\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.787\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.868\n",
-            "IoU metric: segm\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.768\n",
-            " Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.990\n",
-            " Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.917\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = -1.000\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.464\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.776\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] = 0.350\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] = 0.809\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.809\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = -1.000\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.762\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.813\n",
-            "Epoch: [8]  [ 0/60]  eta: 0:00:56  lr: 0.000050  loss: 0.1368 (0.1368)  loss_classifier: 0.0151 (0.0151)  loss_box_reg: 0.0078 (0.0078)  loss_mask: 0.1098 (0.1098)  loss_objectness: 0.0004 (0.0004)  loss_rpn_box_reg: 0.0038 (0.0038)  time: 0.9355  data: 0.2996  max mem: 5370\n",
-            "Epoch: [8]  [10/60]  eta: 0:00:31  lr: 0.000050  loss: 0.1555 (0.1604)  loss_classifier: 0.0233 (0.0258)  loss_box_reg: 0.0086 (0.0107)  loss_mask: 0.1098 (0.1175)  loss_objectness: 0.0002 (0.0003)  loss_rpn_box_reg: 0.0047 (0.0061)  time: 0.6251  data: 0.0334  max mem: 5370\n",
-            "Epoch: [8]  [20/60]  eta: 0:00:25  lr: 0.000050  loss: 0.1418 (0.1505)  loss_classifier: 0.0192 (0.0216)  loss_box_reg: 0.0067 (0.0087)  loss_mask: 0.1037 (0.1131)  loss_objectness: 0.0002 (0.0004)  loss_rpn_box_reg: 0.0054 (0.0068)  time: 0.6100  data: 0.0068  max mem: 5370\n",
-            "Epoch: [8]  [30/60]  eta: 0:00:19  lr: 0.000050  loss: 0.1427 (0.1506)  loss_classifier: 0.0195 (0.0224)  loss_box_reg: 0.0062 (0.0088)  loss_mask: 0.1037 (0.1120)  loss_objectness: 0.0003 (0.0004)  loss_rpn_box_reg: 0.0065 (0.0070)  time: 0.6461  data: 0.0068  max mem: 5370\n",
-            "Epoch: [8]  [40/60]  eta: 0:00:12  lr: 0.000050  loss: 0.1516 (0.1536)  loss_classifier: 0.0240 (0.0236)  loss_box_reg: 0.0096 (0.0103)  loss_mask: 0.1037 (0.1117)  loss_objectness: 0.0003 (0.0006)  loss_rpn_box_reg: 0.0072 (0.0074)  time: 0.6651  data: 0.0068  max mem: 5370\n",
-            "Epoch: [8]  [50/60]  eta: 0:00:06  lr: 0.000050  loss: 0.1570 (0.1595)  loss_classifier: 0.0253 (0.0244)  loss_box_reg: 0.0110 (0.0114)  loss_mask: 0.1060 (0.1156)  loss_objectness: 0.0003 (0.0006)  loss_rpn_box_reg: 0.0074 (0.0074)  time: 0.6429  data: 0.0067  max mem: 5370\n",
-            "Epoch: [8]  [59/60]  eta: 0:00:00  lr: 0.000050  loss: 0.1545 (0.1596)  loss_classifier: 0.0253 (0.0247)  loss_box_reg: 0.0092 (0.0111)  loss_mask: 0.1118 (0.1157)  loss_objectness: 0.0003 (0.0007)  loss_rpn_box_reg: 0.0074 (0.0074)  time: 0.6498  data: 0.0066  max mem: 5370\n",
-            "Epoch: [8] Total time: 0:00:38 (0.6474 s / it)\n",
-            "creating index...\n",
-            "index created!\n",
-            "Test:  [ 0/50]  eta: 0:00:17  model_time: 0.1581 (0.1581)  evaluator_time: 0.0041 (0.0041)  time: 0.3566  data: 0.1928  max mem: 5370\n",
-            "Test:  [49/50]  eta: 0:00:00  model_time: 0.1125 (0.1125)  evaluator_time: 0.0036 (0.0058)  time: 0.1217  data: 0.0036  max mem: 5370\n",
-            "Test: Total time: 0:00:06 (0.1290 s / it)\n",
-            "Averaged stats: model_time: 0.1125 (0.1125)  evaluator_time: 0.0036 (0.0058)\n",
-            "Accumulating evaluation results...\n",
-            "DONE (t=0.01s).\n",
-            "Accumulating evaluation results...\n",
-            "DONE (t=0.01s).\n",
-            "IoU metric: bbox\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.826\n",
-            " Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.990\n",
-            " Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.960\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = -1.000\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.596\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.837\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] = 0.382\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] = 0.865\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.865\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = -1.000\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.787\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.870\n",
-            "IoU metric: segm\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.772\n",
-            " Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.990\n",
-            " Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.917\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = -1.000\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.458\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.782\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] = 0.352\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] = 0.812\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.812\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = -1.000\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.762\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.815\n",
-            "Epoch: [9]  [ 0/60]  eta: 0:00:52  lr: 0.000005  loss: 0.1495 (0.1495)  loss_classifier: 0.0158 (0.0158)  loss_box_reg: 0.0093 (0.0093)  loss_mask: 0.1086 (0.1086)  loss_objectness: 0.0054 (0.0054)  loss_rpn_box_reg: 0.0105 (0.0105)  time: 0.8829  data: 0.2796  max mem: 5370\n",
-            "Epoch: [9]  [10/60]  eta: 0:00:32  lr: 0.000005  loss: 0.1645 (0.1607)  loss_classifier: 0.0271 (0.0248)  loss_box_reg: 0.0093 (0.0111)  loss_mask: 0.1086 (0.1156)  loss_objectness: 0.0007 (0.0020)  loss_rpn_box_reg: 0.0077 (0.0072)  time: 0.6560  data: 0.0323  max mem: 5370\n",
-            "Epoch: [9]  [20/60]  eta: 0:00:25  lr: 0.000005  loss: 0.1444 (0.1535)  loss_classifier: 0.0218 (0.0224)  loss_box_reg: 0.0078 (0.0095)  loss_mask: 0.1078 (0.1142)  loss_objectness: 0.0004 (0.0013)  loss_rpn_box_reg: 0.0036 (0.0060)  time: 0.6136  data: 0.0072  max mem: 5370\n",
-            "Epoch: [9]  [30/60]  eta: 0:00:18  lr: 0.000005  loss: 0.1361 (0.1559)  loss_classifier: 0.0218 (0.0234)  loss_box_reg: 0.0078 (0.0101)  loss_mask: 0.1026 (0.1149)  loss_objectness: 0.0004 (0.0010)  loss_rpn_box_reg: 0.0052 (0.0065)  time: 0.6150  data: 0.0069  max mem: 5370\n",
-            "Epoch: [9]  [40/60]  eta: 0:00:12  lr: 0.000005  loss: 0.1613 (0.1622)  loss_classifier: 0.0243 (0.0252)  loss_box_reg: 0.0092 (0.0118)  loss_mask: 0.1054 (0.1169)  loss_objectness: 0.0003 (0.0010)  loss_rpn_box_reg: 0.0072 (0.0075)  time: 0.6652  data: 0.0075  max mem: 5370\n",
-            "Epoch: [9]  [50/60]  eta: 0:00:06  lr: 0.000005  loss: 0.1473 (0.1602)  loss_classifier: 0.0232 (0.0251)  loss_box_reg: 0.0084 (0.0116)  loss_mask: 0.1102 (0.1151)  loss_objectness: 0.0004 (0.0009)  loss_rpn_box_reg: 0.0070 (0.0075)  time: 0.6760  data: 0.0074  max mem: 5370\n",
-            "Epoch: [9]  [59/60]  eta: 0:00:00  lr: 0.000005  loss: 0.1391 (0.1572)  loss_classifier: 0.0203 (0.0244)  loss_box_reg: 0.0067 (0.0109)  loss_mask: 0.1049 (0.1136)  loss_objectness: 0.0004 (0.0010)  loss_rpn_box_reg: 0.0066 (0.0072)  time: 0.6440  data: 0.0068  max mem: 5370\n",
-            "Epoch: [9] Total time: 0:00:38 (0.6447 s / it)\n",
-            "creating index...\n",
-            "index created!\n",
-            "Test:  [ 0/50]  eta: 0:00:17  model_time: 0.1590 (0.1590)  evaluator_time: 0.0039 (0.0039)  time: 0.3443  data: 0.1797  max mem: 5370\n",
-            "Test:  [49/50]  eta: 0:00:00  model_time: 0.1123 (0.1119)  evaluator_time: 0.0035 (0.0057)  time: 0.1212  data: 0.0034  max mem: 5370\n",
-            "Test: Total time: 0:00:06 (0.1280 s / it)\n",
-            "Averaged stats: model_time: 0.1123 (0.1119)  evaluator_time: 0.0035 (0.0057)\n",
-            "Accumulating evaluation results...\n",
-            "DONE (t=0.01s).\n",
-            "Accumulating evaluation results...\n",
-            "DONE (t=0.01s).\n",
-            "IoU metric: bbox\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.828\n",
-            " Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.990\n",
-            " Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.960\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = -1.000\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.596\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.839\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] = 0.382\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] = 0.867\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.867\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = -1.000\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.787\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.873\n",
-            "IoU metric: segm\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.771\n",
-            " Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.990\n",
-            " Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.917\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = -1.000\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.458\n",
-            " Average Precision  (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.780\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] = 0.351\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] = 0.811\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.811\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = -1.000\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.762\n",
-            " Average Recall     (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.814\n"
-          ],
-          "name": "stdout"
-        }
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "Z6mYGFLxkO8F",
-        "colab_type": "text"
-      },
-      "source": [
-        "Now that training has finished, let's have a look at what it actually predicts in a test image"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "YHwIdxH76uPj",
-        "colab_type": "code",
-        "colab": {}
-      },
-      "source": [
-        "# pick one image from the test set\n",
-        "img, _ = dataset_test[0]\n",
-        "# put the model in evaluation mode\n",
-        "model.eval()\n",
-        "with torch.no_grad():\n",
-        "    prediction = model([img.to(device)])"
-      ],
-      "execution_count": 0,
-      "outputs": []
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "DmN602iKsuey",
-        "colab_type": "text"
-      },
-      "source": [
-        "Printing the prediction shows that we have a list of dictionaries. Each element of the list corresponds to a different image. As we have a single image, there is a single dictionary in the list.\n",
-        "The dictionary contains the predictions for the image we passed. In this case, we can see that it contains `boxes`, `labels`, `masks` and `scores` as fields."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "Lkmb3qUu6zw3",
-        "colab_type": "code",
-        "outputId": "fe5616ea-7e27-4a29-d070-358bee6a1be8",
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 527
-        }
-      },
-      "source": [
-        "prediction"
-      ],
-      "execution_count": 0,
-      "outputs": [
-        {
-          "output_type": "execute_result",
-          "data": {
-            "text/plain": [
-              "[{'boxes': tensor([[ 61.6491,  35.3001, 197.0657, 327.6245],\n",
-              "          [276.3604,  21.6470, 291.0668,  73.5886],\n",
-              "          [ 78.8921,  43.7346, 201.9858, 207.4100]], device='cuda:0'),\n",
-              "  'labels': tensor([1, 1, 1], device='cuda:0'),\n",
-              "  'masks': tensor([[[[0., 0., 0.,  ..., 0., 0., 0.],\n",
-              "            [0., 0., 0.,  ..., 0., 0., 0.],\n",
-              "            [0., 0., 0.,  ..., 0., 0., 0.],\n",
-              "            ...,\n",
-              "            [0., 0., 0.,  ..., 0., 0., 0.],\n",
-              "            [0., 0., 0.,  ..., 0., 0., 0.],\n",
-              "            [0., 0., 0.,  ..., 0., 0., 0.]]],\n",
-              "  \n",
-              "  \n",
-              "          [[[0., 0., 0.,  ..., 0., 0., 0.],\n",
-              "            [0., 0., 0.,  ..., 0., 0., 0.],\n",
-              "            [0., 0., 0.,  ..., 0., 0., 0.],\n",
-              "            ...,\n",
-              "            [0., 0., 0.,  ..., 0., 0., 0.],\n",
-              "            [0., 0., 0.,  ..., 0., 0., 0.],\n",
-              "            [0., 0., 0.,  ..., 0., 0., 0.]]],\n",
-              "  \n",
-              "  \n",
-              "          [[[0., 0., 0.,  ..., 0., 0., 0.],\n",
-              "            [0., 0., 0.,  ..., 0., 0., 0.],\n",
-              "            [0., 0., 0.,  ..., 0., 0., 0.],\n",
-              "            ...,\n",
-              "            [0., 0., 0.,  ..., 0., 0., 0.],\n",
-              "            [0., 0., 0.,  ..., 0., 0., 0.],\n",
-              "            [0., 0., 0.,  ..., 0., 0., 0.]]]], device='cuda:0'),\n",
-              "  'scores': tensor([0.9995, 0.8236, 0.0713], device='cuda:0')}]"
-            ]
-          },
-          "metadata": {
-            "tags": []
-          },
-          "execution_count": 14
-        }
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "RwT21rzotFbH",
-        "colab_type": "text"
-      },
-      "source": [
-        "Let's inspect the image and the predicted segmentation masks.\n",
-        "\n",
-        "For that, we need to convert the image, which has been rescaled to 0-1 and had the channels flipped so that we have it in `[C, H, W]` format."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "bpqN9t1u7B2J",
-        "colab_type": "code",
-        "outputId": "13b60c23-dce3-4a0c-fdf0-54eae39e5cc6",
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 366
-        }
-      },
-      "source": [
-        "Image.fromarray(img.mul(255).permute(1, 2, 0).byte().numpy())"
-      ],
-      "execution_count": 0,
-      "outputs": [
-        {
-          "output_type": "execute_result",
-          "data": {
-            "image/png": "iVBORw0KGgoAAAANSUhEUgAAASQAAAFdCAIAAAAltoeyAAEAAElEQVR4nKT9WY8kS5YeCJ5FRBdb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\nRavk3/bijfwCTrIMA7Tw0I0xeZ7/fyQiwhh406bpAAAAAElFTkSuQmCC\n",
-            "text/plain": [
-              "<PIL.Image.Image image mode=RGB size=292x349 at 0x7F9E865FA0F0>"
-            ]
-          },
-          "metadata": {
-            "tags": []
-          },
-          "execution_count": 15
-        }
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "M58J3O9OtT1G",
-        "colab_type": "text"
-      },
-      "source": [
-        "And let's now visualize the top predicted segmentation mask. The masks are predicted as `[N, 1, H, W]`, where `N` is the number of predictions, and are probability maps between 0-1."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {
-        "id": "5v5S3bm07SO1",
-        "colab_type": "code",
-        "outputId": "502433ff-ac0d-4388-d79c-1d94cf26dc38",
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 366
-        }
-      },
-      "source": [
-        "Image.fromarray(prediction[0]['masks'][0, 0].mul(255).byte().cpu().numpy())"
-      ],
-      "execution_count": 0,
-      "outputs": [
-        {
-          "output_type": "execute_result",
-          "data": {
-            "image/png": "iVBORw0KGgoAAAANSUhEUgAAASQAAAFdCAAAAACPv085AAAqs0lEQVR4nO1daXsTyc6VVEtXL7YT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\nwz7swz7swz7swz7swz7swz7swz7se/t/2Uw49KD+rS4AAAAASUVORK5CYII=\n",
-            "text/plain": [
-              "<PIL.Image.Image image mode=L size=292x349 at 0x7F9EDDF1AF60>"
-            ]
-          },
-          "metadata": {
-            "tags": []
-          },
-          "execution_count": 19
-        }
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "0EZCVtCPunrT",
-        "colab_type": "text"
-      },
-      "source": [
-        "Looks pretty good!\n",
-        "\n",
-        "## Wrapping up\n",
-        "\n",
-        "In this tutorial, you have learned how to create your own training pipeline for instance segmentation models, on a custom dataset.\n",
-        "For that, you wrote a `torch.utils.data.Dataset` class that returns the images and the ground truth boxes and segmentation masks. You also leveraged a Mask R-CNN model pre-trained on COCO train2017 in order to perform transfer learning on this new dataset.\n",
-        "\n",
-        "For a more complete example, which includes multi-machine / multi-gpu training, check `references/detection/train.py`, which is present in the [torchvision GitHub repo](https://github.com/pytorch/vision/tree/v0.3.0/references/detection). \n",
-        "\n"
-      ]
-    }
-  ]
-}
\ No newline at end of file
diff --git a/_static/tv-training-code.py b/_static/tv-training-code.py
deleted file mode 100644
index 116e9bdd20d..00000000000
--- a/_static/tv-training-code.py
+++ /dev/null
@@ -1,165 +0,0 @@
-# Sample code from the TorchVision 0.3 Object Detection Finetuning Tutorial
-# http://pytorch.org/tutorials/intermediate/torchvision_tutorial.html
-
-import os
-import numpy as np
-import torch
-from PIL import Image
-
-import torchvision
-from torchvision.models.detection.faster_rcnn import FastRCNNPredictor
-from torchvision.models.detection.mask_rcnn import MaskRCNNPredictor
-
-from engine import train_one_epoch, evaluate
-import utils
-import transforms as T
-
-
-class PennFudanDataset(object):
-    def __init__(self, root, transforms):
-        self.root = root
-        self.transforms = transforms
-        # load all image files, sorting them to
-        # ensure that they are aligned
-        self.imgs = list(sorted(os.listdir(os.path.join(root, "PNGImages"))))
-        self.masks = list(sorted(os.listdir(os.path.join(root, "PedMasks"))))
-
-    def __getitem__(self, idx):
-        # load images ad masks
-        img_path = os.path.join(self.root, "PNGImages", self.imgs[idx])
-        mask_path = os.path.join(self.root, "PedMasks", self.masks[idx])
-        img = Image.open(img_path).convert("RGB")
-        # note that we haven't converted the mask to RGB,
-        # because each color corresponds to a different instance
-        # with 0 being background
-        mask = Image.open(mask_path)
-
-        mask = np.array(mask)
-        # instances are encoded as different colors
-        obj_ids = np.unique(mask)
-        # first id is the background, so remove it
-        obj_ids = obj_ids[1:]
-
-        # split the color-encoded mask into a set
-        # of binary masks
-        masks = mask == obj_ids[:, None, None]
-
-        # get bounding box coordinates for each mask
-        num_objs = len(obj_ids)
-        boxes = []
-        for i in range(num_objs):
-            pos = np.where(masks[i])
-            xmin = np.min(pos[1])
-            xmax = np.max(pos[1])
-            ymin = np.min(pos[0])
-            ymax = np.max(pos[0])
-            boxes.append([xmin, ymin, xmax, ymax])
-
-        boxes = torch.as_tensor(boxes, dtype=torch.float32)
-        # there is only one class
-        labels = torch.ones((num_objs,), dtype=torch.int64)
-        masks = torch.as_tensor(masks, dtype=torch.uint8)
-
-        image_id = torch.tensor([idx])
-        area = (boxes[:, 3] - boxes[:, 1]) * (boxes[:, 2] - boxes[:, 0])
-        # suppose all instances are not crowd
-        iscrowd = torch.zeros((num_objs,), dtype=torch.int64)
-
-        target = {}
-        target["boxes"] = boxes
-        target["labels"] = labels
-        target["masks"] = masks
-        target["image_id"] = image_id
-        target["area"] = area
-        target["iscrowd"] = iscrowd
-
-        if self.transforms is not None:
-            img, target = self.transforms(img, target)
-
-        return img, target
-
-    def __len__(self):
-        return len(self.imgs)
-
-def get_model_instance_segmentation(num_classes):
-    # load an instance segmentation model pre-trained pre-trained on COCO
-    model = torchvision.models.detection.maskrcnn_resnet50_fpn(pretrained=True)
-
-    # get number of input features for the classifier
-    in_features = model.roi_heads.box_predictor.cls_score.in_features
-    # replace the pre-trained head with a new one
-    model.roi_heads.box_predictor = FastRCNNPredictor(in_features, num_classes)
-
-    # now get the number of input features for the mask classifier
-    in_features_mask = model.roi_heads.mask_predictor.conv5_mask.in_channels
-    hidden_layer = 256
-    # and replace the mask predictor with a new one
-    model.roi_heads.mask_predictor = MaskRCNNPredictor(in_features_mask,
-                                                       hidden_layer,
-                                                       num_classes)
-
-    return model
-
-
-def get_transform(train):
-    transforms = []
-    transforms.append(T.ToTensor())
-    if train:
-        transforms.append(T.RandomHorizontalFlip(0.5))
-    return T.Compose(transforms)
-
-
-def main():
-    # train on the GPU or on the CPU, if a GPU is not available
-    device = torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu')
-
-    # our dataset has two classes only - background and person
-    num_classes = 2
-    # use our dataset and defined transformations
-    dataset = PennFudanDataset('PennFudanPed', get_transform(train=True))
-    dataset_test = PennFudanDataset('PennFudanPed', get_transform(train=False))
-
-    # split the dataset in train and test set
-    indices = torch.randperm(len(dataset)).tolist()
-    dataset = torch.utils.data.Subset(dataset, indices[:-50])
-    dataset_test = torch.utils.data.Subset(dataset_test, indices[-50:])
-
-    # define training and validation data loaders
-    data_loader = torch.utils.data.DataLoader(
-        dataset, batch_size=2, shuffle=True, num_workers=4,
-        collate_fn=utils.collate_fn)
-
-    data_loader_test = torch.utils.data.DataLoader(
-        dataset_test, batch_size=1, shuffle=False, num_workers=4,
-        collate_fn=utils.collate_fn)
-
-    # get the model using our helper function
-    model = get_model_instance_segmentation(num_classes)
-
-    # move model to the right device
-    model.to(device)
-
-    # construct an optimizer
-    params = [p for p in model.parameters() if p.requires_grad]
-    optimizer = torch.optim.SGD(params, lr=0.005,
-                                momentum=0.9, weight_decay=0.0005)
-    # and a learning rate scheduler
-    lr_scheduler = torch.optim.lr_scheduler.StepLR(optimizer,
-                                                   step_size=3,
-                                                   gamma=0.1)
-
-    # let's train it for 10 epochs
-    num_epochs = 10
-
-    for epoch in range(num_epochs):
-        # train for one epoch, printing every 10 iterations
-        train_one_epoch(model, optimizer, data_loader, device, epoch, print_freq=10)
-        # update the learning rate
-        lr_scheduler.step()
-        # evaluate on the test dataset
-        evaluate(model, data_loader_test, device=device)
-
-    print("That's it!")
-    
-if __name__ == "__main__":
-    main()
diff --git a/_static/underscore-1.3.1.js b/_static/underscore-1.3.1.js
deleted file mode 100755
index 4717b8c71ee..00000000000
--- a/_static/underscore-1.3.1.js
+++ /dev/null
@@ -1,999 +0,0 @@
-//     Underscore.js 1.3.1
-//     (c) 2009-2012 Jeremy Ashkenas, DocumentCloud Inc.
-//     Underscore is freely distributable under the MIT license.
-//     Portions of Underscore are inspired or borrowed from Prototype,
-//     Oliver Steele's Functional, and John Resig's Micro-Templating.
-//     For all details and documentation:
-//     https://documentcloud.github.com/underscore
-
-(function() {
-
-  // Baseline setup
-  // --------------
-
-  // Establish the root object, `window` in the browser, or `global` on the server.
-  var root = this;
-
-  // Save the previous value of the `_` variable.
-  var previousUnderscore = root._;
-
-  // Establish the object that gets returned to break out of a loop iteration.
-  var breaker = {};
-
-  // Save bytes in the minified (but not gzipped) version:
-  var ArrayProto = Array.prototype, ObjProto = Object.prototype, FuncProto = Function.prototype;
-
-  // Create quick reference variables for speed access to core prototypes.
-  var slice            = ArrayProto.slice,
-      unshift          = ArrayProto.unshift,
-      toString         = ObjProto.toString,
-      hasOwnProperty   = ObjProto.hasOwnProperty;
-
-  // All **ECMAScript 5** native function implementations that we hope to use
-  // are declared here.
-  var
-    nativeForEach      = ArrayProto.forEach,
-    nativeMap          = ArrayProto.map,
-    nativeReduce       = ArrayProto.reduce,
-    nativeReduceRight  = ArrayProto.reduceRight,
-    nativeFilter       = ArrayProto.filter,
-    nativeEvery        = ArrayProto.every,
-    nativeSome         = ArrayProto.some,
-    nativeIndexOf      = ArrayProto.indexOf,
-    nativeLastIndexOf  = ArrayProto.lastIndexOf,
-    nativeIsArray      = Array.isArray,
-    nativeKeys         = Object.keys,
-    nativeBind         = FuncProto.bind;
-
-  // Create a safe reference to the Underscore object for use below.
-  var _ = function(obj) { return new wrapper(obj); };
-
-  // Export the Underscore object for **Node.js**, with
-  // backwards-compatibility for the old `require()` API. If we're in
-  // the browser, add `_` as a global object via a string identifier,
-  // for Closure Compiler "advanced" mode.
-  if (typeof exports !== 'undefined') {
-    if (typeof module !== 'undefined' && module.exports) {
-      exports = module.exports = _;
-    }
-    exports._ = _;
-  } else {
-    root['_'] = _;
-  }
-
-  // Current version.
-  _.VERSION = '1.3.1';
-
-  // Collection Functions
-  // --------------------
-
-  // The cornerstone, an `each` implementation, aka `forEach`.
-  // Handles objects with the built-in `forEach`, arrays, and raw objects.
-  // Delegates to **ECMAScript 5**'s native `forEach` if available.
-  var each = _.each = _.forEach = function(obj, iterator, context) {
-    if (obj == null) return;
-    if (nativeForEach && obj.forEach === nativeForEach) {
-      obj.forEach(iterator, context);
-    } else if (obj.length === +obj.length) {
-      for (var i = 0, l = obj.length; i < l; i++) {
-        if (i in obj && iterator.call(context, obj[i], i, obj) === breaker) return;
-      }
-    } else {
-      for (var key in obj) {
-        if (_.has(obj, key)) {
-          if (iterator.call(context, obj[key], key, obj) === breaker) return;
-        }
-      }
-    }
-  };
-
-  // Return the results of applying the iterator to each element.
-  // Delegates to **ECMAScript 5**'s native `map` if available.
-  _.map = _.collect = function(obj, iterator, context) {
-    var results = [];
-    if (obj == null) return results;
-    if (nativeMap && obj.map === nativeMap) return obj.map(iterator, context);
-    each(obj, function(value, index, list) {
-      results[results.length] = iterator.call(context, value, index, list);
-    });
-    if (obj.length === +obj.length) results.length = obj.length;
-    return results;
-  };
-
-  // **Reduce** builds up a single result from a list of values, aka `inject`,
-  // or `foldl`. Delegates to **ECMAScript 5**'s native `reduce` if available.
-  _.reduce = _.foldl = _.inject = function(obj, iterator, memo, context) {
-    var initial = arguments.length > 2;
-    if (obj == null) obj = [];
-    if (nativeReduce && obj.reduce === nativeReduce) {
-      if (context) iterator = _.bind(iterator, context);
-      return initial ? obj.reduce(iterator, memo) : obj.reduce(iterator);
-    }
-    each(obj, function(value, index, list) {
-      if (!initial) {
-        memo = value;
-        initial = true;
-      } else {
-        memo = iterator.call(context, memo, value, index, list);
-      }
-    });
-    if (!initial) throw new TypeError('Reduce of empty array with no initial value');
-    return memo;
-  };
-
-  // The right-associative version of reduce, also known as `foldr`.
-  // Delegates to **ECMAScript 5**'s native `reduceRight` if available.
-  _.reduceRight = _.foldr = function(obj, iterator, memo, context) {
-    var initial = arguments.length > 2;
-    if (obj == null) obj = [];
-    if (nativeReduceRight && obj.reduceRight === nativeReduceRight) {
-      if (context) iterator = _.bind(iterator, context);
-      return initial ? obj.reduceRight(iterator, memo) : obj.reduceRight(iterator);
-    }
-    var reversed = _.toArray(obj).reverse();
-    if (context && !initial) iterator = _.bind(iterator, context);
-    return initial ? _.reduce(reversed, iterator, memo, context) : _.reduce(reversed, iterator);
-  };
-
-  // Return the first value which passes a truth test. Aliased as `detect`.
-  _.find = _.detect = function(obj, iterator, context) {
-    var result;
-    any(obj, function(value, index, list) {
-      if (iterator.call(context, value, index, list)) {
-        result = value;
-        return true;
-      }
-    });
-    return result;
-  };
-
-  // Return all the elements that pass a truth test.
-  // Delegates to **ECMAScript 5**'s native `filter` if available.
-  // Aliased as `select`.
-  _.filter = _.select = function(obj, iterator, context) {
-    var results = [];
-    if (obj == null) return results;
-    if (nativeFilter && obj.filter === nativeFilter) return obj.filter(iterator, context);
-    each(obj, function(value, index, list) {
-      if (iterator.call(context, value, index, list)) results[results.length] = value;
-    });
-    return results;
-  };
-
-  // Return all the elements for which a truth test fails.
-  _.reject = function(obj, iterator, context) {
-    var results = [];
-    if (obj == null) return results;
-    each(obj, function(value, index, list) {
-      if (!iterator.call(context, value, index, list)) results[results.length] = value;
-    });
-    return results;
-  };
-
-  // Determine whether all of the elements match a truth test.
-  // Delegates to **ECMAScript 5**'s native `every` if available.
-  // Aliased as `all`.
-  _.every = _.all = function(obj, iterator, context) {
-    var result = true;
-    if (obj == null) return result;
-    if (nativeEvery && obj.every === nativeEvery) return obj.every(iterator, context);
-    each(obj, function(value, index, list) {
-      if (!(result = result && iterator.call(context, value, index, list))) return breaker;
-    });
-    return result;
-  };
-
-  // Determine if at least one element in the object matches a truth test.
-  // Delegates to **ECMAScript 5**'s native `some` if available.
-  // Aliased as `any`.
-  var any = _.some = _.any = function(obj, iterator, context) {
-    iterator || (iterator = _.identity);
-    var result = false;
-    if (obj == null) return result;
-    if (nativeSome && obj.some === nativeSome) return obj.some(iterator, context);
-    each(obj, function(value, index, list) {
-      if (result || (result = iterator.call(context, value, index, list))) return breaker;
-    });
-    return !!result;
-  };
-
-  // Determine if a given value is included in the array or object using `===`.
-  // Aliased as `contains`.
-  _.include = _.contains = function(obj, target) {
-    var found = false;
-    if (obj == null) return found;
-    if (nativeIndexOf && obj.indexOf === nativeIndexOf) return obj.indexOf(target) != -1;
-    found = any(obj, function(value) {
-      return value === target;
-    });
-    return found;
-  };
-
-  // Invoke a method (with arguments) on every item in a collection.
-  _.invoke = function(obj, method) {
-    var args = slice.call(arguments, 2);
-    return _.map(obj, function(value) {
-      return (_.isFunction(method) ? method || value : value[method]).apply(value, args);
-    });
-  };
-
-  // Convenience version of a common use case of `map`: fetching a property.
-  _.pluck = function(obj, key) {
-    return _.map(obj, function(value){ return value[key]; });
-  };
-
-  // Return the maximum element or (element-based computation).
-  _.max = function(obj, iterator, context) {
-    if (!iterator && _.isArray(obj)) return Math.max.apply(Math, obj);
-    if (!iterator && _.isEmpty(obj)) return -Infinity;
-    var result = {computed : -Infinity};
-    each(obj, function(value, index, list) {
-      var computed = iterator ? iterator.call(context, value, index, list) : value;
-      computed >= result.computed && (result = {value : value, computed : computed});
-    });
-    return result.value;
-  };
-
-  // Return the minimum element (or element-based computation).
-  _.min = function(obj, iterator, context) {
-    if (!iterator && _.isArray(obj)) return Math.min.apply(Math, obj);
-    if (!iterator && _.isEmpty(obj)) return Infinity;
-    var result = {computed : Infinity};
-    each(obj, function(value, index, list) {
-      var computed = iterator ? iterator.call(context, value, index, list) : value;
-      computed < result.computed && (result = {value : value, computed : computed});
-    });
-    return result.value;
-  };
-
-  // Shuffle an array.
-  _.shuffle = function(obj) {
-    var shuffled = [], rand;
-    each(obj, function(value, index, list) {
-      if (index == 0) {
-        shuffled[0] = value;
-      } else {
-        rand = Math.floor(Math.random() * (index + 1));
-        shuffled[index] = shuffled[rand];
-        shuffled[rand] = value;
-      }
-    });
-    return shuffled;
-  };
-
-  // Sort the object's values by a criterion produced by an iterator.
-  _.sortBy = function(obj, iterator, context) {
-    return _.pluck(_.map(obj, function(value, index, list) {
-      return {
-        value : value,
-        criteria : iterator.call(context, value, index, list)
-      };
-    }).sort(function(left, right) {
-      var a = left.criteria, b = right.criteria;
-      return a < b ? -1 : a > b ? 1 : 0;
-    }), 'value');
-  };
-
-  // Groups the object's values by a criterion. Pass either a string attribute
-  // to group by, or a function that returns the criterion.
-  _.groupBy = function(obj, val) {
-    var result = {};
-    var iterator = _.isFunction(val) ? val : function(obj) { return obj[val]; };
-    each(obj, function(value, index) {
-      var key = iterator(value, index);
-      (result[key] || (result[key] = [])).push(value);
-    });
-    return result;
-  };
-
-  // Use a comparator function to figure out at what index an object should
-  // be inserted so as to maintain order. Uses binary search.
-  _.sortedIndex = function(array, obj, iterator) {
-    iterator || (iterator = _.identity);
-    var low = 0, high = array.length;
-    while (low < high) {
-      var mid = (low + high) >> 1;
-      iterator(array[mid]) < iterator(obj) ? low = mid + 1 : high = mid;
-    }
-    return low;
-  };
-
-  // Safely convert anything iterable into a real, live array.
-  _.toArray = function(iterable) {
-    if (!iterable)                return [];
-    if (iterable.toArray)         return iterable.toArray();
-    if (_.isArray(iterable))      return slice.call(iterable);
-    if (_.isArguments(iterable))  return slice.call(iterable);
-    return _.values(iterable);
-  };
-
-  // Return the number of elements in an object.
-  _.size = function(obj) {
-    return _.toArray(obj).length;
-  };
-
-  // Array Functions
-  // ---------------
-
-  // Get the first element of an array. Passing **n** will return the first N
-  // values in the array. Aliased as `head`. The **guard** check allows it to work
-  // with `_.map`.
-  _.first = _.head = function(array, n, guard) {
-    return (n != null) && !guard ? slice.call(array, 0, n) : array[0];
-  };
-
-  // Returns everything but the last entry of the array. Especcialy useful on
-  // the arguments object. Passing **n** will return all the values in
-  // the array, excluding the last N. The **guard** check allows it to work with
-  // `_.map`.
-  _.initial = function(array, n, guard) {
-    return slice.call(array, 0, array.length - ((n == null) || guard ? 1 : n));
-  };
-
-  // Get the last element of an array. Passing **n** will return the last N
-  // values in the array. The **guard** check allows it to work with `_.map`.
-  _.last = function(array, n, guard) {
-    if ((n != null) && !guard) {
-      return slice.call(array, Math.max(array.length - n, 0));
-    } else {
-      return array[array.length - 1];
-    }
-  };
-
-  // Returns everything but the first entry of the array. Aliased as `tail`.
-  // Especially useful on the arguments object. Passing an **index** will return
-  // the rest of the values in the array from that index onward. The **guard**
-  // check allows it to work with `_.map`.
-  _.rest = _.tail = function(array, index, guard) {
-    return slice.call(array, (index == null) || guard ? 1 : index);
-  };
-
-  // Trim out all falsy values from an array.
-  _.compact = function(array) {
-    return _.filter(array, function(value){ return !!value; });
-  };
-
-  // Return a completely flattened version of an array.
-  _.flatten = function(array, shallow) {
-    return _.reduce(array, function(memo, value) {
-      if (_.isArray(value)) return memo.concat(shallow ? value : _.flatten(value));
-      memo[memo.length] = value;
-      return memo;
-    }, []);
-  };
-
-  // Return a version of the array that does not contain the specified value(s).
-  _.without = function(array) {
-    return _.difference(array, slice.call(arguments, 1));
-  };
-
-  // Produce a duplicate-free version of the array. If the array has already
-  // been sorted, you have the option of using a faster algorithm.
-  // Aliased as `unique`.
-  _.uniq = _.unique = function(array, isSorted, iterator) {
-    var initial = iterator ? _.map(array, iterator) : array;
-    var result = [];
-    _.reduce(initial, function(memo, el, i) {
-      if (0 == i || (isSorted === true ? _.last(memo) != el : !_.include(memo, el))) {
-        memo[memo.length] = el;
-        result[result.length] = array[i];
-      }
-      return memo;
-    }, []);
-    return result;
-  };
-
-  // Produce an array that contains the union: each distinct element from all of
-  // the passed-in arrays.
-  _.union = function() {
-    return _.uniq(_.flatten(arguments, true));
-  };
-
-  // Produce an array that contains every item shared between all the
-  // passed-in arrays. (Aliased as "intersect" for back-compat.)
-  _.intersection = _.intersect = function(array) {
-    var rest = slice.call(arguments, 1);
-    return _.filter(_.uniq(array), function(item) {
-      return _.every(rest, function(other) {
-        return _.indexOf(other, item) >= 0;
-      });
-    });
-  };
-
-  // Take the difference between one array and a number of other arrays.
-  // Only the elements present in just the first array will remain.
-  _.difference = function(array) {
-    var rest = _.flatten(slice.call(arguments, 1));
-    return _.filter(array, function(value){ return !_.include(rest, value); });
-  };
-
-  // Zip together multiple lists into a single array -- elements that share
-  // an index go together.
-  _.zip = function() {
-    var args = slice.call(arguments);
-    var length = _.max(_.pluck(args, 'length'));
-    var results = new Array(length);
-    for (var i = 0; i < length; i++) results[i] = _.pluck(args, "" + i);
-    return results;
-  };
-
-  // If the browser doesn't supply us with indexOf (I'm looking at you, **MSIE**),
-  // we need this function. Return the position of the first occurrence of an
-  // item in an array, or -1 if the item is not included in the array.
-  // Delegates to **ECMAScript 5**'s native `indexOf` if available.
-  // If the array is large and already in sort order, pass `true`
-  // for **isSorted** to use binary search.
-  _.indexOf = function(array, item, isSorted) {
-    if (array == null) return -1;
-    var i, l;
-    if (isSorted) {
-      i = _.sortedIndex(array, item);
-      return array[i] === item ? i : -1;
-    }
-    if (nativeIndexOf && array.indexOf === nativeIndexOf) return array.indexOf(item);
-    for (i = 0, l = array.length; i < l; i++) if (i in array && array[i] === item) return i;
-    return -1;
-  };
-
-  // Delegates to **ECMAScript 5**'s native `lastIndexOf` if available.
-  _.lastIndexOf = function(array, item) {
-    if (array == null) return -1;
-    if (nativeLastIndexOf && array.lastIndexOf === nativeLastIndexOf) return array.lastIndexOf(item);
-    var i = array.length;
-    while (i--) if (i in array && array[i] === item) return i;
-    return -1;
-  };
-
-  // Generate an integer Array containing an arithmetic progression. A port of
-  // the native Python `range()` function. See
-  // [the Python documentation](https://docs.python.org/library/functions.html#range).
-  _.range = function(start, stop, step) {
-    if (arguments.length <= 1) {
-      stop = start || 0;
-      start = 0;
-    }
-    step = arguments[2] || 1;
-
-    var len = Math.max(Math.ceil((stop - start) / step), 0);
-    var idx = 0;
-    var range = new Array(len);
-
-    while(idx < len) {
-      range[idx++] = start;
-      start += step;
-    }
-
-    return range;
-  };
-
-  // Function (ahem) Functions
-  // ------------------
-
-  // Reusable constructor function for prototype setting.
-  var ctor = function(){};
-
-  // Create a function bound to a given object (assigning `this`, and arguments,
-  // optionally). Binding with arguments is also known as `curry`.
-  // Delegates to **ECMAScript 5**'s native `Function.bind` if available.
-  // We check for `func.bind` first, to fail fast when `func` is undefined.
-  _.bind = function bind(func, context) {
-    var bound, args;
-    if (func.bind === nativeBind && nativeBind) return nativeBind.apply(func, slice.call(arguments, 1));
-    if (!_.isFunction(func)) throw new TypeError;
-    args = slice.call(arguments, 2);
-    return bound = function() {
-      if (!(this instanceof bound)) return func.apply(context, args.concat(slice.call(arguments)));
-      ctor.prototype = func.prototype;
-      var self = new ctor;
-      var result = func.apply(self, args.concat(slice.call(arguments)));
-      if (Object(result) === result) return result;
-      return self;
-    };
-  };
-
-  // Bind all of an object's methods to that object. Useful for ensuring that
-  // all callbacks defined on an object belong to it.
-  _.bindAll = function(obj) {
-    var funcs = slice.call(arguments, 1);
-    if (funcs.length == 0) funcs = _.functions(obj);
-    each(funcs, function(f) { obj[f] = _.bind(obj[f], obj); });
-    return obj;
-  };
-
-  // Memoize an expensive function by storing its results.
-  _.memoize = function(func, hasher) {
-    var memo = {};
-    hasher || (hasher = _.identity);
-    return function() {
-      var key = hasher.apply(this, arguments);
-      return _.has(memo, key) ? memo[key] : (memo[key] = func.apply(this, arguments));
-    };
-  };
-
-  // Delays a function for the given number of milliseconds, and then calls
-  // it with the arguments supplied.
-  _.delay = function(func, wait) {
-    var args = slice.call(arguments, 2);
-    return setTimeout(function(){ return func.apply(func, args); }, wait);
-  };
-
-  // Defers a function, scheduling it to run after the current call stack has
-  // cleared.
-  _.defer = function(func) {
-    return _.delay.apply(_, [func, 1].concat(slice.call(arguments, 1)));
-  };
-
-  // Returns a function, that, when invoked, will only be triggered at most once
-  // during a given window of time.
-  _.throttle = function(func, wait) {
-    var context, args, timeout, throttling, more;
-    var whenDone = _.debounce(function(){ more = throttling = false; }, wait);
-    return function() {
-      context = this; args = arguments;
-      var later = function() {
-        timeout = null;
-        if (more) func.apply(context, args);
-        whenDone();
-      };
-      if (!timeout) timeout = setTimeout(later, wait);
-      if (throttling) {
-        more = true;
-      } else {
-        func.apply(context, args);
-      }
-      whenDone();
-      throttling = true;
-    };
-  };
-
-  // Returns a function, that, as long as it continues to be invoked, will not
-  // be triggered. The function will be called after it stops being called for
-  // N milliseconds.
-  _.debounce = function(func, wait) {
-    var timeout;
-    return function() {
-      var context = this, args = arguments;
-      var later = function() {
-        timeout = null;
-        func.apply(context, args);
-      };
-      clearTimeout(timeout);
-      timeout = setTimeout(later, wait);
-    };
-  };
-
-  // Returns a function that will be executed at most one time, no matter how
-  // often you call it. Useful for lazy initialization.
-  _.once = function(func) {
-    var ran = false, memo;
-    return function() {
-      if (ran) return memo;
-      ran = true;
-      return memo = func.apply(this, arguments);
-    };
-  };
-
-  // Returns the first function passed as an argument to the second,
-  // allowing you to adjust arguments, run code before and after, and
-  // conditionally execute the original function.
-  _.wrap = function(func, wrapper) {
-    return function() {
-      var args = [func].concat(slice.call(arguments, 0));
-      return wrapper.apply(this, args);
-    };
-  };
-
-  // Returns a function that is the composition of a list of functions, each
-  // consuming the return value of the function that follows.
-  _.compose = function() {
-    var funcs = arguments;
-    return function() {
-      var args = arguments;
-      for (var i = funcs.length - 1; i >= 0; i--) {
-        args = [funcs[i].apply(this, args)];
-      }
-      return args[0];
-    };
-  };
-
-  // Returns a function that will only be executed after being called N times.
-  _.after = function(times, func) {
-    if (times <= 0) return func();
-    return function() {
-      if (--times < 1) { return func.apply(this, arguments); }
-    };
-  };
-
-  // Object Functions
-  // ----------------
-
-  // Retrieve the names of an object's properties.
-  // Delegates to **ECMAScript 5**'s native `Object.keys`
-  _.keys = nativeKeys || function(obj) {
-    if (obj !== Object(obj)) throw new TypeError('Invalid object');
-    var keys = [];
-    for (var key in obj) if (_.has(obj, key)) keys[keys.length] = key;
-    return keys;
-  };
-
-  // Retrieve the values of an object's properties.
-  _.values = function(obj) {
-    return _.map(obj, _.identity);
-  };
-
-  // Return a sorted list of the function names available on the object.
-  // Aliased as `methods`
-  _.functions = _.methods = function(obj) {
-    var names = [];
-    for (var key in obj) {
-      if (_.isFunction(obj[key])) names.push(key);
-    }
-    return names.sort();
-  };
-
-  // Extend a given object with all the properties in passed-in object(s).
-  _.extend = function(obj) {
-    each(slice.call(arguments, 1), function(source) {
-      for (var prop in source) {
-        obj[prop] = source[prop];
-      }
-    });
-    return obj;
-  };
-
-  // Fill in a given object with default properties.
-  _.defaults = function(obj) {
-    each(slice.call(arguments, 1), function(source) {
-      for (var prop in source) {
-        if (obj[prop] == null) obj[prop] = source[prop];
-      }
-    });
-    return obj;
-  };
-
-  // Create a (shallow-cloned) duplicate of an object.
-  _.clone = function(obj) {
-    if (!_.isObject(obj)) return obj;
-    return _.isArray(obj) ? obj.slice() : _.extend({}, obj);
-  };
-
-  // Invokes interceptor with the obj, and then returns obj.
-  // The primary purpose of this method is to "tap into" a method chain, in
-  // order to perform operations on intermediate results within the chain.
-  _.tap = function(obj, interceptor) {
-    interceptor(obj);
-    return obj;
-  };
-
-  // Internal recursive comparison function.
-  function eq(a, b, stack) {
-    // Identical objects are equal. `0 === -0`, but they aren't identical.
-    // See the Harmony `egal` proposal: https://wiki.ecmascript.org/doku.php?id=harmony:egal.
-    if (a === b) return a !== 0 || 1 / a == 1 / b;
-    // A strict comparison is necessary because `null == undefined`.
-    if (a == null || b == null) return a === b;
-    // Unwrap any wrapped objects.
-    if (a._chain) a = a._wrapped;
-    if (b._chain) b = b._wrapped;
-    // Invoke a custom `isEqual` method if one is provided.
-    if (a.isEqual && _.isFunction(a.isEqual)) return a.isEqual(b);
-    if (b.isEqual && _.isFunction(b.isEqual)) return b.isEqual(a);
-    // Compare `[[Class]]` names.
-    var className = toString.call(a);
-    if (className != toString.call(b)) return false;
-    switch (className) {
-      // Strings, numbers, dates, and booleans are compared by value.
-      case '[object String]':
-        // Primitives and their corresponding object wrappers are equivalent; thus, `"5"` is
-        // equivalent to `new String("5")`.
-        return a == String(b);
-      case '[object Number]':
-        // `NaN`s are equivalent, but non-reflexive. An `egal` comparison is performed for
-        // other numeric values.
-        return a != +a ? b != +b : (a == 0 ? 1 / a == 1 / b : a == +b);
-      case '[object Date]':
-      case '[object Boolean]':
-        // Coerce dates and booleans to numeric primitive values. Dates are compared by their
-        // millisecond representations. Note that invalid dates with millisecond representations
-        // of `NaN` are not equivalent.
-        return +a == +b;
-      // RegExps are compared by their source patterns and flags.
-      case '[object RegExp]':
-        return a.source == b.source &&
-               a.global == b.global &&
-               a.multiline == b.multiline &&
-               a.ignoreCase == b.ignoreCase;
-    }
-    if (typeof a != 'object' || typeof b != 'object') return false;
-    // Assume equality for cyclic structures. The algorithm for detecting cyclic
-    // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.
-    var length = stack.length;
-    while (length--) {
-      // Linear search. Performance is inversely proportional to the number of
-      // unique nested structures.
-      if (stack[length] == a) return true;
-    }
-    // Add the first object to the stack of traversed objects.
-    stack.push(a);
-    var size = 0, result = true;
-    // Recursively compare objects and arrays.
-    if (className == '[object Array]') {
-      // Compare array lengths to determine if a deep comparison is necessary.
-      size = a.length;
-      result = size == b.length;
-      if (result) {
-        // Deep compare the contents, ignoring non-numeric properties.
-        while (size--) {
-          // Ensure commutative equality for sparse arrays.
-          if (!(result = size in a == size in b && eq(a[size], b[size], stack))) break;
-        }
-      }
-    } else {
-      // Objects with different constructors are not equivalent.
-      if ('constructor' in a != 'constructor' in b || a.constructor != b.constructor) return false;
-      // Deep compare objects.
-      for (var key in a) {
-        if (_.has(a, key)) {
-          // Count the expected number of properties.
-          size++;
-          // Deep compare each member.
-          if (!(result = _.has(b, key) && eq(a[key], b[key], stack))) break;
-        }
-      }
-      // Ensure that both objects contain the same number of properties.
-      if (result) {
-        for (key in b) {
-          if (_.has(b, key) && !(size--)) break;
-        }
-        result = !size;
-      }
-    }
-    // Remove the first object from the stack of traversed objects.
-    stack.pop();
-    return result;
-  }
-
-  // Perform a deep comparison to check if two objects are equal.
-  _.isEqual = function(a, b) {
-    return eq(a, b, []);
-  };
-
-  // Is a given array, string, or object empty?
-  // An "empty" object has no enumerable own-properties.
-  _.isEmpty = function(obj) {
-    if (_.isArray(obj) || _.isString(obj)) return obj.length === 0;
-    for (var key in obj) if (_.has(obj, key)) return false;
-    return true;
-  };
-
-  // Is a given value a DOM element?
-  _.isElement = function(obj) {
-    return !!(obj && obj.nodeType == 1);
-  };
-
-  // Is a given value an array?
-  // Delegates to ECMA5's native Array.isArray
-  _.isArray = nativeIsArray || function(obj) {
-    return toString.call(obj) == '[object Array]';
-  };
-
-  // Is a given variable an object?
-  _.isObject = function(obj) {
-    return obj === Object(obj);
-  };
-
-  // Is a given variable an arguments object?
-  _.isArguments = function(obj) {
-    return toString.call(obj) == '[object Arguments]';
-  };
-  if (!_.isArguments(arguments)) {
-    _.isArguments = function(obj) {
-      return !!(obj && _.has(obj, 'callee'));
-    };
-  }
-
-  // Is a given value a function?
-  _.isFunction = function(obj) {
-    return toString.call(obj) == '[object Function]';
-  };
-
-  // Is a given value a string?
-  _.isString = function(obj) {
-    return toString.call(obj) == '[object String]';
-  };
-
-  // Is a given value a number?
-  _.isNumber = function(obj) {
-    return toString.call(obj) == '[object Number]';
-  };
-
-  // Is the given value `NaN`?
-  _.isNaN = function(obj) {
-    // `NaN` is the only value for which `===` is not reflexive.
-    return obj !== obj;
-  };
-
-  // Is a given value a boolean?
-  _.isBoolean = function(obj) {
-    return obj === true || obj === false || toString.call(obj) == '[object Boolean]';
-  };
-
-  // Is a given value a date?
-  _.isDate = function(obj) {
-    return toString.call(obj) == '[object Date]';
-  };
-
-  // Is the given value a regular expression?
-  _.isRegExp = function(obj) {
-    return toString.call(obj) == '[object RegExp]';
-  };
-
-  // Is a given value equal to null?
-  _.isNull = function(obj) {
-    return obj === null;
-  };
-
-  // Is a given variable undefined?
-  _.isUndefined = function(obj) {
-    return obj === void 0;
-  };
-
-  // Has own property?
-  _.has = function(obj, key) {
-    return hasOwnProperty.call(obj, key);
-  };
-
-  // Utility Functions
-  // -----------------
-
-  // Run Underscore.js in *noConflict* mode, returning the `_` variable to its
-  // previous owner. Returns a reference to the Underscore object.
-  _.noConflict = function() {
-    root._ = previousUnderscore;
-    return this;
-  };
-
-  // Keep the identity function around for default iterators.
-  _.identity = function(value) {
-    return value;
-  };
-
-  // Run a function **n** times.
-  _.times = function (n, iterator, context) {
-    for (var i = 0; i < n; i++) iterator.call(context, i);
-  };
-
-  // Escape a string for HTML interpolation.
-  _.escape = function(string) {
-    return (''+string).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&#x27;').replace(/\//g,'&#x2F;');
-  };
-
-  // Add your own custom functions to the Underscore object, ensuring that
-  // they're correctly added to the OOP wrapper as well.
-  _.mixin = function(obj) {
-    each(_.functions(obj), function(name){
-      addToWrapper(name, _[name] = obj[name]);
-    });
-  };
-
-  // Generate a unique integer id (unique within the entire client session).
-  // Useful for temporary DOM ids.
-  var idCounter = 0;
-  _.uniqueId = function(prefix) {
-    var id = idCounter++;
-    return prefix ? prefix + id : id;
-  };
-
-  // By default, Underscore uses ERB-style template delimiters, change the
-  // following template settings to use alternative delimiters.
-  _.templateSettings = {
-    evaluate    : /<%([\s\S]+?)%>/g,
-    interpolate : /<%=([\s\S]+?)%>/g,
-    escape      : /<%-([\s\S]+?)%>/g
-  };
-
-  // When customizing `templateSettings`, if you don't want to define an
-  // interpolation, evaluation or escaping regex, we need one that is
-  // guaranteed not to match.
-  var noMatch = /.^/;
-
-  // Within an interpolation, evaluation, or escaping, remove HTML escaping
-  // that had been previously added.
-  var unescape = function(code) {
-    return code.replace(/\\\\/g, '\\').replace(/\\'/g, "'");
-  };
-
-  // JavaScript micro-templating, similar to John Resig's implementation.
-  // Underscore templating handles arbitrary delimiters, preserves whitespace,
-  // and correctly escapes quotes within interpolated code.
-  _.template = function(str, data) {
-    var c  = _.templateSettings;
-    var tmpl = 'var __p=[],print=function(){__p.push.apply(__p,arguments);};' +
-      'with(obj||{}){__p.push(\'' +
-      str.replace(/\\/g, '\\\\')
-         .replace(/'/g, "\\'")
-         .replace(c.escape || noMatch, function(match, code) {
-           return "',_.escape(" + unescape(code) + "),'";
-         })
-         .replace(c.interpolate || noMatch, function(match, code) {
-           return "'," + unescape(code) + ",'";
-         })
-         .replace(c.evaluate || noMatch, function(match, code) {
-           return "');" + unescape(code).replace(/[\r\n\t]/g, ' ') + ";__p.push('";
-         })
-         .replace(/\r/g, '\\r')
-         .replace(/\n/g, '\\n')
-         .replace(/\t/g, '\\t')
-         + "');}return __p.join('');";
-    var func = new Function('obj', '_', tmpl);
-    if (data) return func(data, _);
-    return function(data) {
-      return func.call(this, data, _);
-    };
-  };
-
-  // Add a "chain" function, which will delegate to the wrapper.
-  _.chain = function(obj) {
-    return _(obj).chain();
-  };
-
-  // The OOP Wrapper
-  // ---------------
-
-  // If Underscore is called as a function, it returns a wrapped object that
-  // can be used OO-style. This wrapper holds altered versions of all the
-  // underscore functions. Wrapped objects may be chained.
-  var wrapper = function(obj) { this._wrapped = obj; };
-
-  // Expose `wrapper.prototype` as `_.prototype`
-  _.prototype = wrapper.prototype;
-
-  // Helper function to continue chaining intermediate results.
-  var result = function(obj, chain) {
-    return chain ? _(obj).chain() : obj;
-  };
-
-  // A method to easily add functions to the OOP wrapper.
-  var addToWrapper = function(name, func) {
-    wrapper.prototype[name] = function() {
-      var args = slice.call(arguments);
-      unshift.call(args, this._wrapped);
-      return result(func.apply(_, args), this._chain);
-    };
-  };
-
-  // Add all of the Underscore functions to the wrapper object.
-  _.mixin(_);
-
-  // Add all mutator Array functions to the wrapper.
-  each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) {
-    var method = ArrayProto[name];
-    wrapper.prototype[name] = function() {
-      var wrapped = this._wrapped;
-      method.apply(wrapped, arguments);
-      var length = wrapped.length;
-      if ((name == 'shift' || name == 'splice') && length === 0) delete wrapped[0];
-      return result(wrapped, this._chain);
-    };
-  });
-
-  // Add all accessor Array functions to the wrapper.
-  each(['concat', 'join', 'slice'], function(name) {
-    var method = ArrayProto[name];
-    wrapper.prototype[name] = function() {
-      return result(method.apply(this._wrapped, arguments), this._chain);
-    };
-  });
-
-  // Start chaining a wrapped Underscore object.
-  wrapper.prototype.chain = function() {
-    this._chain = true;
-    return this;
-  };
-
-  // Extracts the result from a wrapped and chained object.
-  wrapper.prototype.value = function() {
-    return this._wrapped;
-  };
-
-}).call(this);
diff --git a/_static/underscore.js b/_static/underscore.js
deleted file mode 100755
index 33ad84336e9..00000000000
--- a/_static/underscore.js
+++ /dev/null
@@ -1,31 +0,0 @@
-// Underscore.js 1.3.1
-// (c) 2009-2012 Jeremy Ashkenas, DocumentCloud Inc.
-// Underscore is freely distributable under the MIT license.
-// Portions of Underscore are inspired or borrowed from Prototype,
-// Oliver Steele's Functional, and John Resig's Micro-Templating.
-// For all details and documentation:
-// https://documentcloud.github.com/underscore
-(function(){function q(a,c,d){if(a===c)return a!==0||1/a==1/c;if(a==null||c==null)return a===c;if(a._chain)a=a._wrapped;if(c._chain)c=c._wrapped;if(a.isEqual&&b.isFunction(a.isEqual))return a.isEqual(c);if(c.isEqual&&b.isFunction(c.isEqual))return c.isEqual(a);var e=l.call(a);if(e!=l.call(c))return false;switch(e){case "[object String]":return a==String(c);case "[object Number]":return a!=+a?c!=+c:a==0?1/a==1/c:a==+c;case "[object Date]":case "[object Boolean]":return+a==+c;case "[object RegExp]":return a.source==
-c.source&&a.global==c.global&&a.multiline==c.multiline&&a.ignoreCase==c.ignoreCase}if(typeof a!="object"||typeof c!="object")return false;for(var f=d.length;f--;)if(d[f]==a)return true;d.push(a);var f=0,g=true;if(e=="[object Array]"){if(f=a.length,g=f==c.length)for(;f--;)if(!(g=f in a==f in c&&q(a[f],c[f],d)))break}else{if("constructor"in a!="constructor"in c||a.constructor!=c.constructor)return false;for(var h in a)if(b.has(a,h)&&(f++,!(g=b.has(c,h)&&q(a[h],c[h],d))))break;if(g){for(h in c)if(b.has(c,
-h)&&!f--)break;g=!f}}d.pop();return g}var r=this,G=r._,n={},k=Array.prototype,o=Object.prototype,i=k.slice,H=k.unshift,l=o.toString,I=o.hasOwnProperty,w=k.forEach,x=k.map,y=k.reduce,z=k.reduceRight,A=k.filter,B=k.every,C=k.some,p=k.indexOf,D=k.lastIndexOf,o=Array.isArray,J=Object.keys,s=Function.prototype.bind,b=function(a){return new m(a)};if(typeof exports!=="undefined"){if(typeof module!=="undefined"&&module.exports)exports=module.exports=b;exports._=b}else r._=b;b.VERSION="1.3.1";var j=b.each=
-b.forEach=function(a,c,d){if(a!=null)if(w&&a.forEach===w)a.forEach(c,d);else if(a.length===+a.length)for(var e=0,f=a.length;e<f;e++){if(e in a&&c.call(d,a[e],e,a)===n)break}else for(e in a)if(b.has(a,e)&&c.call(d,a[e],e,a)===n)break};b.map=b.collect=function(a,c,b){var e=[];if(a==null)return e;if(x&&a.map===x)return a.map(c,b);j(a,function(a,g,h){e[e.length]=c.call(b,a,g,h)});if(a.length===+a.length)e.length=a.length;return e};b.reduce=b.foldl=b.inject=function(a,c,d,e){var f=arguments.length>2;a==
-null&&(a=[]);if(y&&a.reduce===y)return e&&(c=b.bind(c,e)),f?a.reduce(c,d):a.reduce(c);j(a,function(a,b,i){f?d=c.call(e,d,a,b,i):(d=a,f=true)});if(!f)throw new TypeError("Reduce of empty array with no initial value");return d};b.reduceRight=b.foldr=function(a,c,d,e){var f=arguments.length>2;a==null&&(a=[]);if(z&&a.reduceRight===z)return e&&(c=b.bind(c,e)),f?a.reduceRight(c,d):a.reduceRight(c);var g=b.toArray(a).reverse();e&&!f&&(c=b.bind(c,e));return f?b.reduce(g,c,d,e):b.reduce(g,c)};b.find=b.detect=
-function(a,c,b){var e;E(a,function(a,g,h){if(c.call(b,a,g,h))return e=a,true});return e};b.filter=b.select=function(a,c,b){var e=[];if(a==null)return e;if(A&&a.filter===A)return a.filter(c,b);j(a,function(a,g,h){c.call(b,a,g,h)&&(e[e.length]=a)});return e};b.reject=function(a,c,b){var e=[];if(a==null)return e;j(a,function(a,g,h){c.call(b,a,g,h)||(e[e.length]=a)});return e};b.every=b.all=function(a,c,b){var e=true;if(a==null)return e;if(B&&a.every===B)return a.every(c,b);j(a,function(a,g,h){if(!(e=
-e&&c.call(b,a,g,h)))return n});return e};var E=b.some=b.any=function(a,c,d){c||(c=b.identity);var e=false;if(a==null)return e;if(C&&a.some===C)return a.some(c,d);j(a,function(a,b,h){if(e||(e=c.call(d,a,b,h)))return n});return!!e};b.include=b.contains=function(a,c){var b=false;if(a==null)return b;return p&&a.indexOf===p?a.indexOf(c)!=-1:b=E(a,function(a){return a===c})};b.invoke=function(a,c){var d=i.call(arguments,2);return b.map(a,function(a){return(b.isFunction(c)?c||a:a[c]).apply(a,d)})};b.pluck=
-function(a,c){return b.map(a,function(a){return a[c]})};b.max=function(a,c,d){if(!c&&b.isArray(a))return Math.max.apply(Math,a);if(!c&&b.isEmpty(a))return-Infinity;var e={computed:-Infinity};j(a,function(a,b,h){b=c?c.call(d,a,b,h):a;b>=e.computed&&(e={value:a,computed:b})});return e.value};b.min=function(a,c,d){if(!c&&b.isArray(a))return Math.min.apply(Math,a);if(!c&&b.isEmpty(a))return Infinity;var e={computed:Infinity};j(a,function(a,b,h){b=c?c.call(d,a,b,h):a;b<e.computed&&(e={value:a,computed:b})});
-return e.value};b.shuffle=function(a){var b=[],d;j(a,function(a,f){f==0?b[0]=a:(d=Math.floor(Math.random()*(f+1)),b[f]=b[d],b[d]=a)});return b};b.sortBy=function(a,c,d){return b.pluck(b.map(a,function(a,b,g){return{value:a,criteria:c.call(d,a,b,g)}}).sort(function(a,b){var c=a.criteria,d=b.criteria;return c<d?-1:c>d?1:0}),"value")};b.groupBy=function(a,c){var d={},e=b.isFunction(c)?c:function(a){return a[c]};j(a,function(a,b){var c=e(a,b);(d[c]||(d[c]=[])).push(a)});return d};b.sortedIndex=function(a,
-c,d){d||(d=b.identity);for(var e=0,f=a.length;e<f;){var g=e+f>>1;d(a[g])<d(c)?e=g+1:f=g}return e};b.toArray=function(a){return!a?[]:a.toArray?a.toArray():b.isArray(a)?i.call(a):b.isArguments(a)?i.call(a):b.values(a)};b.size=function(a){return b.toArray(a).length};b.first=b.head=function(a,b,d){return b!=null&&!d?i.call(a,0,b):a[0]};b.initial=function(a,b,d){return i.call(a,0,a.length-(b==null||d?1:b))};b.last=function(a,b,d){return b!=null&&!d?i.call(a,Math.max(a.length-b,0)):a[a.length-1]};b.rest=
-b.tail=function(a,b,d){return i.call(a,b==null||d?1:b)};b.compact=function(a){return b.filter(a,function(a){return!!a})};b.flatten=function(a,c){return b.reduce(a,function(a,e){if(b.isArray(e))return a.concat(c?e:b.flatten(e));a[a.length]=e;return a},[])};b.without=function(a){return b.difference(a,i.call(arguments,1))};b.uniq=b.unique=function(a,c,d){var d=d?b.map(a,d):a,e=[];b.reduce(d,function(d,g,h){if(0==h||(c===true?b.last(d)!=g:!b.include(d,g)))d[d.length]=g,e[e.length]=a[h];return d},[]);
-return e};b.union=function(){return b.uniq(b.flatten(arguments,true))};b.intersection=b.intersect=function(a){var c=i.call(arguments,1);return b.filter(b.uniq(a),function(a){return b.every(c,function(c){return b.indexOf(c,a)>=0})})};b.difference=function(a){var c=b.flatten(i.call(arguments,1));return b.filter(a,function(a){return!b.include(c,a)})};b.zip=function(){for(var a=i.call(arguments),c=b.max(b.pluck(a,"length")),d=Array(c),e=0;e<c;e++)d[e]=b.pluck(a,""+e);return d};b.indexOf=function(a,c,
-d){if(a==null)return-1;var e;if(d)return d=b.sortedIndex(a,c),a[d]===c?d:-1;if(p&&a.indexOf===p)return a.indexOf(c);for(d=0,e=a.length;d<e;d++)if(d in a&&a[d]===c)return d;return-1};b.lastIndexOf=function(a,b){if(a==null)return-1;if(D&&a.lastIndexOf===D)return a.lastIndexOf(b);for(var d=a.length;d--;)if(d in a&&a[d]===b)return d;return-1};b.range=function(a,b,d){arguments.length<=1&&(b=a||0,a=0);for(var d=arguments[2]||1,e=Math.max(Math.ceil((b-a)/d),0),f=0,g=Array(e);f<e;)g[f++]=a,a+=d;return g};
-var F=function(){};b.bind=function(a,c){var d,e;if(a.bind===s&&s)return s.apply(a,i.call(arguments,1));if(!b.isFunction(a))throw new TypeError;e=i.call(arguments,2);return d=function(){if(!(this instanceof d))return a.apply(c,e.concat(i.call(arguments)));F.prototype=a.prototype;var b=new F,g=a.apply(b,e.concat(i.call(arguments)));return Object(g)===g?g:b}};b.bindAll=function(a){var c=i.call(arguments,1);c.length==0&&(c=b.functions(a));j(c,function(c){a[c]=b.bind(a[c],a)});return a};b.memoize=function(a,
-c){var d={};c||(c=b.identity);return function(){var e=c.apply(this,arguments);return b.has(d,e)?d[e]:d[e]=a.apply(this,arguments)}};b.delay=function(a,b){var d=i.call(arguments,2);return setTimeout(function(){return a.apply(a,d)},b)};b.defer=function(a){return b.delay.apply(b,[a,1].concat(i.call(arguments,1)))};b.throttle=function(a,c){var d,e,f,g,h,i=b.debounce(function(){h=g=false},c);return function(){d=this;e=arguments;var b;f||(f=setTimeout(function(){f=null;h&&a.apply(d,e);i()},c));g?h=true:
-a.apply(d,e);i();g=true}};b.debounce=function(a,b){var d;return function(){var e=this,f=arguments;clearTimeout(d);d=setTimeout(function(){d=null;a.apply(e,f)},b)}};b.once=function(a){var b=false,d;return function(){if(b)return d;b=true;return d=a.apply(this,arguments)}};b.wrap=function(a,b){return function(){var d=[a].concat(i.call(arguments,0));return b.apply(this,d)}};b.compose=function(){var a=arguments;return function(){for(var b=arguments,d=a.length-1;d>=0;d--)b=[a[d].apply(this,b)];return b[0]}};
-b.after=function(a,b){return a<=0?b():function(){if(--a<1)return b.apply(this,arguments)}};b.keys=J||function(a){if(a!==Object(a))throw new TypeError("Invalid object");var c=[],d;for(d in a)b.has(a,d)&&(c[c.length]=d);return c};b.values=function(a){return b.map(a,b.identity)};b.functions=b.methods=function(a){var c=[],d;for(d in a)b.isFunction(a[d])&&c.push(d);return c.sort()};b.extend=function(a){j(i.call(arguments,1),function(b){for(var d in b)a[d]=b[d]});return a};b.defaults=function(a){j(i.call(arguments,
-1),function(b){for(var d in b)a[d]==null&&(a[d]=b[d])});return a};b.clone=function(a){return!b.isObject(a)?a:b.isArray(a)?a.slice():b.extend({},a)};b.tap=function(a,b){b(a);return a};b.isEqual=function(a,b){return q(a,b,[])};b.isEmpty=function(a){if(b.isArray(a)||b.isString(a))return a.length===0;for(var c in a)if(b.has(a,c))return false;return true};b.isElement=function(a){return!!(a&&a.nodeType==1)};b.isArray=o||function(a){return l.call(a)=="[object Array]"};b.isObject=function(a){return a===Object(a)};
-b.isArguments=function(a){return l.call(a)=="[object Arguments]"};if(!b.isArguments(arguments))b.isArguments=function(a){return!(!a||!b.has(a,"callee"))};b.isFunction=function(a){return l.call(a)=="[object Function]"};b.isString=function(a){return l.call(a)=="[object String]"};b.isNumber=function(a){return l.call(a)=="[object Number]"};b.isNaN=function(a){return a!==a};b.isBoolean=function(a){return a===true||a===false||l.call(a)=="[object Boolean]"};b.isDate=function(a){return l.call(a)=="[object Date]"};
-b.isRegExp=function(a){return l.call(a)=="[object RegExp]"};b.isNull=function(a){return a===null};b.isUndefined=function(a){return a===void 0};b.has=function(a,b){return I.call(a,b)};b.noConflict=function(){r._=G;return this};b.identity=function(a){return a};b.times=function(a,b,d){for(var e=0;e<a;e++)b.call(d,e)};b.escape=function(a){return(""+a).replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/"/g,"&quot;").replace(/'/g,"&#x27;").replace(/\//g,"&#x2F;")};b.mixin=function(a){j(b.functions(a),
-function(c){K(c,b[c]=a[c])})};var L=0;b.uniqueId=function(a){var b=L++;return a?a+b:b};b.templateSettings={evaluate:/<%([\s\S]+?)%>/g,interpolate:/<%=([\s\S]+?)%>/g,escape:/<%-([\s\S]+?)%>/g};var t=/.^/,u=function(a){return a.replace(/\\\\/g,"\\").replace(/\\'/g,"'")};b.template=function(a,c){var d=b.templateSettings,d="var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push('"+a.replace(/\\/g,"\\\\").replace(/'/g,"\\'").replace(d.escape||t,function(a,b){return"',_.escape("+
-u(b)+"),'"}).replace(d.interpolate||t,function(a,b){return"',"+u(b)+",'"}).replace(d.evaluate||t,function(a,b){return"');"+u(b).replace(/[\r\n\t]/g," ")+";__p.push('"}).replace(/\r/g,"\\r").replace(/\n/g,"\\n").replace(/\t/g,"\\t")+"');}return __p.join('');",e=new Function("obj","_",d);return c?e(c,b):function(a){return e.call(this,a,b)}};b.chain=function(a){return b(a).chain()};var m=function(a){this._wrapped=a};b.prototype=m.prototype;var v=function(a,c){return c?b(a).chain():a},K=function(a,c){m.prototype[a]=
-function(){var a=i.call(arguments);H.call(a,this._wrapped);return v(c.apply(b,a),this._chain)}};b.mixin(b);j("pop,push,reverse,shift,sort,splice,unshift".split(","),function(a){var b=k[a];m.prototype[a]=function(){var d=this._wrapped;b.apply(d,arguments);var e=d.length;(a=="shift"||a=="splice")&&e===0&&delete d[0];return v(d,this._chain)}});j(["concat","join","slice"],function(a){var b=k[a];m.prototype[a]=function(){return v(b.apply(this._wrapped,arguments),this._chain)}});m.prototype.chain=function(){this._chain=
-true;return this};m.prototype.value=function(){return this._wrapped}}).call(this);
diff --git a/_static/websupport.js b/_static/websupport.js
deleted file mode 100755
index 78e14bb4a1e..00000000000
--- a/_static/websupport.js
+++ /dev/null
@@ -1,808 +0,0 @@
-/*
- * websupport.js
- * ~~~~~~~~~~~~~
- *
- * sphinx.websupport utilities for all documentation.
- *
- * :copyright: Copyright 2007-2018 by the Sphinx team, see AUTHORS.
- * :license: BSD, see LICENSE for details.
- *
- */
-
-(function($) {
-  $.fn.autogrow = function() {
-    return this.each(function() {
-    var textarea = this;
-
-    $.fn.autogrow.resize(textarea);
-
-    $(textarea)
-      .focus(function() {
-        textarea.interval = setInterval(function() {
-          $.fn.autogrow.resize(textarea);
-        }, 500);
-      })
-      .blur(function() {
-        clearInterval(textarea.interval);
-      });
-    });
-  };
-
-  $.fn.autogrow.resize = function(textarea) {
-    var lineHeight = parseInt($(textarea).css('line-height'), 10);
-    var lines = textarea.value.split('\n');
-    var columns = textarea.cols;
-    var lineCount = 0;
-    $.each(lines, function() {
-      lineCount += Math.ceil(this.length / columns) || 1;
-    });
-    var height = lineHeight * (lineCount + 1);
-    $(textarea).css('height', height);
-  };
-})(jQuery);
-
-(function($) {
-  var comp, by;
-
-  function init() {
-    initEvents();
-    initComparator();
-  }
-
-  function initEvents() {
-    $(document).on("click", 'a.comment-close', function(event) {
-      event.preventDefault();
-      hide($(this).attr('id').substring(2));
-    });
-    $(document).on("click", 'a.vote', function(event) {
-      event.preventDefault();
-      handleVote($(this));
-    });
-    $(document).on("click", 'a.reply', function(event) {
-      event.preventDefault();
-      openReply($(this).attr('id').substring(2));
-    });
-    $(document).on("click", 'a.close-reply', function(event) {
-      event.preventDefault();
-      closeReply($(this).attr('id').substring(2));
-    });
-    $(document).on("click", 'a.sort-option', function(event) {
-      event.preventDefault();
-      handleReSort($(this));
-    });
-    $(document).on("click", 'a.show-proposal', function(event) {
-      event.preventDefault();
-      showProposal($(this).attr('id').substring(2));
-    });
-    $(document).on("click", 'a.hide-proposal', function(event) {
-      event.preventDefault();
-      hideProposal($(this).attr('id').substring(2));
-    });
-    $(document).on("click", 'a.show-propose-change', function(event) {
-      event.preventDefault();
-      showProposeChange($(this).attr('id').substring(2));
-    });
-    $(document).on("click", 'a.hide-propose-change', function(event) {
-      event.preventDefault();
-      hideProposeChange($(this).attr('id').substring(2));
-    });
-    $(document).on("click", 'a.accept-comment', function(event) {
-      event.preventDefault();
-      acceptComment($(this).attr('id').substring(2));
-    });
-    $(document).on("click", 'a.delete-comment', function(event) {
-      event.preventDefault();
-      deleteComment($(this).attr('id').substring(2));
-    });
-    $(document).on("click", 'a.comment-markup', function(event) {
-      event.preventDefault();
-      toggleCommentMarkupBox($(this).attr('id').substring(2));
-    });
-  }
-
-  /**
-   * Set comp, which is a comparator function used for sorting and
-   * inserting comments into the list.
-   */
-  function setComparator() {
-    // If the first three letters are "asc", sort in ascending order
-    // and remove the prefix.
-    if (by.substring(0,3) == 'asc') {
-      var i = by.substring(3);
-      comp = function(a, b) { return a[i] - b[i]; };
-    } else {
-      // Otherwise sort in descending order.
-      comp = function(a, b) { return b[by] - a[by]; };
-    }
-
-    // Reset link styles and format the selected sort option.
-    $('a.sel').attr('href', '#').removeClass('sel');
-    $('a.by' + by).removeAttr('href').addClass('sel');
-  }
-
-  /**
-   * Create a comp function. If the user has preferences stored in
-   * the sortBy cookie, use those, otherwise use the default.
-   */
-  function initComparator() {
-    by = 'rating'; // Default to sort by rating.
-    // If the sortBy cookie is set, use that instead.
-    if (document.cookie.length > 0) {
-      var start = document.cookie.indexOf('sortBy=');
-      if (start != -1) {
-        start = start + 7;
-        var end = document.cookie.indexOf(";", start);
-        if (end == -1) {
-          end = document.cookie.length;
-          by = unescape(document.cookie.substring(start, end));
-        }
-      }
-    }
-    setComparator();
-  }
-
-  /**
-   * Show a comment div.
-   */
-  function show(id) {
-    $('#ao' + id).hide();
-    $('#ah' + id).show();
-    var context = $.extend({id: id}, opts);
-    var popup = $(renderTemplate(popupTemplate, context)).hide();
-    popup.find('textarea[name="proposal"]').hide();
-    popup.find('a.by' + by).addClass('sel');
-    var form = popup.find('#cf' + id);
-    form.submit(function(event) {
-      event.preventDefault();
-      addComment(form);
-    });
-    $('#s' + id).after(popup);
-    popup.slideDown('fast', function() {
-      getComments(id);
-    });
-  }
-
-  /**
-   * Hide a comment div.
-   */
-  function hide(id) {
-    $('#ah' + id).hide();
-    $('#ao' + id).show();
-    var div = $('#sc' + id);
-    div.slideUp('fast', function() {
-      div.remove();
-    });
-  }
-
-  /**
-   * Perform an ajax request to get comments for a node
-   * and insert the comments into the comments tree.
-   */
-  function getComments(id) {
-    $.ajax({
-     type: 'GET',
-     url: opts.getCommentsURL,
-     data: {node: id},
-     success: function(data, textStatus, request) {
-       var ul = $('#cl' + id);
-       var speed = 100;
-       $('#cf' + id)
-         .find('textarea[name="proposal"]')
-         .data('source', data.source);
-
-       if (data.comments.length === 0) {
-         ul.html('<li>No comments yet.</li>');
-         ul.data('empty', true);
-       } else {
-         // If there are comments, sort them and put them in the list.
-         var comments = sortComments(data.comments);
-         speed = data.comments.length * 100;
-         appendComments(comments, ul);
-         ul.data('empty', false);
-       }
-       $('#cn' + id).slideUp(speed + 200);
-       ul.slideDown(speed);
-     },
-     error: function(request, textStatus, error) {
-       showError('Oops, there was a problem retrieving the comments.');
-     },
-     dataType: 'json'
-    });
-  }
-
-  /**
-   * Add a comment via ajax and insert the comment into the comment tree.
-   */
-  function addComment(form) {
-    var node_id = form.find('input[name="node"]').val();
-    var parent_id = form.find('input[name="parent"]').val();
-    var text = form.find('textarea[name="comment"]').val();
-    var proposal = form.find('textarea[name="proposal"]').val();
-
-    if (text == '') {
-      showError('Please enter a comment.');
-      return;
-    }
-
-    // Disable the form that is being submitted.
-    form.find('textarea,input').attr('disabled', 'disabled');
-
-    // Send the comment to the server.
-    $.ajax({
-      type: "POST",
-      url: opts.addCommentURL,
-      dataType: 'json',
-      data: {
-        node: node_id,
-        parent: parent_id,
-        text: text,
-        proposal: proposal
-      },
-      success: function(data, textStatus, error) {
-        // Reset the form.
-        if (node_id) {
-          hideProposeChange(node_id);
-        }
-        form.find('textarea')
-          .val('')
-          .add(form.find('input'))
-          .removeAttr('disabled');
-	var ul = $('#cl' + (node_id || parent_id));
-        if (ul.data('empty')) {
-          $(ul).empty();
-          ul.data('empty', false);
-        }
-        insertComment(data.comment);
-        var ao = $('#ao' + node_id);
-        ao.find('img').attr({'src': opts.commentBrightImage});
-        if (node_id) {
-          // if this was a "root" comment, remove the commenting box
-          // (the user can get it back by reopening the comment popup)
-          $('#ca' + node_id).slideUp();
-        }
-      },
-      error: function(request, textStatus, error) {
-        form.find('textarea,input').removeAttr('disabled');
-        showError('Oops, there was a problem adding the comment.');
-      }
-    });
-  }
-
-  /**
-   * Recursively append comments to the main comment list and children
-   * lists, creating the comment tree.
-   */
-  function appendComments(comments, ul) {
-    $.each(comments, function() {
-      var div = createCommentDiv(this);
-      ul.append($(document.createElement('li')).html(div));
-      appendComments(this.children, div.find('ul.comment-children'));
-      // To avoid stagnating data, don't store the comments children in data.
-      this.children = null;
-      div.data('comment', this);
-    });
-  }
-
-  /**
-   * After adding a new comment, it must be inserted in the correct
-   * location in the comment tree.
-   */
-  function insertComment(comment) {
-    var div = createCommentDiv(comment);
-
-    // To avoid stagnating data, don't store the comments children in data.
-    comment.children = null;
-    div.data('comment', comment);
-
-    var ul = $('#cl' + (comment.node || comment.parent));
-    var siblings = getChildren(ul);
-
-    var li = $(document.createElement('li'));
-    li.hide();
-
-    // Determine where in the parents children list to insert this comment.
-    for(var i=0; i < siblings.length; i++) {
-      if (comp(comment, siblings[i]) <= 0) {
-        $('#cd' + siblings[i].id)
-          .parent()
-          .before(li.html(div));
-        li.slideDown('fast');
-        return;
-      }
-    }
-
-    // If we get here, this comment rates lower than all the others,
-    // or it is the only comment in the list.
-    ul.append(li.html(div));
-    li.slideDown('fast');
-  }
-
-  function acceptComment(id) {
-    $.ajax({
-      type: 'POST',
-      url: opts.acceptCommentURL,
-      data: {id: id},
-      success: function(data, textStatus, request) {
-        $('#cm' + id).fadeOut('fast');
-        $('#cd' + id).removeClass('moderate');
-      },
-      error: function(request, textStatus, error) {
-        showError('Oops, there was a problem accepting the comment.');
-      }
-    });
-  }
-
-  function deleteComment(id) {
-    $.ajax({
-      type: 'POST',
-      url: opts.deleteCommentURL,
-      data: {id: id},
-      success: function(data, textStatus, request) {
-        var div = $('#cd' + id);
-        if (data == 'delete') {
-          // Moderator mode: remove the comment and all children immediately
-          div.slideUp('fast', function() {
-            div.remove();
-          });
-          return;
-        }
-        // User mode: only mark the comment as deleted
-        div
-          .find('span.user-id:first')
-          .text('[deleted]').end()
-          .find('div.comment-text:first')
-          .text('[deleted]').end()
-          .find('#cm' + id + ', #dc' + id + ', #ac' + id + ', #rc' + id +
-                ', #sp' + id + ', #hp' + id + ', #cr' + id + ', #rl' + id)
-          .remove();
-        var comment = div.data('comment');
-        comment.username = '[deleted]';
-        comment.text = '[deleted]';
-        div.data('comment', comment);
-      },
-      error: function(request, textStatus, error) {
-        showError('Oops, there was a problem deleting the comment.');
-      }
-    });
-  }
-
-  function showProposal(id) {
-    $('#sp' + id).hide();
-    $('#hp' + id).show();
-    $('#pr' + id).slideDown('fast');
-  }
-
-  function hideProposal(id) {
-    $('#hp' + id).hide();
-    $('#sp' + id).show();
-    $('#pr' + id).slideUp('fast');
-  }
-
-  function showProposeChange(id) {
-    $('#pc' + id).hide();
-    $('#hc' + id).show();
-    var textarea = $('#pt' + id);
-    textarea.val(textarea.data('source'));
-    $.fn.autogrow.resize(textarea[0]);
-    textarea.slideDown('fast');
-  }
-
-  function hideProposeChange(id) {
-    $('#hc' + id).hide();
-    $('#pc' + id).show();
-    var textarea = $('#pt' + id);
-    textarea.val('').removeAttr('disabled');
-    textarea.slideUp('fast');
-  }
-
-  function toggleCommentMarkupBox(id) {
-    $('#mb' + id).toggle();
-  }
-
-  /** Handle when the user clicks on a sort by link. */
-  function handleReSort(link) {
-    var classes = link.attr('class').split(/\s+/);
-    for (var i=0; i<classes.length; i++) {
-      if (classes[i] != 'sort-option') {
-	by = classes[i].substring(2);
-      }
-    }
-    setComparator();
-    // Save/update the sortBy cookie.
-    var expiration = new Date();
-    expiration.setDate(expiration.getDate() + 365);
-    document.cookie= 'sortBy=' + escape(by) +
-                     ';expires=' + expiration.toUTCString();
-    $('ul.comment-ul').each(function(index, ul) {
-      var comments = getChildren($(ul), true);
-      comments = sortComments(comments);
-      appendComments(comments, $(ul).empty());
-    });
-  }
-
-  /**
-   * Function to process a vote when a user clicks an arrow.
-   */
-  function handleVote(link) {
-    if (!opts.voting) {
-      showError("You'll need to login to vote.");
-      return;
-    }
-
-    var id = link.attr('id');
-    if (!id) {
-      // Didn't click on one of the voting arrows.
-      return;
-    }
-    // If it is an unvote, the new vote value is 0,
-    // Otherwise it's 1 for an upvote, or -1 for a downvote.
-    var value = 0;
-    if (id.charAt(1) != 'u') {
-      value = id.charAt(0) == 'u' ? 1 : -1;
-    }
-    // The data to be sent to the server.
-    var d = {
-      comment_id: id.substring(2),
-      value: value
-    };
-
-    // Swap the vote and unvote links.
-    link.hide();
-    $('#' + id.charAt(0) + (id.charAt(1) == 'u' ? 'v' : 'u') + d.comment_id)
-      .show();
-
-    // The div the comment is displayed in.
-    var div = $('div#cd' + d.comment_id);
-    var data = div.data('comment');
-
-    // If this is not an unvote, and the other vote arrow has
-    // already been pressed, unpress it.
-    if ((d.value !== 0) && (data.vote === d.value * -1)) {
-      $('#' + (d.value == 1 ? 'd' : 'u') + 'u' + d.comment_id).hide();
-      $('#' + (d.value == 1 ? 'd' : 'u') + 'v' + d.comment_id).show();
-    }
-
-    // Update the comments rating in the local data.
-    data.rating += (data.vote === 0) ? d.value : (d.value - data.vote);
-    data.vote = d.value;
-    div.data('comment', data);
-
-    // Change the rating text.
-    div.find('.rating:first')
-      .text(data.rating + ' point' + (data.rating == 1 ? '' : 's'));
-
-    // Send the vote information to the server.
-    $.ajax({
-      type: "POST",
-      url: opts.processVoteURL,
-      data: d,
-      error: function(request, textStatus, error) {
-        showError('Oops, there was a problem casting that vote.');
-      }
-    });
-  }
-
-  /**
-   * Open a reply form used to reply to an existing comment.
-   */
-  function openReply(id) {
-    // Swap out the reply link for the hide link
-    $('#rl' + id).hide();
-    $('#cr' + id).show();
-
-    // Add the reply li to the children ul.
-    var div = $(renderTemplate(replyTemplate, {id: id})).hide();
-    $('#cl' + id)
-      .prepend(div)
-      // Setup the submit handler for the reply form.
-      .find('#rf' + id)
-      .submit(function(event) {
-        event.preventDefault();
-        addComment($('#rf' + id));
-        closeReply(id);
-      })
-      .find('input[type=button]')
-      .click(function() {
-        closeReply(id);
-      });
-    div.slideDown('fast', function() {
-      $('#rf' + id).find('textarea').focus();
-    });
-  }
-
-  /**
-   * Close the reply form opened with openReply.
-   */
-  function closeReply(id) {
-    // Remove the reply div from the DOM.
-    $('#rd' + id).slideUp('fast', function() {
-      $(this).remove();
-    });
-
-    // Swap out the hide link for the reply link
-    $('#cr' + id).hide();
-    $('#rl' + id).show();
-  }
-
-  /**
-   * Recursively sort a tree of comments using the comp comparator.
-   */
-  function sortComments(comments) {
-    comments.sort(comp);
-    $.each(comments, function() {
-      this.children = sortComments(this.children);
-    });
-    return comments;
-  }
-
-  /**
-   * Get the children comments from a ul. If recursive is true,
-   * recursively include childrens' children.
-   */
-  function getChildren(ul, recursive) {
-    var children = [];
-    ul.children().children("[id^='cd']")
-      .each(function() {
-        var comment = $(this).data('comment');
-        if (recursive)
-          comment.children = getChildren($(this).find('#cl' + comment.id), true);
-        children.push(comment);
-      });
-    return children;
-  }
-
-  /** Create a div to display a comment in. */
-  function createCommentDiv(comment) {
-    if (!comment.displayed && !opts.moderator) {
-      return $('<div class="moderate">Thank you!  Your comment will show up '
-               + 'once it is has been approved by a moderator.</div>');
-    }
-    // Prettify the comment rating.
-    comment.pretty_rating = comment.rating + ' point' +
-      (comment.rating == 1 ? '' : 's');
-    // Make a class (for displaying not yet moderated comments differently)
-    comment.css_class = comment.displayed ? '' : ' moderate';
-    // Create a div for this comment.
-    var context = $.extend({}, opts, comment);
-    var div = $(renderTemplate(commentTemplate, context));
-
-    // If the user has voted on this comment, highlight the correct arrow.
-    if (comment.vote) {
-      var direction = (comment.vote == 1) ? 'u' : 'd';
-      div.find('#' + direction + 'v' + comment.id).hide();
-      div.find('#' + direction + 'u' + comment.id).show();
-    }
-
-    if (opts.moderator || comment.text != '[deleted]') {
-      div.find('a.reply').show();
-      if (comment.proposal_diff)
-        div.find('#sp' + comment.id).show();
-      if (opts.moderator && !comment.displayed)
-        div.find('#cm' + comment.id).show();
-      if (opts.moderator || (opts.username == comment.username))
-        div.find('#dc' + comment.id).show();
-    }
-    return div;
-  }
-
-  /**
-   * A simple template renderer. Placeholders such as <%id%> are replaced
-   * by context['id'] with items being escaped. Placeholders such as <#id#>
-   * are not escaped.
-   */
-  function renderTemplate(template, context) {
-    var esc = $(document.createElement('div'));
-
-    function handle(ph, escape) {
-      var cur = context;
-      $.each(ph.split('.'), function() {
-        cur = cur[this];
-      });
-      return escape ? esc.text(cur || "").html() : cur;
-    }
-
-    return template.replace(/<([%#])([\w\.]*)\1>/g, function() {
-      return handle(arguments[2], arguments[1] == '%' ? true : false);
-    });
-  }
-
-  /** Flash an error message briefly. */
-  function showError(message) {
-    $(document.createElement('div')).attr({'class': 'popup-error'})
-      .append($(document.createElement('div'))
-               .attr({'class': 'error-message'}).text(message))
-      .appendTo('body')
-      .fadeIn("slow")
-      .delay(2000)
-      .fadeOut("slow");
-  }
-
-  /** Add a link the user uses to open the comments popup. */
-  $.fn.comment = function() {
-    return this.each(function() {
-      var id = $(this).attr('id').substring(1);
-      var count = COMMENT_METADATA[id];
-      var title = count + ' comment' + (count == 1 ? '' : 's');
-      var image = count > 0 ? opts.commentBrightImage : opts.commentImage;
-      var addcls = count == 0 ? ' nocomment' : '';
-      $(this)
-        .append(
-          $(document.createElement('a')).attr({
-            href: '#',
-            'class': 'sphinx-comment-open' + addcls,
-            id: 'ao' + id
-          })
-            .append($(document.createElement('img')).attr({
-              src: image,
-              alt: 'comment',
-              title: title
-            }))
-            .click(function(event) {
-              event.preventDefault();
-              show($(this).attr('id').substring(2));
-            })
-        )
-        .append(
-          $(document.createElement('a')).attr({
-            href: '#',
-            'class': 'sphinx-comment-close hidden',
-            id: 'ah' + id
-          })
-            .append($(document.createElement('img')).attr({
-              src: opts.closeCommentImage,
-              alt: 'close',
-              title: 'close'
-            }))
-            .click(function(event) {
-              event.preventDefault();
-              hide($(this).attr('id').substring(2));
-            })
-        );
-    });
-  };
-
-  var opts = {
-    processVoteURL: '/_process_vote',
-    addCommentURL: '/_add_comment',
-    getCommentsURL: '/_get_comments',
-    acceptCommentURL: '/_accept_comment',
-    deleteCommentURL: '/_delete_comment',
-    commentImage: '/static/_static/comment.png',
-    closeCommentImage: '/static/_static/comment-close.png',
-    loadingImage: '/static/_static/ajax-loader.gif',
-    commentBrightImage: '/static/_static/comment-bright.png',
-    upArrow: '/static/_static/up.png',
-    downArrow: '/static/_static/down.png',
-    upArrowPressed: '/static/_static/up-pressed.png',
-    downArrowPressed: '/static/_static/down-pressed.png',
-    voting: false,
-    moderator: false
-  };
-
-  if (typeof COMMENT_OPTIONS != "undefined") {
-    opts = jQuery.extend(opts, COMMENT_OPTIONS);
-  }
-
-  var popupTemplate = '\
-    <div class="sphinx-comments" id="sc<%id%>">\
-      <p class="sort-options">\
-        Sort by:\
-        <a href="#" class="sort-option byrating">best rated</a>\
-        <a href="#" class="sort-option byascage">newest</a>\
-        <a href="#" class="sort-option byage">oldest</a>\
-      </p>\
-      <div class="comment-header">Comments</div>\
-      <div class="comment-loading" id="cn<%id%>">\
-        loading comments... <img src="<%loadingImage%>" alt="" /></div>\
-      <ul id="cl<%id%>" class="comment-ul"></ul>\
-      <div id="ca<%id%>">\
-      <p class="add-a-comment">Add a comment\
-        (<a href="#" class="comment-markup" id="ab<%id%>">markup</a>):</p>\
-      <div class="comment-markup-box" id="mb<%id%>">\
-        reStructured text markup: <i>*emph*</i>, <b>**strong**</b>, \
-        <code>``code``</code>, \
-        code blocks: <code>::</code> and an indented block after blank line</div>\
-      <form method="post" id="cf<%id%>" class="comment-form" action="">\
-        <textarea name="comment" cols="80"></textarea>\
-        <p class="propose-button">\
-          <a href="#" id="pc<%id%>" class="show-propose-change">\
-            Propose a change &#9657;\
-          </a>\
-          <a href="#" id="hc<%id%>" class="hide-propose-change">\
-            Propose a change &#9663;\
-          </a>\
-        </p>\
-        <textarea name="proposal" id="pt<%id%>" cols="80"\
-                  spellcheck="false"></textarea>\
-        <input type="submit" value="Add comment" />\
-        <input type="hidden" name="node" value="<%id%>" />\
-        <input type="hidden" name="parent" value="" />\
-      </form>\
-      </div>\
-    </div>';
-
-  var commentTemplate = '\
-    <div id="cd<%id%>" class="sphinx-comment<%css_class%>">\
-      <div class="vote">\
-        <div class="arrow">\
-          <a href="#" id="uv<%id%>" class="vote" title="vote up">\
-            <img src="<%upArrow%>" />\
-          </a>\
-          <a href="#" id="uu<%id%>" class="un vote" title="vote up">\
-            <img src="<%upArrowPressed%>" />\
-          </a>\
-        </div>\
-        <div class="arrow">\
-          <a href="#" id="dv<%id%>" class="vote" title="vote down">\
-            <img src="<%downArrow%>" id="da<%id%>" />\
-          </a>\
-          <a href="#" id="du<%id%>" class="un vote" title="vote down">\
-            <img src="<%downArrowPressed%>" />\
-          </a>\
-        </div>\
-      </div>\
-      <div class="comment-content">\
-        <p class="tagline comment">\
-          <span class="user-id"><%username%></span>\
-          <span class="rating"><%pretty_rating%></span>\
-          <span class="delta"><%time.delta%></span>\
-        </p>\
-        <div class="comment-text comment"><#text#></div>\
-        <p class="comment-opts comment">\
-          <a href="#" class="reply hidden" id="rl<%id%>">reply &#9657;</a>\
-          <a href="#" class="close-reply" id="cr<%id%>">reply &#9663;</a>\
-          <a href="#" id="sp<%id%>" class="show-proposal">proposal &#9657;</a>\
-          <a href="#" id="hp<%id%>" class="hide-proposal">proposal &#9663;</a>\
-          <a href="#" id="dc<%id%>" class="delete-comment hidden">delete</a>\
-          <span id="cm<%id%>" class="moderation hidden">\
-            <a href="#" id="ac<%id%>" class="accept-comment">accept</a>\
-          </span>\
-        </p>\
-        <pre class="proposal" id="pr<%id%>">\
-<#proposal_diff#>\
-        </pre>\
-          <ul class="comment-children" id="cl<%id%>"></ul>\
-        </div>\
-        <div class="clearleft"></div>\
-      </div>\
-    </div>';
-
-  var replyTemplate = '\
-    <li>\
-      <div class="reply-div" id="rd<%id%>">\
-        <form id="rf<%id%>">\
-          <textarea name="comment" cols="80"></textarea>\
-          <input type="submit" value="Add reply" />\
-          <input type="button" value="Cancel" />\
-          <input type="hidden" name="parent" value="<%id%>" />\
-          <input type="hidden" name="node" value="" />\
-        </form>\
-      </div>\
-    </li>';
-
-  $(document).ready(function() {
-    init();
-  });
-})(jQuery);
-
-$(document).ready(function() {
-  // add comment anchors for all paragraphs that are commentable
-  $('.sphinx-has-comment').comment();
-
-  // highlight search words in search results
-  $("div.context").each(function() {
-    var params = $.getQueryParameters();
-    var terms = (params.q) ? params.q[0].split(/\s+/) : [];
-    var result = $(this);
-    $.each(terms, function() {
-      result.highlightText(this.toLowerCase(), 'highlighted');
-    });
-  });
-
-  // directly open comment window if requested
-  var anchor = document.location.hash;
-  if (anchor.substring(0, 9) == '#comment-') {
-    $('#ao' + anchor.substring(9)).click();
-    document.location.hash = '#s' + anchor.substring(9);
-  }
-});
diff --git a/_templates/layout.html b/_templates/layout.html
deleted file mode 100644
index 0c1a398d8ec..00000000000
--- a/_templates/layout.html
+++ /dev/null
@@ -1,84 +0,0 @@
-{% extends "!layout.html" %}
-
-{% block footer %}
-{{ super() }}
-<script>
-  (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
-  (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
-  m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
-  })(window,document,'script','https://www.google-analytics.com/analytics.js','ga');
-
-  ga('create', 'UA-90545585-2', 'auto');
-  ga('send', 'pageview');
-
-</script>
-
-<script async src="https://www.googletagmanager.com/gtag/js?id=UA-117752657-2"></script>
-
-<script>
-
-  window.dataLayer = window.dataLayer || [];
-
-  function gtag(){dataLayer.push(arguments);}
-
-  gtag('js', new Date());
-  gtag('config', 'UA-117752657-2');
-
-</script>
-
-<script>
-  !function(f,b,e,v,n,t,s)
-  {if(f.fbq)return;n=f.fbq=function(){n.callMethod?
-  n.callMethod.apply(n,arguments):n.queue.push(arguments)};
-  if(!f._fbq)f._fbq=n;n.push=n;n.loaded=!0;n.version='2.0';
-  n.queue=[];t=b.createElement(e);t.async=!0;
-  t.src=v;s=b.getElementsByTagName(e)[0];
-  s.parentNode.insertBefore(t,s)}(window,document,'script',
-  'https://connect.facebook.net/en_US/fbevents.js');
-  fbq('init', '243028289693773');
-  fbq('track', 'PageView');
-
-  $("[data-behavior='call-to-action-event']").on('click', function(){
-    fbq('trackCustom', "Download", {
-      tutorialTitle: $('h1:first').text(),
-      downloadLink: this.href,
-      tutorialLink: window.location.href,
-      downloadTitle: $(this).attr("data-response")
-    });
-    ga('send', {
-      hitType: 'event',
-      eventCategory: 'Download',
-      eventAction: 'click',
-      eventLabel: $(this).attr("data-response")
-    });
-   });
-
-   $("[data-behavior='was-this-helpful-event']").on('click', function(){
-    $(".helpful-question").hide();
-    $(".was-helpful-thank-you").show();
-    fbq('trackCustom', "Was this Helpful?", {
-      tutorialLink: window.location.href,
-      tutorialTitle: $('h1:first').text(),
-      helpful: $(this).attr("data-response")
-    });
-    ga('send', {
-      hitType: 'event',
-      eventCategory: 'Was this Helpful?',
-      eventAction: 'click',
-      eventLabel: $(this).attr("data-response")
-    });
-   });
-
-   if (location.pathname == "/") {
-     $(".helpful-container").hide();
-     $(".hr-bottom").hide();
-   }
-</script>
-
-<noscript>
-  <img height="1" width="1"
-  src="https://www.facebook.com/tr?id=243028289693773&ev=PageView
-  &noscript=1"/>
-</noscript>
-<img height="1" width="1" style="border-style:none;" alt="" src="https://www.googleadservices.com/pagead/conversion/795629140/?label=txkmCPmdtosBENSssfsC&amp;guid=ON&amp;script=0"/>
-{% endblock %}
diff --git a/advanced_source/ONNXLive.rst b/advanced_source/ONNXLive.rst
index 21380e43405..7177522c968 100644
--- a/advanced_source/ONNXLive.rst
+++ b/advanced_source/ONNXLive.rst
@@ -2,172 +2,11 @@
 ONNX Live Tutorial
 ==================
 
-This tutorial will show you to convert a neural style transfer model that has been exported from PyTorch into the Apple CoreML format using ONNX. This will allow you to easily run deep learning models on Apple devices and, in this case, live stream from the camera. 
+This tutorial has been deprecated.
 
-What is ONNX?
--------------
+Redirecting in 3 seconds...
 
-ONNX (Open Neural Network Exchange) is an open format to represent deep learning models. With ONNX, AI developers can more easily move models between state-of-the-art tools and choose the combination that is best for them. ONNX is developed and supported by a community of partners. You can learn more about ONNX and what tools are supported by going to `onnx.ai <https://onnx.ai/>`_.
 
-Tutorial Overview
------------------
+.. raw:: html
 
-This tutorial will walk you through 4 main steps:
-
-
-#. `Download (or train) PyTorch style transfer models`_
-#. `Convert the PyTorch models to ONNX models`_
-#. `Convert the ONNX models to CoreML models`_
-#. `Run the CoreML models in a style transfer iOS App`_
-
-Preparing the Environment
--------------------------
-
-We will be working in a virtualenv in order to avoid conflicts with your local packages.
-We are also using Python 3.6 for this tutorial, but other versions should work as well.
-
-.. code-block:: python
-
-   python3.6 -m venv venv
-   source ./venv/bin/activate
-
-
-You need to install pytorch and the onnx->coreml converter:
-
-.. code-block:: bash
-
-   pip install torchvision onnx-coreml
-
-
-You will also need to install XCode if you want to run the iOS style transfer app on your iPhone.
-You can also convert models in Linux, however to run the iOS app itself, you will need a Mac.
-
-Download (or train) PyTorch style transfer models
--------------------------------------------------
-
-For this tutorial, we will use the style transfer models that are published with pytorch in https://github.com/pytorch/examples/tree/master/fast_neural_style .
-If you would like to use a different PyTorch or ONNX model, feel free to skip this step.
-
-These models are meant for applying style transfer on still images and really not optimized to be fast enough for video. However if we reduce the resolution low enough, they can also work well on videos.
-
-Let's download the models:
-
-.. code-block:: bash
-
-   git clone https://github.com/pytorch/examples
-   cd examples/fast_neural_style
-
-
-If you would like to train the models yourself, the pytorch/examples repository you just cloned has more information on how to do this.
-For now, we'll just download pre-trained models with the script provided by the repository:
-
-.. code-block:: bash
-
-   python download_saved_models.py
-
-
-This script downloads the pre-trained PyTorch models and puts them into the ``saved_models`` folder.
-There should now be 4 files, ``candy.pth``\ , ``mosaic.pth``\ , ``rain_princess.pth`` and ``udnie.pth`` in your directory.
-
-Convert the PyTorch models to ONNX models
------------------------------------------
-
-Now that we have the pre-trained PyTorch models as ``.pth`` files in the ``saved_models`` folder, we will need to convert them to ONNX format.
-The model definition is in the pytorch/examples repository we cloned previously, and with a few lines of python we can export it to ONNX.
-In this case, instead of actually running the neural net, we will call ``torch.onnx._export``\ , which is provided with PyTorch as an api to directly export ONNX formatted models from PyTorch.
-However, in this case we don't even need to do that, because a script already exists ``neural_style/neural_style.py`` that will do this for us.
-You can also take a look at that script if you would like to apply it to other models.
-
-Exporting the ONNX format from PyTorch is essentially tracing your neural network so this api call will internally run the network on 'dummy data' in order to generate the graph.
-For this, it needs an input image to apply the style transfer to which can simply be a blank image.
-However, the pixel size of this image is important, as this will be the size for the exported style transfer model.
-To get good performance, we'll use a resolution of 250x540. Feel free to take a larger resolution if you care less about
-FPS and more about style transfer quality.
-
-Let's use `ImageMagick <https://www.imagemagick.org/>`_ to create a blank image of the resolution we want:
-
-.. code-block:: bash
-
-   convert -size 250x540 xc:white png24:dummy.jpg
-
-
-and use that to export the PyTorch models:
-
-.. code-block:: bash
-
-   python ./neural_style/neural_style.py eval --content-image dummy.jpg --output-image dummy-out.jpg --model ./saved_models/candy.pth --cuda 0 --export_onnx ./saved_models/candy.onnx
-   python ./neural_style/neural_style.py eval --content-image dummy.jpg --output-image dummy-out.jpg --model ./saved_models/udnie.pth --cuda 0 --export_onnx ./saved_models/udnie.onnx
-   python ./neural_style/neural_style.py eval --content-image dummy.jpg --output-image dummy-out.jpg --model ./saved_models/rain_princess.pth --cuda 0 --export_onnx ./saved_models/rain_princess.onnx
-   python ./neural_style/neural_style.py eval --content-image dummy.jpg --output-image dummy-out.jpg --model ./saved_models/mosaic.pth --cuda 0 --export_onnx ./saved_models/mosaic.onnx
-
-
-You should end up with 4 files, ``candy.onnx``\ , ``mosaic.onnx``\ , ``rain_princess.onnx`` and ``udnie.onnx``\ ,
-created from the corresponding ``.pth`` files.
-
-Convert the ONNX models to CoreML models
-----------------------------------------
-
-Now that we have ONNX models, we can convert them to CoreML models in order to run them on Apple devices.
-For this, we use the onnx-coreml converter we installed previously.
-The converter comes with a ``convert-onnx-to-coreml`` script, which the installation steps above added to our path. Unfortunately that won't work for us as we need to mark the input and output of the network as an image
-and, while this is supported by the converter, it is only supported when calling the converter from python.
-
-Looking at the style transfer model (for example opening the .onnx file in an application like `Netron <https://github.com/lutzroeder/Netron>`_\ ),
-we see that the input is named '0' and the output is named '186'. These are just numeric ids assigned by PyTorch.
-We will need to mark these as images.
-
-So let's create a small python file and call it ``onnx_to_coreml.py``. This can be created by using the touch command and edited with your favorite editor to add the following lines of code.
-
-.. code-block:: python
-
-   import sys
-   from onnx import onnx_pb
-   from onnx_coreml import convert
-
-   model_in = sys.argv[1]
-   model_out = sys.argv[2]
-
-   model_file = open(model_in, 'rb')
-   model_proto = onnx_pb.ModelProto()
-   model_proto.ParseFromString(model_file.read())
-   coreml_model = convert(model_proto, image_input_names=['0'], image_output_names=['186'])
-   coreml_model.save(model_out)
-
-
-we now run it:
-
-.. code-block:: bash
-
-   python onnx_to_coreml.py ./saved_models/candy.onnx ./saved_models/candy.mlmodel
-   python onnx_to_coreml.py ./saved_models/udnie.onnx ./saved_models/udnie.mlmodel
-   python onnx_to_coreml.py ./saved_models/rain_princess.onnx ./saved_models/rain_princess.mlmodel
-   python onnx_to_coreml.py ./saved_models/mosaic.onnx ./saved_models/mosaic.mlmodel
-
-
-Now, there should be 4 CoreML models in your ``saved_models`` directory: ``candy.mlmodel``\ , ``mosaic.mlmodel``\ , ``rain_princess.mlmodel`` and ``udnie.mlmodel``.
-
-Run the CoreML models in a style transfer iOS App
--------------------------------------------------
-
-This repository (i.e. the one you're currently reading the README.md of) contains an iOS app able to run CoreML style transfer models on a live camera stream from your phone camera. Let's clone the repository:
-
-.. code-block:: bash
-
-   git clone https://github.com/onnx/tutorials
-
-
-and open the ``tutorials/examples/CoreML/ONNXLive/ONNXLive.xcodeproj`` project in XCode.
-We recommend using XCode 9.3 and an iPhone X. There might be issues running on older devices or XCode versions.
-
-In the ``Models/`` folder, the project contains some .mlmodel files. We're going to replace them with the models we just created.
-
-You then run the app on your iPhone and you are all set. Tapping on the screen switches through the models.
-
-Conclusion
-----------
-
-We hope this tutorial gave you an overview of what ONNX is about and how you can use it to convert neural networks
-between frameworks, in this case neural style transfer models moving from PyTorch to CoreML.
-
-Feel free to experiment with these steps and test them on your own models.
-Please let us know if you hit any issues or want to give feedback. We'd like to hear what you think.
+   <meta http-equiv="Refresh" content="3; url='https://pytorch.org/tutorials/index.html'" />
diff --git a/advanced_source/README.txt b/advanced_source/README.txt
index 50dacb8c362..56f01688089 100644
--- a/advanced_source/README.txt
+++ b/advanced_source/README.txt
@@ -8,11 +8,3 @@ Advanced Tutorials
 2. numpy_extensions_tutorial.py
 	Creating Extensions Using numpy and scipy
 	https://pytorch.org/tutorials/advanced/numpy_extensions_tutorial.html
-
-3. c_extension.rst
-	Custom C Extensions for PyTorch
-	https://pytorch.org/tutorials/advanced/c_extension.html
-
-4. super_resolution_with_caffe2.py
-	Transfering a Model from PyTorch to Caffe2 and Mobile using ONNX
-	https://pytorch.org/tutorials/advanced/super_resolution_with_caffe2.html
diff --git a/advanced_source/coding_ddpg.py b/advanced_source/coding_ddpg.py
new file mode 100644
index 00000000000..90ea4565dab
--- /dev/null
+++ b/advanced_source/coding_ddpg.py
@@ -0,0 +1,1220 @@
+# -*- coding: utf-8 -*-
+"""
+TorchRL objectives: Coding a DDPG loss
+======================================
+**Author**: `Vincent Moens <https://github.com/vmoens>`_
+
+"""
+
+##############################################################################
+# Overview
+# --------
+#
+# TorchRL separates the training of RL algorithms in various pieces that will be
+# assembled in your training script: the environment, the data collection and
+# storage, the model and finally the loss function.
+#
+# TorchRL losses (or "objectives") are stateful objects that contain the
+# trainable parameters (policy and value models).
+# This tutorial will guide you through the steps to code a loss from the ground up
+# using TorchRL.
+#
+# To this aim, we will be focusing on DDPG, which is a relatively straightforward
+# algorithm to code.
+# `Deep Deterministic Policy Gradient <https://arxiv.org/abs/1509.02971>`_ (DDPG)
+# is a simple continuous control algorithm. It consists in learning a
+# parametric value function for an action-observation pair, and
+# then learning a policy that outputs actions that maximize this value
+# function given a certain observation.
+#
+# What you will learn:
+#
+# - how to write a loss module and customize its value estimator;
+# - how to build an environment in TorchRL, including transforms
+#   (for example, data normalization) and parallel execution;
+# - how to design a policy and value network;
+# - how to collect data from your environment efficiently and store them
+#   in a replay buffer;
+# - how to store trajectories (and not transitions) in your replay buffer);
+# - how to evaluate your model.
+#
+# Prerequisites
+# ~~~~~~~~~~~~~
+#
+# This tutorial assumes that you have completed the
+# `PPO tutorial <reinforcement_ppo.html>`_ which gives
+# an overview of the TorchRL components and dependencies, such as
+# :class:`tensordict.TensorDict` and :class:`tensordict.nn.TensorDictModules`,
+# although it should be
+# sufficiently transparent to be understood without a deep understanding of
+# these classes.
+#
+# .. note::
+#   We do not aim at giving a SOTA implementation of the algorithm, but rather
+#   to provide a high-level illustration of TorchRL's loss implementations
+#   and the library features that are to be used in the context of
+#   this algorithm.
+#
+# Imports and setup
+# -----------------
+#
+#  .. code-block:: bash
+#
+#      %%bash
+#      pip3 install torchrl mujoco glfw
+
+# sphinx_gallery_start_ignore
+import warnings
+
+warnings.filterwarnings("ignore")
+from torch import multiprocessing
+
+# TorchRL prefers spawn method, that restricts creation of  ``~torchrl.envs.ParallelEnv`` inside
+# `__main__` method call, but for the easy of reading the code switch to fork
+# which is also a default spawn method in Google's Colaboratory
+try:
+    multiprocessing.set_start_method("fork")
+except RuntimeError:
+    pass
+
+# sphinx_gallery_end_ignore
+
+
+import torch
+import tqdm
+
+
+###############################################################################
+# We will execute the policy on CUDA if available
+is_fork = multiprocessing.get_start_method() == "fork"
+device = (
+    torch.device(0)
+    if torch.cuda.is_available() and not is_fork
+    else torch.device("cpu")
+)
+collector_device = torch.device("cpu")  # Change the device to ``cuda`` to use CUDA
+
+###############################################################################
+# TorchRL :class:`~torchrl.objectives.LossModule`
+# -----------------------------------------------
+#
+# TorchRL provides a series of losses to use in your training scripts.
+# The aim is to have losses that are easily reusable/swappable and that have
+# a simple signature.
+#
+# The main characteristics of TorchRL losses are:
+#
+# - They are stateful objects: they contain a copy of the trainable parameters
+#   such that ``loss_module.parameters()`` gives whatever is needed to train the
+#   algorithm.
+# - They follow the ``TensorDict`` convention: the :meth:`torch.nn.Module.forward`
+#   method will receive a TensorDict as input that contains all the necessary
+#   information to return a loss value.
+#
+#       >>> data = replay_buffer.sample()
+#       >>> loss_dict = loss_module(data)
+#
+# - They output a :class:`tensordict.TensorDict` instance with the loss values
+#   written under a ``"loss_<smth>"`` where ``smth`` is a string describing the
+#   loss. Additional keys in the ``TensorDict`` may be useful metrics to log during
+#   training time.
+#
+#   .. note::
+#     The reason we return independent losses is to let the user use a different
+#     optimizer for different sets of parameters for instance. Summing the losses
+#     can be simply done via
+#
+#       >>> loss_val = sum(loss for key, loss in loss_dict.items() if key.startswith("loss_"))
+#
+# The ``__init__`` method
+# ~~~~~~~~~~~~~~~~~~~~~~~
+#
+# The parent class of all losses is :class:`~torchrl.objectives.LossModule`.
+# As many other components of the library, its :meth:`~torchrl.objectives.LossModule.forward` method expects
+# as input a :class:`tensordict.TensorDict` instance sampled from an experience
+# replay buffer, or any similar data structure. Using this format makes it
+# possible to re-use the module across
+# modalities, or in complex settings where the model needs to read multiple
+# entries for instance. In other words, it allows us to code a loss module that
+# is oblivious to the data type that is being given to is and that focuses on
+# running the elementary steps of the loss function and only those.
+#
+# To keep the tutorial as didactic as we can, we'll be displaying each method
+# of the class independently and we'll be populating the class at a later
+# stage.
+#
+# Let us start with the :meth:`~torchrl.objectives.LossModule.__init__`
+# method. DDPG aims at solving a control task with a simple strategy:
+# training a policy to output actions that maximize the value predicted by
+# a value network. Hence, our loss module needs to receive two networks in its
+# constructor: an actor and a value networks. We expect both of these to be
+# TensorDict-compatible objects, such as
+# :class:`tensordict.nn.TensorDictModule`.
+# Our loss function will need to compute a target value and fit the value
+# network to this, and generate an action and fit the policy such that its
+# value estimate is maximized.
+#
+# The crucial step of the :meth:`LossModule.__init__` method is the call to
+# :meth:`~torchrl.LossModule.convert_to_functional`. This method will extract
+# the parameters from the module and convert it to a functional module.
+# Strictly speaking, this is not necessary and one may perfectly code all
+# the losses without it. However, we encourage its usage for the following
+# reason.
+#
+# The reason TorchRL does this is that RL algorithms often execute the same
+# model with different sets of parameters, called "trainable" and "target"
+# parameters.
+# The "trainable" parameters are those that the optimizer needs to fit. The
+# "target" parameters are usually a copy of the former's with some time lag
+# (absolute or diluted through a moving average).
+# These target parameters are used to compute the value associated with the
+# next observation. One the advantages of using a set of target parameters
+# for the value model that do not match exactly the current configuration is
+# that they provide a pessimistic bound on the value function being computed.
+# Pay attention to the ``create_target_params`` keyword argument below: this
+# argument tells the :meth:`~torchrl.objectives.LossModule.convert_to_functional`
+# method to create a set of target parameters in the loss module to be used
+# for target value computation. If this is set to ``False`` (see the actor network
+# for instance) the ``target_actor_network_params`` attribute will still be
+# accessible but this will just return a **detached** version of the
+# actor parameters.
+#
+# Later, we will see how the target parameters should be updated in TorchRL.
+#
+
+from tensordict.nn import TensorDictModule, TensorDictSequential
+
+
+def _init(
+    self,
+    actor_network: TensorDictModule,
+    value_network: TensorDictModule,
+) -> None:
+    super(type(self), self).__init__()
+
+    self.convert_to_functional(
+        actor_network,
+        "actor_network",
+        create_target_params=True,
+    )
+    self.convert_to_functional(
+        value_network,
+        "value_network",
+        create_target_params=True,
+        compare_against=list(actor_network.parameters()),
+    )
+
+    self.actor_in_keys = actor_network.in_keys
+
+    # Since the value we'll be using is based on the actor and value network,
+    # we put them together in a single actor-critic container.
+    actor_critic = ActorCriticWrapper(actor_network, value_network)
+    self.actor_critic = actor_critic
+    self.loss_function = "l2"
+
+
+###############################################################################
+# The value estimator loss method
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# In many RL algorithm, the value network (or Q-value network) is trained based
+# on an empirical value estimate. This can be bootstrapped (TD(0), low
+# variance, high bias), meaning
+# that the target value is obtained using the next reward and nothing else, or
+# a Monte-Carlo estimate can be obtained (TD(1)) in which case the whole
+# sequence of upcoming rewards will be used (high variance, low bias). An
+# intermediate estimator (TD(:math:`\lambda`)) can also be used to compromise
+# bias and variance.
+# TorchRL makes it easy to use one or the other estimator via the
+# :class:`~torchrl.objectives.utils.ValueEstimators` Enum class, which contains
+# pointers to all the value estimators implemented. Let us define the default
+# value function here. We will take the simplest version (TD(0)), and show later
+# on how this can be changed.
+
+from torchrl.objectives.utils import ValueEstimators
+
+default_value_estimator = ValueEstimators.TD0
+
+###############################################################################
+# We also need to give some instructions to DDPG on how to build the value
+# estimator, depending on the user query. Depending on the estimator provided,
+# we will build the corresponding module to be used at train time:
+
+from torchrl.objectives.utils import default_value_kwargs
+from torchrl.objectives.value import TD0Estimator, TD1Estimator, TDLambdaEstimator
+
+
+def make_value_estimator(self, value_type: ValueEstimators, **hyperparams):
+    hp = dict(default_value_kwargs(value_type))
+    if hasattr(self, "gamma"):
+        hp["gamma"] = self.gamma
+    hp.update(hyperparams)
+    value_key = "state_action_value"
+    if value_type == ValueEstimators.TD1:
+        self._value_estimator = TD1Estimator(value_network=self.actor_critic, **hp)
+    elif value_type == ValueEstimators.TD0:
+        self._value_estimator = TD0Estimator(value_network=self.actor_critic, **hp)
+    elif value_type == ValueEstimators.GAE:
+        raise NotImplementedError(
+            f"Value type {value_type} it not implemented for loss {type(self)}."
+        )
+    elif value_type == ValueEstimators.TDLambda:
+        self._value_estimator = TDLambdaEstimator(value_network=self.actor_critic, **hp)
+    else:
+        raise NotImplementedError(f"Unknown value type {value_type}")
+    self._value_estimator.set_keys(value=value_key)
+
+
+###############################################################################
+# The ``make_value_estimator`` method can but does not need to be called: if
+# not, the :class:`~torchrl.objectives.LossModule` will query this method with
+# its default estimator.
+#
+# The actor loss method
+# ~~~~~~~~~~~~~~~~~~~~~
+#
+# The central piece of an RL algorithm is the training loss for the actor.
+# In the case of DDPG, this function is quite simple: we just need to compute
+# the value associated with an action computed using the policy and optimize
+# the actor weights to maximize this value.
+#
+# When computing this value, we must make sure to take the value parameters out
+# of the graph, otherwise the actor and value loss will be mixed up.
+# For this, the :func:`~torchrl.objectives.utils.hold_out_params` function
+# can be used.
+
+
+def _loss_actor(
+    self,
+    tensordict,
+) -> torch.Tensor:
+    td_copy = tensordict.select(*self.actor_in_keys)
+    # Get an action from the actor network: since we made it functional, we need to pass the params
+    with self.actor_network_params.to_module(self.actor_network):
+        td_copy = self.actor_network(td_copy)
+    # get the value associated with that action
+    with self.value_network_params.detach().to_module(self.value_network):
+        td_copy = self.value_network(td_copy)
+    return -td_copy.get("state_action_value")
+
+
+###############################################################################
+# The value loss method
+# ~~~~~~~~~~~~~~~~~~~~~
+#
+# We now need to optimize our value network parameters.
+# To do this, we will rely on the value estimator of our class:
+#
+
+from torchrl.objectives.utils import distance_loss
+
+
+def _loss_value(
+    self,
+    tensordict,
+):
+    td_copy = tensordict.clone()
+
+    # V(s, a)
+    with self.value_network_params.to_module(self.value_network):
+        self.value_network(td_copy)
+    pred_val = td_copy.get("state_action_value").squeeze(-1)
+
+    # we manually reconstruct the parameters of the actor-critic, where the first
+    # set of parameters belongs to the actor and the second to the value function.
+    target_params = TensorDict(
+        {
+            "module": {
+                "0": self.target_actor_network_params,
+                "1": self.target_value_network_params,
+            }
+        },
+        batch_size=self.target_actor_network_params.batch_size,
+        device=self.target_actor_network_params.device,
+    )
+    with target_params.to_module(self.actor_critic):
+        target_value = self.value_estimator.value_estimate(tensordict).squeeze(-1)
+
+    # Computes the value loss: L2, L1 or smooth L1 depending on `self.loss_function`
+    loss_value = distance_loss(pred_val, target_value, loss_function=self.loss_function)
+    td_error = (pred_val - target_value).pow(2)
+
+    return loss_value, td_error, pred_val, target_value
+
+
+###############################################################################
+# Putting things together in a forward call
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# The only missing piece is the forward method, which will glue together the
+# value and actor loss, collect the cost values and write them in a ``TensorDict``
+# delivered to the user.
+
+from tensordict import TensorDict, TensorDictBase
+
+
+def _forward(self, input_tensordict: TensorDictBase) -> TensorDict:
+    loss_value, td_error, pred_val, target_value = self.loss_value(
+        input_tensordict,
+    )
+    td_error = td_error.detach()
+    td_error = td_error.unsqueeze(input_tensordict.ndimension())
+    if input_tensordict.device is not None:
+        td_error = td_error.to(input_tensordict.device)
+    input_tensordict.set(
+        "td_error",
+        td_error,
+        inplace=True,
+    )
+    loss_actor = self.loss_actor(input_tensordict)
+    return TensorDict(
+        source={
+            "loss_actor": loss_actor.mean(),
+            "loss_value": loss_value.mean(),
+            "pred_value": pred_val.mean().detach(),
+            "target_value": target_value.mean().detach(),
+            "pred_value_max": pred_val.max().detach(),
+            "target_value_max": target_value.max().detach(),
+        },
+        batch_size=[],
+    )
+
+
+from torchrl.objectives import LossModule
+
+
+class DDPGLoss(LossModule):
+    default_value_estimator = default_value_estimator
+    make_value_estimator = make_value_estimator
+
+    __init__ = _init
+    forward = _forward
+    loss_value = _loss_value
+    loss_actor = _loss_actor
+
+
+###############################################################################
+# Now that we have our loss, we can use it to train a policy to solve a
+# control task.
+#
+# Environment
+# -----------
+#
+# In most algorithms, the first thing that needs to be taken care of is the
+# construction of the environment as it conditions the remainder of the
+# training script.
+#
+# For this example, we will be using the ``"cheetah"`` task. The goal is to make
+# a half-cheetah run as fast as possible.
+#
+# In TorchRL, one can create such a task by relying on ``dm_control`` or ``gym``:
+#
+# .. code-block:: python
+#
+#    env = GymEnv("HalfCheetah-v4")
+#
+# or
+#
+# .. code-block:: python
+#
+#    env = DMControlEnv("cheetah", "run")
+#
+# By default, these environment disable rendering. Training from states is
+# usually easier than training from images. To keep things simple, we focus
+# on learning from states only. To pass the pixels to the ``tensordicts`` that
+# are collected by :func:`env.step()`, simply pass the ``from_pixels=True``
+# argument to the constructor:
+#
+# .. code-block:: python
+#
+#    env = GymEnv("HalfCheetah-v4", from_pixels=True, pixels_only=True)
+#
+# We write a :func:`make_env` helper function that will create an environment
+# with either one of the two backends considered above (``dm-control`` or ``gym``).
+#
+
+from torchrl.envs.libs.dm_control import DMControlEnv
+from torchrl.envs.libs.gym import GymEnv
+
+env_library = None
+env_name = None
+
+
+def make_env(from_pixels=False):
+    """Create a base ``env``."""
+    global env_library
+    global env_name
+
+    if backend == "dm_control":
+        env_name = "cheetah"
+        env_task = "run"
+        env_args = (env_name, env_task)
+        env_library = DMControlEnv
+    elif backend == "gym":
+        env_name = "HalfCheetah-v4"
+        env_args = (env_name,)
+        env_library = GymEnv
+    else:
+        raise NotImplementedError
+
+    env_kwargs = {
+        "device": device,
+        "from_pixels": from_pixels,
+        "pixels_only": from_pixels,
+        "frame_skip": 2,
+    }
+    env = env_library(*env_args, **env_kwargs)
+    return env
+
+
+###############################################################################
+# Transforms
+# ~~~~~~~~~~
+#
+# Now that we have a base environment, we may want to modify its representation
+# to make it more policy-friendly. In TorchRL, transforms are appended to the
+# base environment in a specialized :class:`torchr.envs.TransformedEnv` class.
+#
+# - It is common in DDPG to rescale the reward using some heuristic value. We
+#   will multiply the reward by 5 in this example.
+#
+# - If we are using :mod:`dm_control`, it is also important to build an interface
+#   between the simulator which works with double precision numbers, and our
+#   script which presumably uses single precision ones. This transformation goes
+#   both ways: when calling :func:`env.step`, our actions will need to be
+#   represented in double precision, and the output will need to be transformed
+#   to single precision.
+#   The :class:`~torchrl.envs.DoubleToFloat` transform does exactly this: the
+#   ``in_keys`` list refers to the keys that will need to be transformed from
+#   double to float, while the ``in_keys_inv`` refers to those that need to
+#   be transformed to double before being passed to the environment.
+#
+# - We concatenate the state keys together using the :class:`~torchrl.envs.CatTensors`
+#   transform.
+#
+# - Finally, we also leave the possibility of normalizing the states: we will
+#   take care of computing the normalizing constants later on.
+#
+
+from torchrl.envs import (
+    CatTensors,
+    DoubleToFloat,
+    EnvCreator,
+    InitTracker,
+    ObservationNorm,
+    ParallelEnv,
+    RewardScaling,
+    StepCounter,
+    TransformedEnv,
+)
+
+
+def make_transformed_env(
+    env,
+):
+    """Apply transforms to the ``env`` (such as reward scaling and state normalization)."""
+
+    env = TransformedEnv(env)
+
+    # we append transforms one by one, although we might as well create the
+    # transformed environment using the `env = TransformedEnv(base_env, transforms)`
+    # syntax.
+    env.append_transform(RewardScaling(loc=0.0, scale=reward_scaling))
+
+    # We concatenate all states into a single "observation_vector"
+    # even if there is a single tensor, it'll be renamed in "observation_vector".
+    # This facilitates the downstream operations as we know the name of the
+    # output tensor.
+    # In some environments (not half-cheetah), there may be more than one
+    # observation vector: in this case this code snippet will concatenate them
+    # all.
+    selected_keys = list(env.observation_spec.keys())
+    out_key = "observation_vector"
+    env.append_transform(CatTensors(in_keys=selected_keys, out_key=out_key))
+
+    # we normalize the states, but for now let's just instantiate a stateless
+    # version of the transform
+    env.append_transform(ObservationNorm(in_keys=[out_key], standard_normal=True))
+
+    env.append_transform(DoubleToFloat())
+
+    env.append_transform(StepCounter(max_frames_per_traj))
+
+    # We need a marker for the start of trajectories for our Ornstein-Uhlenbeck (OU)
+    # exploration:
+    env.append_transform(InitTracker())
+
+    return env
+
+
+###############################################################################
+# Parallel execution
+# ~~~~~~~~~~~~~~~~~~
+#
+# The following helper function allows us to run environments in parallel.
+# Running environments in parallel can significantly speed up the collection
+# throughput. When using transformed environment, we need to choose whether we
+# want to execute the transform individually for each environment, or
+# centralize the data and transform it in batch. Both approaches are easy to
+# code:
+#
+# .. code-block:: python
+#
+#    env = ParallelEnv(
+#        lambda: TransformedEnv(GymEnv("HalfCheetah-v4"), transforms),
+#        num_workers=4
+#    )
+#    env = TransformedEnv(
+#        ParallelEnv(lambda: GymEnv("HalfCheetah-v4"), num_workers=4),
+#        transforms
+#    )
+#
+# To leverage the vectorization capabilities of PyTorch, we adopt
+# the first method:
+#
+
+
+def parallel_env_constructor(
+    env_per_collector,
+    transform_state_dict,
+):
+    if env_per_collector == 1:
+
+        def make_t_env():
+            env = make_transformed_env(make_env())
+            env.transform[2].init_stats(3)
+            env.transform[2].loc.copy_(transform_state_dict["loc"])
+            env.transform[2].scale.copy_(transform_state_dict["scale"])
+            return env
+
+        env_creator = EnvCreator(make_t_env)
+        return env_creator
+
+    parallel_env = ParallelEnv(
+        num_workers=env_per_collector,
+        create_env_fn=EnvCreator(lambda: make_env()),
+        create_env_kwargs=None,
+        pin_memory=False,
+    )
+    env = make_transformed_env(parallel_env)
+    # we call `init_stats` for a limited number of steps, just to instantiate
+    # the lazy buffers.
+    env.transform[2].init_stats(3, cat_dim=1, reduce_dim=[0, 1])
+    env.transform[2].load_state_dict(transform_state_dict)
+    return env
+
+
+# The backend can be ``gym`` or ``dm_control``
+backend = "gym"
+
+###############################################################################
+# .. note::
+#
+#   ``frame_skip`` batches multiple step together with a single action
+#   If > 1, the other frame counts (for example, frames_per_batch, total_frames)
+#   need to be adjusted to have a consistent total number of frames collected
+#   across experiments. This is important as raising the frame-skip but keeping the
+#   total number of frames unchanged may seem like cheating: all things compared,
+#   a dataset of 10M elements collected with a frame-skip of 2 and another with
+#   a frame-skip of 1 actually have a ratio of interactions with the environment
+#   of 2:1! In a nutshell, one should be cautious about the frame-count of a
+#   training script when dealing with frame skipping as this may lead to
+#   biased comparisons between training strategies.
+#
+# Scaling the reward helps us control the signal magnitude for a more
+# efficient learning.
+reward_scaling = 5.0
+
+###############################################################################
+# We also define when a trajectory will be truncated. A thousand steps (500 if
+# frame-skip = 2) is a good number to use for the cheetah task:
+
+max_frames_per_traj = 500
+
+###############################################################################
+# Normalization of the observations
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# To compute the normalizing statistics, we run an arbitrary number of random
+# steps in the environment and compute the mean and standard deviation of the
+# collected observations. The :func:`ObservationNorm.init_stats()` method can
+# be used for this purpose. To get the summary statistics, we create a dummy
+# environment and run it for a given number of steps, collect data over a given
+# number of steps and compute its summary statistics.
+#
+
+
+def get_env_stats():
+    """Gets the stats of an environment."""
+    proof_env = make_transformed_env(make_env())
+    t = proof_env.transform[2]
+    t.init_stats(init_env_steps)
+    transform_state_dict = t.state_dict()
+    proof_env.close()
+    return transform_state_dict
+
+
+###############################################################################
+# Normalization stats
+# ~~~~~~~~~~~~~~~~~~~
+# Number of random steps used as for stats computation using ``ObservationNorm``
+
+init_env_steps = 5000
+
+transform_state_dict = get_env_stats()
+
+###############################################################################
+# Number of environments in each data collector
+env_per_collector = 4
+
+###############################################################################
+# We pass the stats computed earlier to normalize the output of our
+# environment:
+
+parallel_env = parallel_env_constructor(
+    env_per_collector=env_per_collector,
+    transform_state_dict=transform_state_dict,
+)
+
+
+from torchrl.data import CompositeSpec
+
+###############################################################################
+# Building the model
+# ------------------
+#
+# We now turn to the setup of the model. As we have seen, DDPG requires a
+# value network, trained to estimate the value of a state-action pair, and a
+# parametric actor that learns how to select actions that maximize this value.
+#
+# Recall that building a TorchRL module requires two steps:
+#
+# - writing the :class:`torch.nn.Module` that will be used as network,
+# - wrapping the network in a :class:`tensordict.nn.TensorDictModule` where the
+#   data flow is handled by specifying the input and output keys.
+#
+# In more complex scenarios, :class:`tensordict.nn.TensorDictSequential` can
+# also be used.
+#
+#
+# The Q-Value network is wrapped in a :class:`~torchrl.modules.ValueOperator`
+# that automatically sets the ``out_keys`` to ``"state_action_value`` for q-value
+# networks and ``state_value`` for other value networks.
+#
+# TorchRL provides a built-in version of the DDPG networks as presented in the
+# original paper. These can be found under :class:`~torchrl.modules.DdpgMlpActor`
+# and :class:`~torchrl.modules.DdpgMlpQNet`.
+#
+# Since we use lazy modules, it is necessary to materialize the lazy modules
+# before being able to move the policy from device to device and achieve other
+# operations. Hence, it is good practice to run the modules with a small
+# sample of data. For this purpose, we generate fake data from the
+# environment specs.
+#
+
+from torchrl.modules import (
+    ActorCriticWrapper,
+    DdpgMlpActor,
+    DdpgMlpQNet,
+    OrnsteinUhlenbeckProcessModule,
+    ProbabilisticActor,
+    TanhDelta,
+    ValueOperator,
+)
+
+
+def make_ddpg_actor(
+    transform_state_dict,
+    device="cpu",
+):
+    proof_environment = make_transformed_env(make_env())
+    proof_environment.transform[2].init_stats(3)
+    proof_environment.transform[2].load_state_dict(transform_state_dict)
+
+    out_features = proof_environment.action_spec.shape[-1]
+
+    actor_net = DdpgMlpActor(
+        action_dim=out_features,
+    )
+
+    in_keys = ["observation_vector"]
+    out_keys = ["param"]
+
+    actor = TensorDictModule(
+        actor_net,
+        in_keys=in_keys,
+        out_keys=out_keys,
+    )
+
+    actor = ProbabilisticActor(
+        actor,
+        distribution_class=TanhDelta,
+        in_keys=["param"],
+        spec=CompositeSpec(action=proof_environment.action_spec),
+    ).to(device)
+
+    q_net = DdpgMlpQNet()
+
+    in_keys = in_keys + ["action"]
+    qnet = ValueOperator(
+        in_keys=in_keys,
+        module=q_net,
+    ).to(device)
+
+    # initialize lazy modules
+    qnet(actor(proof_environment.reset().to(device)))
+    return actor, qnet
+
+
+actor, qnet = make_ddpg_actor(
+    transform_state_dict=transform_state_dict,
+    device=device,
+)
+
+###############################################################################
+# Exploration
+# ~~~~~~~~~~~
+#
+# The policy is passed into a :class:`~torchrl.modules.OrnsteinUhlenbeckProcessModule`
+# exploration module, as suggested in the original paper.
+# Let's define the number of frames before OU noise reaches its minimum value
+annealing_frames = 1_000_000
+
+actor_model_explore = TensorDictSequential(
+    actor,
+    OrnsteinUhlenbeckProcessModule(
+        spec=actor.spec.clone(),
+        annealing_num_steps=annealing_frames,
+    ).to(device),
+)
+if device == torch.device("cpu"):
+    actor_model_explore.share_memory()
+
+
+###############################################################################
+# Data collector
+# --------------
+#
+# TorchRL provides specialized classes to help you collect data by executing
+# the policy in the environment. These "data collectors" iteratively compute
+# the action to be executed at a given time, then execute a step in the
+# environment and reset it when required.
+# Data collectors are designed to help developers have a tight control
+# on the number of frames per batch of data, on the (a)sync nature of this
+# collection and on the resources allocated to the data collection (for example
+# GPU, number of workers, and so on).
+#
+# Here we will use
+# :class:`~torchrl.collectors.SyncDataCollector`, a simple, single-process
+# data collector. TorchRL offers other collectors, such as
+# :class:`~torchrl.collectors.MultiaSyncDataCollector`, which executed the
+# rollouts in an asynchronous manner (for example, data will be collected while
+# the policy is being optimized, thereby decoupling the training and
+# data collection).
+#
+# The parameters to specify are:
+#
+# - an environment factory or an environment,
+# - the policy,
+# - the total number of frames before the collector is considered empty,
+# - the maximum number of frames per trajectory (useful for non-terminating
+#   environments, like ``dm_control`` ones).
+#
+#   .. note::
+#
+#     The ``max_frames_per_traj`` passed to the collector will have the effect
+#     of registering a new :class:`~torchrl.envs.StepCounter` transform
+#     with the environment used for inference. We can achieve the same result
+#     manually, as we do in this script.
+#
+# One should also pass:
+#
+# - the number of frames in each batch collected,
+# - the number of random steps executed independently from the policy,
+# - the devices used for policy execution
+# - the devices used to store data before the data is passed to the main
+#   process.
+#
+# The total frames we will use during training should be around 1M.
+total_frames = 10_000  # 1_000_000
+
+###############################################################################
+# The number of frames returned by the collector at each iteration of the outer
+# loop is equal to the length of each sub-trajectories times the number of
+# environments run in parallel in each collector.
+#
+# In other words, we expect batches from the collector to have a shape
+# ``[env_per_collector, traj_len]`` where
+# ``traj_len=frames_per_batch/env_per_collector``:
+#
+traj_len = 200
+frames_per_batch = env_per_collector * traj_len
+init_random_frames = 5000
+num_collectors = 2
+
+from torchrl.collectors import SyncDataCollector
+from torchrl.envs import ExplorationType
+
+collector = SyncDataCollector(
+    parallel_env,
+    policy=actor_model_explore,
+    total_frames=total_frames,
+    frames_per_batch=frames_per_batch,
+    init_random_frames=init_random_frames,
+    reset_at_each_iter=False,
+    split_trajs=False,
+    device=collector_device,
+    exploration_type=ExplorationType.RANDOM,
+)
+
+###############################################################################
+# Evaluator: building your recorder object
+# ----------------------------------------
+#
+# As the training data is obtained using some exploration strategy, the true
+# performance of our algorithm needs to be assessed in deterministic mode. We
+# do this using a dedicated class, ``Recorder``, which executes the policy in
+# the environment at a given frequency and returns some statistics obtained
+# from these simulations.
+#
+# The following helper function builds this object:
+from torchrl.trainers import Recorder
+
+
+def make_recorder(actor_model_explore, transform_state_dict, record_interval):
+    base_env = make_env()
+    environment = make_transformed_env(base_env)
+    environment.transform[2].init_stats(
+        3
+    )  # must be instantiated to load the state dict
+    environment.transform[2].load_state_dict(transform_state_dict)
+
+    recorder_obj = Recorder(
+        record_frames=1000,
+        policy_exploration=actor_model_explore,
+        environment=environment,
+        exploration_type=ExplorationType.DETERMINISTIC,
+        record_interval=record_interval,
+    )
+    return recorder_obj
+
+
+###############################################################################
+# We will be recording the performance every 10 batch collected
+record_interval = 10
+
+recorder = make_recorder(
+    actor_model_explore, transform_state_dict, record_interval=record_interval
+)
+
+from torchrl.data.replay_buffers import (
+    LazyMemmapStorage,
+    PrioritizedSampler,
+    RandomSampler,
+    TensorDictReplayBuffer,
+)
+
+###############################################################################
+# Replay buffer
+# -------------
+#
+# Replay buffers come in two flavors: prioritized (where some error signal
+# is used to give a higher likelihood of sampling to some items than others)
+# and regular, circular experience replay.
+#
+# TorchRL replay buffers are composable: one can pick up the storage, sampling
+# and writing strategies. It is also possible to
+# store tensors on physical memory using a memory-mapped array. The following
+# function takes care of creating the replay buffer with the desired
+# hyperparameters:
+#
+
+from torchrl.envs import RandomCropTensorDict
+
+
+def make_replay_buffer(buffer_size, batch_size, random_crop_len, prefetch=3, prb=False):
+    if prb:
+        sampler = PrioritizedSampler(
+            max_capacity=buffer_size,
+            alpha=0.7,
+            beta=0.5,
+        )
+    else:
+        sampler = RandomSampler()
+    replay_buffer = TensorDictReplayBuffer(
+        storage=LazyMemmapStorage(
+            buffer_size,
+            scratch_dir=buffer_scratch_dir,
+        ),
+        batch_size=batch_size,
+        sampler=sampler,
+        pin_memory=False,
+        prefetch=prefetch,
+        transform=RandomCropTensorDict(random_crop_len, sample_dim=1),
+    )
+    return replay_buffer
+
+
+###############################################################################
+# We'll store the replay buffer in a temporary directory on disk
+
+import tempfile
+
+tmpdir = tempfile.TemporaryDirectory()
+buffer_scratch_dir = tmpdir.name
+
+###############################################################################
+# Replay buffer storage and batch size
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# TorchRL replay buffer counts the number of elements along the first dimension.
+# Since we'll be feeding trajectories to our buffer, we need to adapt the buffer
+# size by dividing it by the length of the sub-trajectories yielded by our
+# data collector.
+# Regarding the batch-size, our sampling strategy will consist in sampling
+# trajectories of length ``traj_len=200`` before selecting sub-trajectories
+# or length ``random_crop_len=25`` on which the loss will be computed.
+# This strategy balances the choice of storing whole trajectories of a certain
+# length with the need for providing samples with a sufficient heterogeneity
+# to our loss. The following figure shows the dataflow from a collector
+# that gets 8 frames in each batch with 2 environments run in parallel,
+# feeds them to a replay buffer that contains 1000 trajectories and
+# samples sub-trajectories of 2 time steps each.
+#
+# .. figure:: /_static/img/replaybuffer_traj.png
+#    :alt: Storing trajectories in the replay buffer
+#
+# Let's start with the number of frames stored in the buffer
+
+
+def ceil_div(x, y):
+    return -x // (-y)
+
+
+buffer_size = 1_000_000
+buffer_size = ceil_div(buffer_size, traj_len)
+
+###############################################################################
+# Prioritized replay buffer is disabled by default
+prb = False
+
+###############################################################################
+# We also need to define how many updates we'll be doing per batch of data
+# collected. This is known as the update-to-data or ``UTD`` ratio:
+update_to_data = 64
+
+###############################################################################
+# We'll be feeding the loss with trajectories of length 25:
+random_crop_len = 25
+
+###############################################################################
+# In the original paper, the authors perform one update with a batch of 64
+# elements for each frame collected. Here, we reproduce the same ratio
+# but while realizing several updates at each batch collection. We
+# adapt our batch-size to achieve the same number of update-per-frame ratio:
+
+batch_size = ceil_div(64 * frames_per_batch, update_to_data * random_crop_len)
+
+replay_buffer = make_replay_buffer(
+    buffer_size=buffer_size,
+    batch_size=batch_size,
+    random_crop_len=random_crop_len,
+    prefetch=3,
+    prb=prb,
+)
+
+###############################################################################
+# Loss module construction
+# ------------------------
+#
+# We build our loss module with the actor and ``qnet`` we've just created.
+# Because we have target parameters to update, we _must_ create a target network
+# updater.
+#
+
+gamma = 0.99
+lmbda = 0.9
+tau = 0.001  # Decay factor for the target network
+
+loss_module = DDPGLoss(actor, qnet)
+
+###############################################################################
+# let's use the TD(lambda) estimator!
+loss_module.make_value_estimator(ValueEstimators.TDLambda, gamma=gamma, lmbda=lmbda, device=device)
+
+###############################################################################
+# .. note::
+#   Off-policy usually dictates a TD(0) estimator. Here, we use a TD(:math:`\lambda`)
+#   estimator, which will introduce some bias as the trajectory that follows
+#   a certain state has been collected with an outdated policy.
+#   This trick, as the multi-step trick that can be used during data collection,
+#   are alternative versions of "hacks" that we usually find to work well in
+#   practice despite the fact that they introduce some bias in the return
+#   estimates.
+#
+# Target network updater
+# ~~~~~~~~~~~~~~~~~~~~~~
+#
+# Target networks are a crucial part of off-policy RL algorithms.
+# Updating the target network parameters is made easy thanks to the
+# :class:`~torchrl.objectives.HardUpdate` and :class:`~torchrl.objectives.SoftUpdate`
+# classes. They're built with the loss module as argument, and the update is
+# achieved via a call to `updater.step()` at the appropriate location in the
+# training loop.
+
+from torchrl.objectives.utils import SoftUpdate
+
+target_net_updater = SoftUpdate(loss_module, eps=1 - tau)
+
+###############################################################################
+# Optimizer
+# ~~~~~~~~~
+#
+# Finally, we will use the Adam optimizer for the policy and value network:
+
+from torch import optim
+
+optimizer_actor = optim.Adam(
+    loss_module.actor_network_params.values(True, True), lr=1e-4, weight_decay=0.0
+)
+optimizer_value = optim.Adam(
+    loss_module.value_network_params.values(True, True), lr=1e-3, weight_decay=1e-2
+)
+total_collection_steps = total_frames // frames_per_batch
+
+###############################################################################
+# Time to train the policy
+# ------------------------
+#
+# The training loop is pretty straightforward now that we have built all the
+# modules we need.
+#
+
+rewards = []
+rewards_eval = []
+
+# Main loop
+
+collected_frames = 0
+pbar = tqdm.tqdm(total=total_frames)
+r0 = None
+for i, tensordict in enumerate(collector):
+
+    # update weights of the inference policy
+    collector.update_policy_weights_()
+
+    if r0 is None:
+        r0 = tensordict["next", "reward"].mean().item()
+    pbar.update(tensordict.numel())
+
+    # extend the replay buffer with the new data
+    current_frames = tensordict.numel()
+    collected_frames += current_frames
+    replay_buffer.extend(tensordict.cpu())
+
+    # optimization steps
+    if collected_frames >= init_random_frames:
+        for _ in range(update_to_data):
+            # sample from replay buffer
+            sampled_tensordict = replay_buffer.sample().to(device)
+
+            # Compute loss
+            loss_dict = loss_module(sampled_tensordict)
+
+            # optimize
+            loss_dict["loss_actor"].backward()
+            gn1 = torch.nn.utils.clip_grad_norm_(
+                loss_module.actor_network_params.values(True, True), 10.0
+            )
+            optimizer_actor.step()
+            optimizer_actor.zero_grad()
+
+            loss_dict["loss_value"].backward()
+            gn2 = torch.nn.utils.clip_grad_norm_(
+                loss_module.value_network_params.values(True, True), 10.0
+            )
+            optimizer_value.step()
+            optimizer_value.zero_grad()
+
+            gn = (gn1**2 + gn2**2) ** 0.5
+
+            # update priority
+            if prb:
+                replay_buffer.update_tensordict_priority(sampled_tensordict)
+            # update target network
+            target_net_updater.step()
+
+    rewards.append(
+        (
+            i,
+            tensordict["next", "reward"].mean().item(),
+        )
+    )
+    td_record = recorder(None)
+    if td_record is not None:
+        rewards_eval.append((i, td_record["r_evaluation"].item()))
+    if len(rewards_eval) and collected_frames >= init_random_frames:
+        target_value = loss_dict["target_value"].item()
+        loss_value = loss_dict["loss_value"].item()
+        loss_actor = loss_dict["loss_actor"].item()
+        rn = sampled_tensordict["next", "reward"].mean().item()
+        rs = sampled_tensordict["next", "reward"].std().item()
+        pbar.set_description(
+            f"reward: {rewards[-1][1]: 4.2f} (r0 = {r0: 4.2f}), "
+            f"reward eval: reward: {rewards_eval[-1][1]: 4.2f}, "
+            f"reward normalized={rn :4.2f}/{rs :4.2f}, "
+            f"grad norm={gn: 4.2f}, "
+            f"loss_value={loss_value: 4.2f}, "
+            f"loss_actor={loss_actor: 4.2f}, "
+            f"target value: {target_value: 4.2f}"
+        )
+
+    # update the exploration strategy
+    actor_model_explore[1].step(current_frames)
+
+collector.shutdown()
+del collector
+
+###############################################################################
+# Experiment results
+# ------------------
+#
+# We make a simple plot of the average rewards during training. We can observe
+# that our policy learned quite well to solve the task.
+#
+# .. note::
+#   As already mentioned above, to get a more reasonable performance,
+#   use a greater value for ``total_frames`` for example, 1M.
+
+from matplotlib import pyplot as plt
+
+plt.figure()
+plt.plot(*zip(*rewards), label="training")
+plt.plot(*zip(*rewards_eval), label="eval")
+plt.legend()
+plt.xlabel("iter")
+plt.ylabel("reward")
+plt.tight_layout()
+
+###############################################################################
+# Conclusion
+# ----------
+#
+# In this tutorial, we have learned how to code a loss module in TorchRL given
+# the concrete example of DDPG.
+#
+# The key takeaways are:
+#
+# - How to use the :class:`~torchrl.objectives.LossModule` class to code up a new
+#   loss component;
+# - How to use (or not) a target network, and how to update its parameters;
+# - How to create an optimizer associated with a loss module.
+#
+# Next Steps
+# ----------
+# 
+# To iterate further on this loss module we might consider:
+# 
+# - Using `@dispatch` (see `[Feature] Distpatch IQL loss module <https://github.com/pytorch/rl/pull/1230>`_.)
+# - Allowing flexible TensorDict keys.
+# 
diff --git a/advanced_source/cpp_autograd.rst b/advanced_source/cpp_autograd.rst
new file mode 100644
index 00000000000..51e5e0b358f
--- /dev/null
+++ b/advanced_source/cpp_autograd.rst
@@ -0,0 +1,437 @@
+Autograd in C++ Frontend
+========================
+
+The ``autograd`` package is crucial for building highly flexible and dynamic neural
+networks in PyTorch. Most of the autograd APIs in PyTorch Python frontend are also available
+in C++ frontend, allowing easy translation of autograd code from Python to C++.
+
+In this tutorial explore several examples of doing autograd in PyTorch C++ frontend.
+Note that this tutorial assumes that you already have a basic understanding of
+autograd in Python frontend. If that's not the case, please first read
+`Autograd: Automatic Differentiation <https://pytorch.org/tutorials/beginner/blitz/autograd_tutorial.html>`_.
+
+Basic autograd operations
+-------------------------
+
+(Adapted from `this tutorial <https://pytorch.org/tutorials/beginner/blitz/autograd_tutorial.html#autograd-automatic-differentiation>`_)
+
+Create a tensor and set ``torch::requires_grad()`` to track computation with it
+
+.. code-block:: cpp
+
+  auto x = torch::ones({2, 2}, torch::requires_grad());
+  std::cout << x << std::endl;
+
+Out:
+
+.. code-block:: shell
+
+  1 1
+  1 1
+  [ CPUFloatType{2,2} ]
+
+
+Do a tensor operation:
+
+.. code-block:: cpp
+
+  auto y = x + 2;
+  std::cout << y << std::endl;
+
+Out:
+
+.. code-block:: shell
+
+   3  3
+   3  3
+  [ CPUFloatType{2,2} ]
+
+``y`` was created as a result of an operation, so it has a ``grad_fn``.
+
+.. code-block:: cpp
+
+  std::cout << y.grad_fn()->name() << std::endl;
+
+Out:
+
+.. code-block:: shell
+
+  AddBackward1
+
+Do more operations on ``y``
+
+.. code-block:: cpp
+
+  auto z = y * y * 3;
+  auto out = z.mean();
+  
+  std::cout << z << std::endl;
+  std::cout << z.grad_fn()->name() << std::endl;
+  std::cout << out << std::endl;
+  std::cout << out.grad_fn()->name() << std::endl;
+
+Out:
+
+.. code-block:: shell
+
+   27  27
+   27  27
+  [ CPUFloatType{2,2} ]
+  MulBackward1
+  27
+  [ CPUFloatType{} ]
+  MeanBackward0
+
+
+``.requires_grad_( ... )`` changes an existing tensor's ``requires_grad`` flag in-place.
+
+.. code-block:: cpp
+
+  auto a = torch::randn({2, 2});
+  a = ((a * 3) / (a - 1));
+  std::cout << a.requires_grad() << std::endl;
+  
+  a.requires_grad_(true);
+  std::cout << a.requires_grad() << std::endl;
+  
+  auto b = (a * a).sum();
+  std::cout << b.grad_fn()->name() << std::endl;
+
+Out:
+
+.. code-block:: shell
+
+  false
+  true
+  SumBackward0
+
+Let's backprop now. Because ``out`` contains a single scalar, ``out.backward()``
+is equivalent to ``out.backward(torch::tensor(1.))``.
+
+.. code-block:: cpp
+
+  out.backward();
+
+Print gradients d(out)/dx
+
+.. code-block:: cpp
+
+  std::cout << x.grad() << std::endl;
+
+Out:
+
+.. code-block:: shell
+
+   4.5000  4.5000
+   4.5000  4.5000
+  [ CPUFloatType{2,2} ]
+
+You should have got a matrix of ``4.5``. For explanations on how we arrive at this value,
+please see `the corresponding section in this tutorial <https://pytorch.org/tutorials/beginner/blitz/autograd_tutorial.html#gradients>`_.
+
+Now let's take a look at an example of vector-Jacobian product:
+
+.. code-block:: cpp
+
+  x = torch::randn(3, torch::requires_grad());
+  
+  y = x * 2;
+  while (y.norm().item<double>() < 1000) {
+    y = y * 2;
+  }
+    
+  std::cout << y << std::endl;
+  std::cout << y.grad_fn()->name() << std::endl;
+
+Out:
+
+.. code-block:: shell
+
+  -1021.4020
+    314.6695
+   -613.4944
+  [ CPUFloatType{3} ]
+  MulBackward1
+
+If we want the vector-Jacobian product, pass the vector to ``backward`` as argument:
+
+.. code-block:: cpp
+
+  auto v = torch::tensor({0.1, 1.0, 0.0001}, torch::kFloat);
+  y.backward(v);
+  
+  std::cout << x.grad() << std::endl;
+
+Out:
+
+.. code-block:: shell
+
+    102.4000
+   1024.0000
+      0.1024
+  [ CPUFloatType{3} ]
+
+You can also stop autograd from tracking history on tensors that require gradients
+either by putting ``torch::NoGradGuard`` in a code block
+
+.. code-block:: cpp
+
+  std::cout << x.requires_grad() << std::endl;
+  std::cout << x.pow(2).requires_grad() << std::endl;
+  
+  {
+    torch::NoGradGuard no_grad;
+    std::cout << x.pow(2).requires_grad() << std::endl;
+  }
+
+
+Out:
+
+.. code-block:: shell
+
+  true
+  true
+  false
+
+Or by using ``.detach()`` to get a new tensor with the same content but that does
+not require gradients:
+
+.. code-block:: cpp
+
+  std::cout << x.requires_grad() << std::endl;
+  y = x.detach();
+  std::cout << y.requires_grad() << std::endl;
+  std::cout << x.eq(y).all().item<bool>() << std::endl;
+
+Out:
+
+.. code-block:: shell
+
+  true
+  false
+  true
+
+For more information on C++ tensor autograd APIs such as ``grad`` / ``requires_grad`` /
+``is_leaf`` / ``backward`` / ``detach`` / ``detach_`` / ``register_hook`` / ``retain_grad``,
+please see `the corresponding C++ API docs <https://pytorch.org/cppdocs/api/classat_1_1_tensor.html>`_.
+
+Computing higher-order gradients in C++
+---------------------------------------
+
+One of the applications of higher-order gradients is calculating gradient penalty.
+Let's see an example of it using ``torch::autograd::grad``:
+
+.. code-block:: cpp
+
+  #include <torch/torch.h>
+  
+  auto model = torch::nn::Linear(4, 3);
+  
+  auto input = torch::randn({3, 4}).requires_grad_(true);
+  auto output = model(input);
+  
+  // Calculate loss
+  auto target = torch::randn({3, 3});
+  auto loss = torch::nn::MSELoss()(output, target);
+  
+  // Use norm of gradients as penalty
+  auto grad_output = torch::ones_like(output);
+  auto gradient = torch::autograd::grad({output}, {input}, /*grad_outputs=*/{grad_output}, /*create_graph=*/true)[0];
+  auto gradient_penalty = torch::pow((gradient.norm(2, /*dim=*/1) - 1), 2).mean();
+  
+  // Add gradient penalty to loss
+  auto combined_loss = loss + gradient_penalty;
+  combined_loss.backward();
+  
+  std::cout << input.grad() << std::endl;
+
+Out:
+
+.. code-block:: shell
+
+  -0.1042 -0.0638  0.0103  0.0723
+  -0.2543 -0.1222  0.0071  0.0814
+  -0.1683 -0.1052  0.0355  0.1024
+  [ CPUFloatType{3,4} ]
+
+Please see the documentation for ``torch::autograd::backward``
+(`link <https://pytorch.org/cppdocs/api/function_namespacetorch_1_1autograd_1a1403bf65b1f4f8c8506a9e6e5312d030.html>`_)
+and ``torch::autograd::grad``
+(`link <https://pytorch.org/cppdocs/api/function_namespacetorch_1_1autograd_1ab9fa15dc09a8891c26525fb61d33401a.html>`_)
+for more information on how to use them.
+
+Using custom autograd function in C++
+-------------------------------------
+
+(Adapted from `this tutorial <https://pytorch.org/docs/stable/notes/extending.html#extending-torch-autograd>`_)
+
+Adding a new elementary operation to ``torch::autograd`` requires implementing a new ``torch::autograd::Function``
+subclass for each operation. ``torch::autograd::Function`` s are what ``torch::autograd``
+uses to compute the results and gradients, and encode the operation history. Every
+new function requires you to implement 2 methods: ``forward`` and ``backward``, and
+please see `this link <https://pytorch.org/cppdocs/api/structtorch_1_1autograd_1_1_function.html>`_
+for the detailed requirements.
+
+Below you can find code for a ``Linear`` function from ``torch::nn``:
+
+.. code-block:: cpp
+
+  #include <torch/torch.h>
+  
+  using namespace torch::autograd;
+  
+  // Inherit from Function
+  class LinearFunction : public Function<LinearFunction> {
+   public:
+    // Note that both forward and backward are static functions
+  
+    // bias is an optional argument
+    static torch::Tensor forward(
+        AutogradContext *ctx, torch::Tensor input, torch::Tensor weight, torch::Tensor bias = torch::Tensor()) {
+      ctx->save_for_backward({input, weight, bias});
+      auto output = input.mm(weight.t());
+      if (bias.defined()) {
+        output += bias.unsqueeze(0).expand_as(output);
+      }
+      return output;
+    }
+  
+    static tensor_list backward(AutogradContext *ctx, tensor_list grad_outputs) {
+      auto saved = ctx->get_saved_variables();
+      auto input = saved[0];
+      auto weight = saved[1];
+      auto bias = saved[2];
+  
+      auto grad_output = grad_outputs[0];
+      auto grad_input = grad_output.mm(weight);
+      auto grad_weight = grad_output.t().mm(input);
+      auto grad_bias = torch::Tensor();
+      if (bias.defined()) {
+        grad_bias = grad_output.sum(0);
+      }
+  
+      return {grad_input, grad_weight, grad_bias};
+    }
+  };
+
+Then, we can use the ``LinearFunction`` in the following way:
+
+.. code-block:: cpp
+
+  auto x = torch::randn({2, 3}).requires_grad_();
+  auto weight = torch::randn({4, 3}).requires_grad_();
+  auto y = LinearFunction::apply(x, weight);
+  y.sum().backward();
+  
+  std::cout << x.grad() << std::endl;
+  std::cout << weight.grad() << std::endl;
+
+Out:
+
+.. code-block:: shell
+
+   0.5314  1.2807  1.4864
+   0.5314  1.2807  1.4864
+  [ CPUFloatType{2,3} ]
+   3.7608  0.9101  0.0073
+   3.7608  0.9101  0.0073
+   3.7608  0.9101  0.0073
+   3.7608  0.9101  0.0073
+  [ CPUFloatType{4,3} ]
+
+Here, we give an additional example of a function that is parametrized by non-tensor arguments:
+
+.. code-block:: cpp
+
+  #include <torch/torch.h>
+  
+  using namespace torch::autograd;
+  
+  class MulConstant : public Function<MulConstant> {
+   public:
+    static torch::Tensor forward(AutogradContext *ctx, torch::Tensor tensor, double constant) {
+      // ctx is a context object that can be used to stash information
+      // for backward computation
+      ctx->saved_data["constant"] = constant;
+      return tensor * constant;
+    }
+  
+    static tensor_list backward(AutogradContext *ctx, tensor_list grad_outputs) {
+      // We return as many input gradients as there were arguments.
+      // Gradients of non-tensor arguments to forward must be `torch::Tensor()`.
+      return {grad_outputs[0] * ctx->saved_data["constant"].toDouble(), torch::Tensor()};
+    }
+  };
+
+Then, we can use the ``MulConstant`` in the following way:
+
+.. code-block:: cpp
+
+  auto x = torch::randn({2}).requires_grad_();
+  auto y = MulConstant::apply(x, 5.5);
+  y.sum().backward();
+
+  std::cout << x.grad() << std::endl;
+
+Out:
+
+.. code-block:: shell
+
+   5.5000
+   5.5000
+  [ CPUFloatType{2} ]
+
+For more information on ``torch::autograd::Function``, please see
+`its documentation <https://pytorch.org/cppdocs/api/structtorch_1_1autograd_1_1_function.html>`_.
+
+Translating autograd code from Python to C++
+--------------------------------------------
+
+On a high level, the easiest way to use autograd in C++ is to have working
+autograd code in Python first, and then translate your autograd code from Python to
+C++ using the following table:
+
++--------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| Python                         | C++                                                                                                                                                                    |
++================================+========================================================================================================================================================================+
+| ``torch.autograd.backward``    | ``torch::autograd::backward`` (`link <https://pytorch.org/cppdocs/api/function_namespacetorch_1_1autograd_1a1403bf65b1f4f8c8506a9e6e5312d030.html>`_)                  |
++--------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| ``torch.autograd.grad``        | ``torch::autograd::grad`` (`link <https://pytorch.org/cppdocs/api/function_namespacetorch_1_1autograd_1ab9fa15dc09a8891c26525fb61d33401a.html>`_)                      |
++--------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| ``torch.Tensor.detach``        | ``torch::Tensor::detach`` (`link <https://pytorch.org/cppdocs/api/classat_1_1_tensor.html#_CPPv4NK2at6Tensor6detachEv>`_)                                              |
++--------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| ``torch.Tensor.detach_``       | ``torch::Tensor::detach_`` (`link <https://pytorch.org/cppdocs/api/classat_1_1_tensor.html#_CPPv4NK2at6Tensor7detach_Ev>`_)                                            |
++--------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| ``torch.Tensor.backward``      | ``torch::Tensor::backward`` (`link <https://pytorch.org/cppdocs/api/classat_1_1_tensor.html#_CPPv4NK2at6Tensor8backwardERK6Tensorbb>`_)                                |
++--------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| ``torch.Tensor.register_hook`` | ``torch::Tensor::register_hook`` (`link <https://pytorch.org/cppdocs/api/classat_1_1_tensor.html#_CPPv4I0ENK2at6Tensor13register_hookE18hook_return_void_tI1TERR1T>`_) |
++--------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| ``torch.Tensor.requires_grad`` | ``torch::Tensor::requires_grad_`` (`link <https://pytorch.org/cppdocs/api/classat_1_1_tensor.html#_CPPv4NK2at6Tensor14requires_grad_Eb>`_)                             |
++--------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| ``torch.Tensor.retain_grad``   | ``torch::Tensor::retain_grad`` (`link <https://pytorch.org/cppdocs/api/classat_1_1_tensor.html#_CPPv4NK2at6Tensor11retain_gradEv>`_)                                   |
++--------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| ``torch.Tensor.grad``          | ``torch::Tensor::grad`` (`link <https://pytorch.org/cppdocs/api/classat_1_1_tensor.html#_CPPv4NK2at6Tensor4gradEv>`_)                                                  |
++--------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| ``torch.Tensor.grad_fn``       | ``torch::Tensor::grad_fn`` (`link <https://pytorch.org/cppdocs/api/classat_1_1_tensor.html#_CPPv4NK2at6Tensor7grad_fnEv>`_)                                            |
++--------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| ``torch.Tensor.set_data``      | ``torch::Tensor::set_data`` (`link <https://pytorch.org/cppdocs/api/classat_1_1_tensor.html#_CPPv4NK2at6Tensor8set_dataERK6Tensor>`_)                                  |
++--------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| ``torch.Tensor.data``          | ``torch::Tensor::data`` (`link <https://pytorch.org/cppdocs/api/classat_1_1_tensor.html#_CPPv4NK2at6Tensor4dataEv>`_)                                                  |
++--------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| ``torch.Tensor.output_nr``     | ``torch::Tensor::output_nr`` (`link <https://pytorch.org/cppdocs/api/classat_1_1_tensor.html#_CPPv4NK2at6Tensor9output_nrEv>`_)                                        |
++--------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| ``torch.Tensor.is_leaf``       | ``torch::Tensor::is_leaf`` (`link <https://pytorch.org/cppdocs/api/classat_1_1_tensor.html#_CPPv4NK2at6Tensor7is_leafEv>`_)                                            |
++--------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+
+After translation, most of your Python autograd code should just work in C++.
+If that's not the case, please file a bug report at `GitHub issues <https://github.com/pytorch/pytorch/issues>`_
+and we will fix it as soon as possible.
+
+Conclusion
+----------
+
+You should now have a good overview of PyTorch's C++ autograd API.
+You can find the code examples displayed in this note `here
+<https://github.com/pytorch/examples/tree/master/cpp/autograd>`_. As always, if you run into any
+problems or have questions, you can use our `forum <https://discuss.pytorch.org/>`_
+or `GitHub issues <https://github.com/pytorch/pytorch/issues>`_ to get in touch.
diff --git a/advanced_source/cpp_custom_ops.rst b/advanced_source/cpp_custom_ops.rst
new file mode 100644
index 00000000000..512c39b2a68
--- /dev/null
+++ b/advanced_source/cpp_custom_ops.rst
@@ -0,0 +1,582 @@
+.. _cpp-custom-ops-tutorial:
+
+Custom C++ and CUDA Operators
+=============================
+
+**Author:** `Richard Zou <https://github.com/zou3519>`_
+
+.. grid:: 2
+
+    .. grid-item-card:: :octicon:`mortar-board;1em;` What you will learn
+       :class-card: card-prerequisites
+
+       * How to integrate custom operators written in C++/CUDA with PyTorch
+       * How to test custom operators using ``torch.library.opcheck``
+
+    .. grid-item-card:: :octicon:`list-unordered;1em;` Prerequisites
+       :class-card: card-prerequisites
+
+       * PyTorch 2.4 or later
+       * Basic understanding of C++ and CUDA programming
+
+.. note::
+
+  This tutorial will also work on AMD ROCm with no additional modifications.
+
+PyTorch offers a large library of operators that work on Tensors (e.g. torch.add, torch.sum, etc).
+However, you may wish to bring a new custom operator to PyTorch. This tutorial demonstrates the
+blessed path to authoring a custom operator written in C++/CUDA.
+
+For our tutorial, we’ll demonstrate how to author a fused multiply-add C++
+and CUDA operator that composes with PyTorch subsystems. The semantics of
+the operation are as follows:
+
+.. code-block:: python
+
+  def mymuladd(a: Tensor, b: Tensor, c: float):
+      return a * b + c
+
+You can find the end-to-end working example for this tutorial
+`here <https://github.com/pytorch/extension-cpp>`_ .
+
+Setting up the Build System
+---------------------------
+
+If you are developing custom C++/CUDA code, it must be compiled.
+Note that if you’re interfacing with a Python library that already has bindings
+to precompiled C++/CUDA code, you might consider writing a custom Python operator
+instead (:ref:`python-custom-ops-tutorial`).
+
+Use `torch.utils.cpp_extension <https://pytorch.org/docs/stable/cpp_extension.html>`_
+to compile custom C++/CUDA code for use with PyTorch
+C++ extensions may be built either "ahead of time" with setuptools, or "just in time"
+via `load_inline <https://pytorch.org/docs/stable/cpp_extension.html#torch.utils.cpp_extension.load_inline>`_;
+we’ll focus on the "ahead of time" flavor.
+
+Using ``cpp_extension`` is as simple as writing the following ``setup.py``:
+
+.. code-block:: python
+
+  from setuptools import setup, Extension
+  from torch.utils import cpp_extension
+
+  setup(name="extension_cpp",
+        ext_modules=[
+            cpp_extension.CppExtension(
+              "extension_cpp",
+              ["muladd.cpp"],
+              # define Py_LIMITED_API with min version 3.9 to expose only the stable
+              # limited API subset from Python.h
+              extra_compile_args={"cxx": ["-DPy_LIMITED_API=0x03090000"]}, 
+              py_limited_api=True)],  # Build 1 wheel across multiple Python versions
+        cmdclass={'build_ext': cpp_extension.BuildExtension},
+        options={"bdist_wheel": {"py_limited_api": "cp39"}}  # 3.9 is minimum supported Python version
+  )
+
+If you need to compile CUDA code (for example, ``.cu`` files), then instead use
+`torch.utils.cpp_extension.CUDAExtension <https://pytorch.org/docs/stable/cpp_extension.html#torch.utils.cpp_extension.CUDAExtension>`_.
+Please see `extension-cpp <https://github.com/pytorch/extension-cpp>`_ for an
+example for how this is set up.
+
+The above example represents what we refer to as a CPython agnostic wheel, meaning we are
+building a single wheel that can be run across multiple CPython versions (similar to pure
+Python packages). CPython agnosticism is desirable in minimizing the number of wheels your
+custom library needs to support and release. The minimum version we'd like to support is
+3.9, since it is the oldest supported version currently, so we use the corresponding hexcode
+and specifier throughout the setup code. We suggest building the extension in the same
+environment as the minimum CPython version you'd like to support to minimize unknown behavior,
+so, here, we build the extension in a CPython 3.9 environment. When built, this single wheel
+will be runnable in any CPython environment 3.9+. To achieve this, there are three key lines
+to note.
+
+The first is the specification of ``Py_LIMITED_API`` in ``extra_compile_args`` to the
+minimum CPython version you would like to support:
+
+.. code-block:: python
+
+  extra_compile_args={"cxx": ["-DPy_LIMITED_API=0x03090000"]},
+
+Defining the ``Py_LIMITED_API`` flag helps verify that the extension is in fact
+only using the `CPython Stable Limited API <https://docs.python.org/3/c-api/stable.html>`_,
+which is a requirement for the building a CPython agnostic wheel. If this requirement
+is not met, it is possible to build a wheel that looks CPython agnostic but will crash,
+or worse, be silently incorrect, in another CPython environment. Take care to avoid
+using unstable CPython APIs, for example APIs from libtorch_python (in particular
+pytorch/python bindings,) and to only use APIs from libtorch (ATen objects, operators
+and the dispatcher). We strongly recommend defining the ``Py_LIMITED_API`` flag to
+help ascertain the extension is compliant and safe as a CPython agnostic wheel. Note that
+defining this flag is not a full guarantee that the built wheel is CPython agnostic, but
+it is better than the wild wild west. There are several caveats mentioned in the
+`Python docs <https://docs.python.org/3/c-api/stable.html#limited-api-caveats>`_,
+and you should test and verify yourself that the wheel is truly agnostic for the relevant
+CPython versions.
+
+The second and third lines specifying ``py_limited_api`` inform setuptools that you intend
+to build a CPython agnostic wheel and will influence the naming of the wheel accordingly:
+
+.. code-block:: python
+
+  setup(name="extension_cpp",
+        ext_modules=[
+            cpp_extension.CppExtension(
+              ...,
+              py_limited_api=True)],  # Build 1 wheel across multiple Python versions
+        ...,
+        options={"bdist_wheel": {"py_limited_api": "cp39"}}  # 3.9 is minimum supported Python version
+  )
+
+It is necessary to specify ``py_limited_api=True`` as an argument to CppExtension/
+CUDAExtension and also as an option to the ``"bdist_wheel"`` command with the minimal
+supported CPython version (in this case, 3.9). Consequently, the ``setup`` in our
+tutorial would build one properly named wheel that could be installed across multiple
+CPython versions ``>=3.9``.
+
+If your extension uses CPython APIs outside the stable limited set, then you cannot
+build a CPython agnostic wheel! You should build one wheel per CPython version instead,
+like so:
+
+.. code-block:: python
+
+  from setuptools import setup, Extension
+  from torch.utils import cpp_extension
+
+  setup(name="extension_cpp",
+        ext_modules=[
+            cpp_extension.CppExtension(
+              "extension_cpp",
+              ["muladd.cpp"])],
+        cmdclass={'build_ext': cpp_extension.BuildExtension},
+  )
+
+
+Defining the custom op and adding backend implementations
+---------------------------------------------------------
+First, let's write a C++ function that computes ``mymuladd``:
+
+.. code-block:: cpp
+
+   at::Tensor mymuladd_cpu(at::Tensor a, const at::Tensor& b, double c) {
+     TORCH_CHECK(a.sizes() == b.sizes());
+     TORCH_CHECK(a.dtype() == at::kFloat);
+     TORCH_CHECK(b.dtype() == at::kFloat);
+     TORCH_INTERNAL_ASSERT(a.device().type() == at::DeviceType::CPU);
+     TORCH_INTERNAL_ASSERT(b.device().type() == at::DeviceType::CPU);
+     at::Tensor a_contig = a.contiguous();
+     at::Tensor b_contig = b.contiguous();
+     at::Tensor result = torch::empty(a_contig.sizes(), a_contig.options());
+     const float* a_ptr = a_contig.data_ptr<float>();
+     const float* b_ptr = b_contig.data_ptr<float>();
+     float* result_ptr = result.data_ptr<float>();
+     for (int64_t i = 0; i < result.numel(); i++) {
+       result_ptr[i] = a_ptr[i] * b_ptr[i] + c;
+     }
+     return result;
+   }
+
+In order to use this from PyTorch’s Python frontend, we need to register it
+as a PyTorch operator using the ``TORCH_LIBRARY`` API. This will automatically
+bind the operator to Python.
+
+Operator registration is a two step-process:
+
+- **Defining the operator** - This step ensures that PyTorch is aware of the new operator.
+- **Registering backend implementations** - In this step, implementations for various
+  backends, such as CPU and CUDA, are associated with the operator.
+
+Defining an operator
+^^^^^^^^^^^^^^^^^^^^
+To define an operator, follow these steps:
+
+1. select a namespace for an operator. We recommend the namespace be the name of your top-level
+   project; we’ll use "extension_cpp" in our tutorial.
+2. provide a schema string that specifies the input/output types of the operator and if an
+   input Tensors will be mutated. We support more types in addition to Tensor and float;
+   please see `The Custom Operators Manual <https://pytorch.org/docs/main/notes/custom_operators.html>`_
+   for more details.
+
+   * If you are authoring an operator that can mutate its input Tensors, please see here
+     (:ref:`mutable-ops`) for how to specify that.
+
+.. code-block:: cpp
+
+  TORCH_LIBRARY(extension_cpp, m) {
+     // Note that "float" in the schema corresponds to the C++ double type
+     // and the Python float type.
+     m.def("mymuladd(Tensor a, Tensor b, float c) -> Tensor");
+   }
+
+This makes the operator available from Python via ``torch.ops.extension_cpp.mymuladd``.
+
+Registering backend implementations for an operator
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Use ``TORCH_LIBRARY_IMPL`` to register a backend implementation for the operator.
+
+.. code-block:: cpp
+
+   TORCH_LIBRARY_IMPL(extension_cpp, CPU, m) {
+     m.impl("mymuladd", &mymuladd_cpu);
+   }
+
+If you also have a CUDA implementation of ``myaddmul``, you can register it
+in a separate ``TORCH_LIBRARY_IMPL`` block:
+
+.. code-block:: cpp
+
+  __global__ void muladd_kernel(int numel, const float* a, const float* b, float c, float* result) {
+    int idx = blockIdx.x * blockDim.x + threadIdx.x;
+    if (idx < numel) result[idx] = a[idx] * b[idx] + c;
+  }
+
+  at::Tensor mymuladd_cuda(const at::Tensor& a, const at::Tensor& b, double c) {
+    TORCH_CHECK(a.sizes() == b.sizes());
+    TORCH_CHECK(a.dtype() == at::kFloat);
+    TORCH_CHECK(b.dtype() == at::kFloat);
+    TORCH_INTERNAL_ASSERT(a.device().type() == at::DeviceType::CUDA);
+    TORCH_INTERNAL_ASSERT(b.device().type() == at::DeviceType::CUDA);
+    at::Tensor a_contig = a.contiguous();
+    at::Tensor b_contig = b.contiguous();
+    at::Tensor result = torch::empty(a_contig.sizes(), a_contig.options());
+    const float* a_ptr = a_contig.data_ptr<float>();
+    const float* b_ptr = b_contig.data_ptr<float>();
+    float* result_ptr = result.data_ptr<float>();
+
+    int numel = a_contig.numel();
+    muladd_kernel<<<(numel+255)/256, 256>>>(numel, a_ptr, b_ptr, c, result_ptr);
+    return result;
+  }
+
+  TORCH_LIBRARY_IMPL(extension_cpp, CUDA, m) {
+    m.impl("mymuladd", &mymuladd_cuda);
+  }
+
+Adding ``torch.compile`` support for an operator
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+To add ``torch.compile`` support for an operator, we must add a FakeTensor kernel (also
+known as a "meta kernel" or "abstract impl"). FakeTensors are Tensors that have
+metadata (such as shape, dtype, device) but no data: the FakeTensor kernel for an
+operator specifies how to compute the metadata of output tensors given the metadata of input tensors.
+The FakeTensor kernel should return dummy Tensors of your choice with
+the correct Tensor metadata (shape/strides/``dtype``/device).
+
+We recommend that this be done from Python via the ``torch.library.register_fake`` API,
+though it is possible to do this from C++ as well (see
+`The Custom Operators Manual <https://pytorch.org/docs/main/notes/custom_operators.html>`_
+for more details).
+
+.. code-block:: python
+
+  # Important: the C++ custom operator definitions should be loaded first
+  # before calling ``torch.library`` APIs that add registrations for the
+  # C++ custom operator(s). The following import loads our
+  # C++ custom operator definitions.
+  # Note that if you are striving for Python agnosticism, you should use
+  # the ``load_library(...)`` API call instead. See the next section for
+  # more details.
+  from . import _C
+
+  @torch.library.register_fake("extension_cpp::mymuladd")
+  def _(a, b, c):
+      torch._check(a.shape == b.shape)
+      torch._check(a.dtype == torch.float)
+      torch._check(b.dtype == torch.float)
+      torch._check(a.device == b.device)
+      return torch.empty_like(a)
+
+Setting up hybrid Python/C++ registration
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+In this tutorial, we defined a custom operator in C++, added CPU/CUDA
+implementations in C++, and added ``FakeTensor`` kernels and backward formulas
+in Python. The order in which these registrations are loaded (or imported)
+matters (importing in the wrong order will lead to an error).
+
+To use the custom operator with hybrid Python/C++ registrations, we must
+first load the C++ library that holds the custom operator definition
+and then call the ``torch.library`` registration APIs. This can happen in
+three ways:
+
+
+1. The first way to load the C++ library that holds the custom operator definition
+   is to define a dummy Python module for _C. Then, in Python, when you import the
+   module with ``import _C``, the ``.so`` files corresponding to the extension will
+   be loaded and the ``TORCH_LIBRARY`` and ``TORCH_LIBRARY_IMPL`` static initializers
+   will run. One can create a dummy Python module with ``PYBIND11_MODULE`` like below,
+   but you will notice that this does not compile with ``Py_LIMITED_API``, because
+   ``pybind11`` does not promise to only use the stable limited CPython API! With
+   the below code, you sadly cannot build a CPython agnostic wheel for your extension!
+   (Foreshadowing: I wonder what the second way is ;) ).
+
+.. code-block:: cpp
+
+  // in, say, not_agnostic/csrc/extension_BAD.cpp
+  #include <pybind11/pybind11.h>
+
+  PYBIND11_MODULE("_C", m) {}
+
+.. code-block:: python
+
+  # in, say, extension/__init__.py
+  from . import _C
+
+2. In this tutorial, because we value being able to build a single wheel across multiple
+   CPython versions, we will replace the unstable ``PYBIND11`` call with stable API calls.
+   The below code compiles with ``-DPy_LIMITED_API=0x03090000`` and successfully creates
+   a dummy Python module for our ``_C`` extension so that it can be imported from Python.
+   See `extension_cpp/__init__.py <https://github.com/pytorch/extension-cpp/blob/38ec45e/extension_cpp/__init__.py>`_
+   and `extension_cpp/csrc/muladd.cpp  <https://github.com/pytorch/extension-cpp/blob/38ec45e/extension_cpp/csrc/muladd.cpp>`_
+   for more details:
+
+.. code-block:: cpp
+  
+  #include <Python.h>
+
+  extern "C" {
+    /* Creates a dummy empty _C module that can be imported from Python.
+      The import from Python will load the .so consisting of this file
+      in this extension, so that the TORCH_LIBRARY static initializers
+      below are run. */
+    PyObject* PyInit__C(void)
+    {
+        static struct PyModuleDef module_def = {
+            PyModuleDef_HEAD_INIT,
+            "_C",   /* name of module */
+            NULL,   /* module documentation, may be NULL */
+            -1,     /* size of per-interpreter state of the module,
+                      or -1 if the module keeps state in global variables. */
+            NULL,   /* methods */
+        };
+        return PyModule_Create(&module_def);
+    }
+  }
+
+.. code-block:: python
+
+  # in, say, extension/__init__.py
+  from . import _C
+
+3. If you want to avoid ``Python.h`` entirely in your C++ custom operator, you may
+   use ``torch.ops.load_library("/path/to/library.so")`` in Python to load the ``.so``
+   file(s) compiled from the extension. Note that, with this method, there is no ``_C``
+   Python module created for the extension so you cannot call ``import _C`` from Python.
+   Instead of relying on the import statement to trigger the custom operators to be
+   registered, ``torch.ops.load_library("/path/to/library.so")`` will do the trick.
+   The challenge then is shifted towards understanding where the ``.so`` files are
+   located so that you can load them, which is not always trivial:
+
+.. code-block:: python
+
+  import torch
+  from pathlib import Path
+
+  so_files = list(Path(__file__).parent.glob("_C*.so"))
+  assert (
+      len(so_files) == 1
+  ), f"Expected one _C*.so file, found {len(so_files)}"
+  torch.ops.load_library(so_files[0])
+
+  from . import ops
+
+
+Adding training (autograd) support for an operator
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Use ``torch.library.register_autograd`` to add training support for an operator. Prefer
+this over directly using Python ``torch.autograd.Function`` or C++ ``torch::autograd::Function``;
+you must use those in a very specific way to avoid silent incorrectness (see
+`The Custom Operators Manual <https://pytorch.org/docs/main/notes/custom_operators.html>`_
+for more details).
+
+.. code-block:: python
+
+  def _backward(ctx, grad):
+      a, b = ctx.saved_tensors
+      grad_a, grad_b = None, None
+      if ctx.needs_input_grad[0]:
+          grad_a = grad * b
+      if ctx.needs_input_grad[1]:
+          grad_b = grad * a
+      return grad_a, grad_b, None
+
+  def _setup_context(ctx, inputs, output):
+      a, b, c = inputs
+      saved_a, saved_b = None, None
+      if ctx.needs_input_grad[0]:
+          saved_b = b
+      if ctx.needs_input_grad[1]:
+          saved_a = a
+      ctx.save_for_backward(saved_a, saved_b)
+
+  # This code adds training support for the operator. You must provide us
+  # the backward formula for the operator and a `setup_context` function
+  # to save values to be used in the backward.
+  torch.library.register_autograd(
+      "extension_cpp::mymuladd", _backward, setup_context=_setup_context)
+
+Note that the backward must be a composition of PyTorch-understood operators.
+If you wish to use another custom C++ or CUDA kernel in your backwards pass,
+it must be wrapped into a custom operator.
+
+If we had our own custom ``mymul`` kernel, we would need to wrap it into a
+custom operator and then call that from the backward:
+
+.. code-block:: cpp
+
+  // New! a mymul_cpu kernel
+  at::Tensor mymul_cpu(const at::Tensor& a, const at::Tensor& b) {
+    TORCH_CHECK(a.sizes() == b.sizes());
+    TORCH_CHECK(a.dtype() == at::kFloat);
+    TORCH_CHECK(b.dtype() == at::kFloat);
+    TORCH_CHECK(a.device().type() == at::DeviceType::CPU);
+    TORCH_CHECK(b.device().type() == at::DeviceType::CPU);
+    at::Tensor a_contig = a.contiguous();
+    at::Tensor b_contig = b.contiguous();
+    at::Tensor result = torch::empty(a_contig.sizes(), a_contig.options());
+    const float* a_ptr = a_contig.data_ptr<float>();
+    const float* b_ptr = b_contig.data_ptr<float>();
+    float* result_ptr = result.data_ptr<float>();
+    for (int64_t i = 0; i < result.numel(); i++) {
+      result_ptr[i] = a_ptr[i] * b_ptr[i];
+    }
+    return result;
+  }
+
+  TORCH_LIBRARY(extension_cpp, m) {
+    m.def("mymuladd(Tensor a, Tensor b, float c) -> Tensor");
+    // New! defining the mymul operator
+    m.def("mymul(Tensor a, Tensor b) -> Tensor");
+  }
+
+
+  TORCH_LIBRARY_IMPL(extension_cpp, CPU, m) {
+    m.impl("mymuladd", &mymuladd_cpu);
+    // New! registering the cpu kernel for the mymul operator
+    m.impl("mymul", &mymul_cpu);
+  }
+
+.. code-block:: python
+
+  def _backward(ctx, grad):
+      a, b = ctx.saved_tensors
+      grad_a, grad_b = None, None
+      if ctx.needs_input_grad[0]:
+          grad_a = torch.ops.extension_cpp.mymul.default(grad, b)
+      if ctx.needs_input_grad[1]:
+          grad_b = torch.ops.extension_cpp.mymul.default(grad, a)
+      return grad_a, grad_b, None
+
+
+  def _setup_context(ctx, inputs, output):
+      a, b, c = inputs
+      saved_a, saved_b = None, None
+      if ctx.needs_input_grad[0]:
+          saved_b = b
+      if ctx.needs_input_grad[1]:
+          saved_a = a
+      ctx.save_for_backward(saved_a, saved_b)
+
+
+  # This code adds training support for the operator. You must provide us
+  # the backward formula for the operator and a `setup_context` function
+  # to save values to be used in the backward.
+  torch.library.register_autograd(
+      "extension_cpp::mymuladd", _backward, setup_context=_setup_context)
+
+Testing an operator
+-------------------
+Use ``torch.library.opcheck`` to test that the custom op was registered correctly.
+Note that this function does not test that the gradients are mathematically correct
+-- plan to write separate tests for that, either manual ones or by using
+``torch.autograd.gradcheck``.
+
+.. code-block:: python
+
+  def sample_inputs(device, *, requires_grad=False):
+      def make_tensor(*size):
+          return torch.randn(size, device=device, requires_grad=requires_grad)
+
+      def make_nondiff_tensor(*size):
+          return torch.randn(size, device=device, requires_grad=False)
+
+      return [
+          [make_tensor(3), make_tensor(3), 1],
+          [make_tensor(20), make_tensor(20), 3.14],
+          [make_tensor(20), make_nondiff_tensor(20), -123],
+          [make_nondiff_tensor(2, 3), make_tensor(2, 3), -0.3],
+      ]
+
+  def reference_muladd(a, b, c):
+      return a * b + c
+
+  samples = sample_inputs(device, requires_grad=True)
+  samples.extend(sample_inputs(device, requires_grad=False))
+  for args in samples:
+      # Correctness test
+      result = torch.ops.extension_cpp.mymuladd(*args)
+      expected = reference_muladd(*args)
+      torch.testing.assert_close(result, expected)
+
+      # Use opcheck to check for incorrect usage of operator registration APIs
+      torch.library.opcheck(torch.ops.extension_cpp.mymuladd.default, args)
+
+.. _mutable-ops:
+
+Creating mutable operators
+--------------------------
+You may wish to author a custom operator that mutates its inputs. Use ``Tensor(a!)``
+to specify each mutable Tensor in the schema; otherwise, there will be undefined
+behavior. If there are multiple mutated Tensors, use different names (for example, ``Tensor(a!)``,
+``Tensor(b!)``, ``Tensor(c!)``) for each mutable Tensor.
+
+Let's author a ``myadd_out(a, b, out)`` operator, which writes the contents of ``a+b`` into ``out``.
+
+.. code-block:: cpp
+
+  // An example of an operator that mutates one of its inputs.
+  void myadd_out_cpu(const at::Tensor& a, const at::Tensor& b, at::Tensor& out) {
+    TORCH_CHECK(a.sizes() == b.sizes());
+    TORCH_CHECK(b.sizes() == out.sizes());
+    TORCH_CHECK(a.dtype() == at::kFloat);
+    TORCH_CHECK(b.dtype() == at::kFloat);
+    TORCH_CHECK(out.dtype() == at::kFloat);
+    TORCH_CHECK(out.is_contiguous());
+    TORCH_INTERNAL_ASSERT(a.device().type() == at::DeviceType::CPU);
+    TORCH_INTERNAL_ASSERT(b.device().type() == at::DeviceType::CPU);
+    TORCH_INTERNAL_ASSERT(out.device().type() == at::DeviceType::CPU);
+    at::Tensor a_contig = a.contiguous();
+    at::Tensor b_contig = b.contiguous();
+    const float* a_ptr = a_contig.data_ptr<float>();
+    const float* b_ptr = b_contig.data_ptr<float>();
+    float* result_ptr = out.data_ptr<float>();
+    for (int64_t i = 0; i < out.numel(); i++) {
+      result_ptr[i] = a_ptr[i] + b_ptr[i];
+    }
+  }
+
+When defining the operator, we must specify that it mutates the out Tensor in the schema:
+
+.. code-block:: cpp
+
+  TORCH_LIBRARY(extension_cpp, m) {
+    m.def("mymuladd(Tensor a, Tensor b, float c) -> Tensor");
+    m.def("mymul(Tensor a, Tensor b) -> Tensor");
+    // New!
+    m.def("myadd_out(Tensor a, Tensor b, Tensor(a!) out) -> ()");
+  }
+
+  TORCH_LIBRARY_IMPL(extension_cpp, CPU, m) {
+    m.impl("mymuladd", &mymuladd_cpu);
+    m.impl("mymul", &mymul_cpu);
+    // New!
+    m.impl("myadd_out", &myadd_out_cpu);
+  }
+
+.. note::
+
+  Do not return any mutated Tensors as outputs of the operator as this will
+  cause incompatibility with PyTorch subsystems like ``torch.compile``.
+
+Conclusion
+----------
+In this tutorial, we went over the recommended approach to integrating Custom C++
+and CUDA operators with PyTorch. The ``TORCH_LIBRARY/torch.library`` APIs are fairly
+low-level. For more information about how to use the API, see
+`The Custom Operators Manual <https://pytorch.org/tutorials/advanced/custom_ops_landing_page.html#the-custom-operators-manual>`_.
diff --git a/advanced_source/cpp_custom_ops_sycl.rst b/advanced_source/cpp_custom_ops_sycl.rst
new file mode 100644
index 00000000000..3b3ad069b58
--- /dev/null
+++ b/advanced_source/cpp_custom_ops_sycl.rst
@@ -0,0 +1,274 @@
+.. _cpp-custom-ops-tutorial-sycl:
+
+Custom SYCL Operators
+=====================
+
+.. grid:: 2
+
+    .. grid-item-card:: :octicon:`mortar-board;1em;` What you will learn
+       :class-card: card-prerequisites
+
+       * How to integrate custom operators written in SYCL with PyTorch
+
+    .. grid-item-card:: :octicon:`list-unordered;1em;` Prerequisites
+       :class-card: card-prerequisites
+
+       * PyTorch 2.8 or later
+       * Basic understanding of SYCL programming
+
+.. note::
+
+  ``SYCL`` serves as the backend programming language for Intel GPUs (device label ``xpu``). For configuration details, see:
+  `Getting Started on Intel GPUs <https://docs.pytorch.org/docs/main/notes/get_start_xpu.html>`_. The Intel Compiler, which comes bundled with Intel Deep Learning Essentials, handles ``SYCL`` compilation. Ensure you install and activate the compiler environment prior to executing the code examples in this tutorial.
+
+PyTorch offers a large library of operators that work on Tensors (e.g. torch.add, torch.sum, etc).
+However, you may wish to bring a new custom operator to PyTorch. This tutorial demonstrates the
+best path to authoring a custom operator written in SYCL. Tutorials for C++ and CUDA operators are available in the :ref:`cpp-custom-ops-tutorial`.
+
+Follow the structure to create a custom SYCL operator:
+
+.. code-block:: text
+
+  sycl_example/
+  ├── setup.py
+  ├── sycl_extension
+  │   ├── __init__.py
+  │   ├── muladd.sycl
+  │   └── ops.py
+  └── test_sycl_extension.py
+
+Setting up the Build System
+---------------------------
+
+If you need to compile **SYCL** code (for example, ``.sycl`` files), use `torch.utils.cpp_extension.SyclExtension <https://docs.pytorch.org/docs/stable/cpp_extension.html#torch.utils.cpp_extension.SyclExtension>`_.
+The setup process is very similar to C++/CUDA, except the compilation arguments need to be adjusted for SYCL.
+
+Using ``sycl_extension`` is as straightforward as writing the following ``setup.py``:
+
+.. code-block:: python
+
+  import os
+  import torch
+  import glob
+  from setuptools import find_packages, setup
+  from torch.utils.cpp_extension import SyclExtension, BuildExtension
+
+  library_name = "sycl_extension"
+  py_limited_api = True
+  extra_compile_args = {
+      "cxx": ["-O3",
+              "-fdiagnostics-color=always",
+              "-DPy_LIMITED_API=0x03090000"],
+      "sycl": ["-O3" ]
+  }
+
+  assert(torch.xpu.is_available()), "XPU is not available, please check your environment"
+  # Source files collection
+  this_dir = os.path.dirname(os.path.curdir)
+  extensions_dir = os.path.join(this_dir, library_name)
+  sources = list(glob.glob(os.path.join(extensions_dir, "*.sycl")))
+  # Construct extension
+  ext_modules = [
+      SyclExtension(
+          f"{library_name}._C",
+          sources,
+          extra_compile_args=extra_compile_args,
+          py_limited_api=py_limited_api,
+      )
+  ]
+  setup(
+      name=library_name,
+      packages=find_packages(),
+      ext_modules=ext_modules,
+      install_requires=["torch"],
+      description="Simple Example of PyTorch Sycl extensions",
+      cmdclass={"build_ext": BuildExtension},
+      options={"bdist_wheel": {"py_limited_api": "cp39"}} if py_limited_api else {},
+  )
+
+
+Defining the custom op and adding backend implementations
+---------------------------------------------------------
+First, let's write a SYCL function that computes ``mymuladd``:
+
+In order to use this from PyTorch’s Python frontend, we need to register it
+as a PyTorch operator using the ``TORCH_LIBRARY`` API. This will automatically
+bind the operator to Python.
+
+
+If you also have a SYCL implementation of ``myaddmul``, you can also register it
+in a separate ``TORCH_LIBRARY_IMPL`` block:
+
+.. code-block:: cpp
+
+  #include <c10/xpu/XPUStream.h>
+  #include <sycl/sycl.hpp>
+  #include <ATen/Operators.h>
+  #include <torch/all.h>
+  #include <torch/library.h>
+
+  namespace sycl_extension {
+  // MulAdd Kernel: result = a * b + c
+  static void muladd_kernel(
+      int numel, const float* a, const float* b, float c, float* result,
+      const sycl::nd_item<1>& item) {
+      int idx = item.get_global_id(0);
+      if (idx < numel) {
+          result[idx] = a[idx] * b[idx] + c;
+      }
+  }
+
+  class MulAddKernelFunctor {
+  public:
+      MulAddKernelFunctor(int _numel, const float* _a, const float* _b, float _c, float* _result)
+          : numel(_numel), a(_a), b(_b), c(_c), result(_result) {}
+      void operator()(const sycl::nd_item<1>& item) const {
+          muladd_kernel(numel, a, b, c, result, item);
+      }
+
+  private:
+      int numel;
+      const float* a;
+      const float* b;
+      float c;
+      float* result;
+  };
+
+  at::Tensor mymuladd_xpu(const at::Tensor& a, const at::Tensor& b, double c) {
+      TORCH_CHECK(a.sizes() == b.sizes(), "a and b must have the same shape");
+      TORCH_CHECK(a.dtype() == at::kFloat, "a must be a float tensor");
+      TORCH_CHECK(b.dtype() == at::kFloat, "b must be a float tensor");
+      TORCH_CHECK(a.device().is_xpu(), "a must be an XPU tensor");
+      TORCH_CHECK(b.device().is_xpu(), "b must be an XPU tensor");
+
+      at::Tensor a_contig = a.contiguous();
+      at::Tensor b_contig = b.contiguous();
+      at::Tensor result = at::empty_like(a_contig);
+
+      const float* a_ptr = a_contig.data_ptr<float>();
+      const float* b_ptr = b_contig.data_ptr<float>();
+      float* res_ptr = result.data_ptr<float>();
+      int numel = a_contig.numel();
+
+      sycl::queue& queue = c10::xpu::getCurrentXPUStream().queue();
+      constexpr int threads = 256;
+      int blocks = (numel + threads - 1) / threads;
+
+      queue.submit([&](sycl::handler& cgh) {
+          cgh.parallel_for<MulAddKernelFunctor>(
+              sycl::nd_range<1>(blocks * threads, threads),
+              MulAddKernelFunctor(numel, a_ptr, b_ptr, static_cast<float>(c), res_ptr)
+          );
+      });
+
+      return result;
+  }
+  // Defines the operators
+  TORCH_LIBRARY(sycl_extension, m) {
+    m.def("mymuladd(Tensor a, Tensor b, float c) -> Tensor");
+  }
+
+  // ==================================================
+  // Register SYCL Implementations to Torch Library
+  // ==================================================
+  TORCH_LIBRARY_IMPL(sycl_extension, XPU, m) {
+      m.impl("mymuladd", &mymuladd_xpu);
+  }
+
+  } // namespace sycl_extension
+
+
+
+Create a Python Interface
+-------------------------
+
+Create a Python interface for our operator in the ``sycl_extension/ops.py`` file:
+
+.. code-block:: python
+
+  import torch
+  from torch import Tensor
+  __all__ = ["mymuladd"]
+
+  def mymuladd(a: Tensor, b: Tensor, c: float) -> Tensor:
+      """Performs a * b + c in an efficient fused kernel"""
+      return torch.ops.sycl_extension.mymuladd.default(a, b, c)
+
+Initialize Package
+------------------
+
+Create ``sycl_extension/__init__.py`` file to make the package importable:
+
+.. code-block:: python
+
+  import ctypes
+  from pathlib import Path
+
+  import torch
+
+  current_dir = Path(__file__).parent.parent
+  build_dir = current_dir / "build"
+  so_files = list(build_dir.glob("**/*.so"))
+
+  assert len(so_files) == 1, f"Expected one _C*.so file, found {len(so_files)}"
+
+  with torch._ops.dl_open_guard():
+      loaded_lib = ctypes.CDLL(so_files[0])
+
+  from . import ops
+
+  __all__ = [
+      "loaded_lib",
+      "ops",
+  ]
+
+Testing SYCL extension operator
+-------------------
+
+Use simple test to verify that the operator works correctly.
+
+.. code-block:: python
+
+  import torch
+  from torch.testing._internal.common_utils import TestCase
+  import unittest
+  import sycl_extension
+
+  def reference_muladd(a, b, c):
+      return a * b + c
+
+  class TestMyMulAdd(TestCase):
+      def sample_inputs(self, device, *, requires_grad=False):
+          def make_tensor(*size):
+              return torch.randn(size, device=device, requires_grad=requires_grad)
+
+          def make_nondiff_tensor(*size):
+              return torch.randn(size, device=device, requires_grad=False)
+
+          return [
+              [make_tensor(3), make_tensor(3), 1],
+              [make_tensor(20), make_tensor(20), 3.14],
+              [make_tensor(20), make_nondiff_tensor(20), -123],
+              [make_nondiff_tensor(2, 3), make_tensor(2, 3), -0.3],
+          ]
+
+      def _test_correctness(self, device):
+          samples = self.sample_inputs(device)
+          for args in samples:
+              result = sycl_extension.ops.mymuladd(*args)
+              expected = reference_muladd(*args)
+              torch.testing.assert_close(result, expected)
+
+      @unittest.skipIf(not torch.xpu.is_available(), "requires Intel GPU")
+      def test_correctness_xpu(self):
+          self._test_correctness("xpu")
+
+  if __name__ == "__main__":
+      unittest.main()
+
+This test checks the correctness of the custom operator by comparing its output against a reference implementation.
+
+Conclusion
+----------
+
+In this tutorial, we demonstrated how to implement and compile custom SYCL operators for PyTorch. We specifically showcased an inference operation ``muladd``. For adding backward support or enabling torch.compile compatibility, please refer to :ref:`cpp-custom-ops-tutorial`.
diff --git a/advanced_source/cpp_export.rst b/advanced_source/cpp_export.rst
index e0081377584..56c4bcbaae7 100644
--- a/advanced_source/cpp_export.rst
+++ b/advanced_source/cpp_export.rst
@@ -1,376 +1,3 @@
-Loading a PyTorch Model in C++
-==============================
-
-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
-situations where precisely these properties of Python are unfavorable. One
-environment in which the latter often applies is *production* -- the land of
-low latencies and strict deployment requirements. For production scenarios, C++
-is very often the language of choice, even if only to bind it into another
-language like Java, Rust or Go. The following paragraphs will outline the path
-PyTorch provides to go from an existing Python model to a serialized
-representation that can be *loaded* and *executed* purely from C++, with no
-dependency on Python.
-
-Step 1: Converting Your PyTorch Model to Torch Script
------------------------------------------------------
-
-A PyTorch model's journey from Python to C++ is enabled by `Torch Script
-<https://pytorch.org/docs/master/jit.html>`_, a representation of a PyTorch
-model that can be understood, compiled and serialized by the Torch Script
-compiler. If you are starting out from an existing PyTorch model written in the
-vanilla "eager" API, you must first convert your model to Torch Script. In the
-most common cases, discussed below, this requires only little effort. If you
-already have a Torch Script module, you can skip to the next section of this
-tutorial.
-
-There exist two ways of converting a PyTorch model to Torch Script. The first
-is known as *tracing*, a mechanism in which the structure of the model is
-captured by evaluating it once using example inputs, and recording the flow of
-those inputs through the model. This is suitable for models that make limited
-use of control flow. The second approach is to add explicit annotations to your
-model that inform the Torch Script compiler that it may directly parse and
-compile your model code, subject to the constraints imposed by the Torch Script
-language.
-
-.. tip::
-
-  You can find the complete documentation for both of these methods, as well as
-  further guidance on which to use, in the official `Torch Script
-  reference <https://pytorch.org/docs/master/jit.html>`_.
-
-Converting to Torch Script via Tracing
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-To convert a PyTorch model to Torch Script via tracing, you must pass an
-instance of your model along with an example input to the ``torch.jit.trace``
-function. This will produce a ``torch.jit.ScriptModule`` object with the trace
-of your model evaluation embedded in the module's ``forward`` method::
-
-  import torch
-  import torchvision
-
-  # An instance of your model.
-  model = torchvision.models.resnet18()
-
-  # An example input you would normally provide to your model's forward() method.
-  example = torch.rand(1, 3, 224, 224)
-
-  # Use torch.jit.trace to generate a torch.jit.ScriptModule via tracing.
-  traced_script_module = torch.jit.trace(model, example)
-
-The traced ``ScriptModule`` can now be evaluated identically to a regular
-PyTorch module::
-
-  In[1]: output = traced_script_module(torch.ones(1, 3, 224, 224))
-  In[2]: output[0, :5]
-  Out[2]: tensor([-0.2698, -0.0381,  0.4023, -0.3010, -0.0448], grad_fn=<SliceBackward>)
-
-Converting to Torch Script via Annotation
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-Under certain circumstances, such as if your model employs particular forms of
-control flow, you may want to write your model in Torch Script directly and
-annotate your model accordingly. For example, say you have the following
-vanilla Pytorch model::
-
-  import torch
-
-  class MyModule(torch.nn.Module):
-      def __init__(self, N, M):
-          super(MyModule, self).__init__()
-          self.weight = torch.nn.Parameter(torch.rand(N, M))
-
-      def forward(self, input):
-          if input.sum() > 0:
-            output = self.weight.mv(input)
-          else:
-            output = self.weight + input
-          return output
-
-
-Because the ``forward`` method of this module uses control flow that is
-dependent on the input, it is not suitable for tracing. Instead, we can convert
-it to a ``ScriptModule`` by subclassing it from ``torch.jit.ScriptModule`` and
-adding a ``@torch.jit.script_method`` annotation to the model's ``forward``
-method::
-
-  import torch
-
-  class MyModule(torch.jit.ScriptModule):
-      def __init__(self, N, M):
-          super(MyModule, self).__init__()
-          self.weight = torch.nn.Parameter(torch.rand(N, M))
-
-      @torch.jit.script_method
-      def forward(self, input):
-          if bool(input.sum() > 0):
-            output = self.weight.mv(input)
-          else:
-            output = self.weight + input
-          return output
-
-  my_script_module = MyModule(2, 3)
-
-Creating a new ``MyModule`` object now directly produces an instance of
-``ScriptModule`` that is ready for serialization.
-
-Step 2: Serializing Your Script Module to a File
--------------------------------------------------
-
-Once you have a ``ScriptModule`` in your hands, either from tracing or
-annotating a PyTorch model, you are ready to serialize it to a file. Later on,
-you'll be able to load the module from this file in C++ and execute it without
-any dependency on Python. Say we want to serialize the ``ResNet18`` model shown
-earlier in the tracing example. To perform this serialization, simply call
-`save <https://pytorch.org/docs/master/jit.html#torch.jit.ScriptModule.save>`_
-on the module and pass it a filename::
-
-  traced_script_module.save("model.pt")
-
-This will produce a ``model.pt`` file in your working directory. We have now
-officially left the realm of Python and are ready to cross over to the sphere
-of C++.
-
-Step 3: Loading Your Script Module in C++
-------------------------------------------
-
-To load your serialized PyTorch model in C++, your application must depend on
-the PyTorch C++ API -- also known as *LibTorch*. The LibTorch distribution
-encompasses a collection of shared libraries, header files and CMake build
-configuration files. While CMake is not a requirement for depending on
-LibTorch, it is the recommended approach and will be well supported into the
-future. For this tutorial, we will be building a minimal C++ application using
-CMake and LibTorch that simply loads and executes a serialized PyTorch model.
-
-A Minimal C++ Application
-^^^^^^^^^^^^^^^^^^^^^^^^^
-
-Let's begin by discussing the code to load a module. The following will already
-do:
-
-.. code-block:: cpp
-
-  #include <torch/script.h> // One-stop header.
-
-  #include <iostream>
-  #include <memory>
-
-  int main(int argc, const char* argv[]) {
-    if (argc != 2) {
-      std::cerr << "usage: example-app <path-to-exported-script-module>\n";
-      return -1;
-    }
-
-    // Deserialize the ScriptModule from a file using torch::jit::load().
-    std::shared_ptr<torch::jit::script::Module> module = torch::jit::load(argv[1]);
-
-    assert(module != nullptr);
-    std::cout << "ok\n";
-  }
-
-The ``<torch/script.h>`` header encompasses all relevant includes from the
-LibTorch library necessary to run the example. Our application accepts the file
-path to a serialized PyTorch ``ScriptModule`` as its only command line argument
-and then proceeds to deserialize the module using the ``torch::jit::load()``
-function, which takes this file path as input. In return we receive a shared
-pointer to a ``torch::jit::script::Module``, the equivalent to a
-``torch.jit.ScriptModule`` in C++. For now, we only verify that this pointer is
-not null. We will examine how to execute it in a moment.
-
-Depending on LibTorch and Building the Application
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-Assume we stored the above code into a file called ``example-app.cpp``. A
-minimal ``CMakeLists.txt`` to build it could look as simple as:
-
-.. code-block:: cmake
-
-  cmake_minimum_required(VERSION 3.0 FATAL_ERROR)
-  project(custom_ops)
-
-  find_package(Torch REQUIRED)
-
-  add_executable(example-app example-app.cpp)
-  target_link_libraries(example-app "${TORCH_LIBRARIES}")
-  set_property(TARGET example-app PROPERTY CXX_STANDARD 11)
-
-The last thing we need to build the example application is the LibTorch
-distribution. You can always grab the latest stable release from the `download
-page <https://pytorch.org/>`_ on the PyTorch website. If you download and unzip
-the latest archive, you should receive a folder with the following directory
-structure:
-
-.. code-block:: sh
-
-  libtorch/
-    bin/
-    include/
-    lib/
-    share/
-
-- The ``lib/`` folder contains the shared libraries you must link against,
-- The ``include/`` folder contains header files your program will need to include,
-- The ``share/`` folder contains the necessary CMake configuration to enable the simple ``find_package(Torch)`` command above.
-
-.. tip::
-  On Windows, debug and release builds are not ABI-compatible. If you plan to
-  build your project in debug mode, please try the debug version of LibTorch.
-
-The last step is building the application. For this, assume our example
-directory is laid out like this:
-
-.. code-block:: sh
-
-  example-app/
-    CMakeLists.txt
-    example-app.cpp
-
-We can now run the following commands to build the application from within the
-``example-app/`` folder:
-
-.. code-block:: sh
-
-  mkdir build
-  cd build
-  cmake -DCMAKE_PREFIX_PATH=/path/to/libtorch ..
-  make
-
-where ``/path/to/libtorch`` should be the full path to the unzipped LibTorch
-distribution. If all goes well, it will look something like this:
-
-.. code-block:: sh
-
-  root@4b5a67132e81:/example-app# mkdir build
-  root@4b5a67132e81:/example-app# cd build
-  root@4b5a67132e81:/example-app/build# cmake -DCMAKE_PREFIX_PATH=/path/to/libtorch ..
-  -- The C compiler identification is GNU 5.4.0
-  -- The CXX compiler identification is GNU 5.4.0
-  -- Check for working C compiler: /usr/bin/cc
-  -- Check for working C compiler: /usr/bin/cc -- works
-  -- Detecting C compiler ABI info
-  -- Detecting C compiler ABI info - done
-  -- Detecting C compile features
-  -- Detecting C compile features - done
-  -- Check for working CXX compiler: /usr/bin/c++
-  -- Check for working CXX compiler: /usr/bin/c++ -- works
-  -- Detecting CXX compiler ABI info
-  -- Detecting CXX compiler ABI info - done
-  -- Detecting CXX compile features
-  -- Detecting CXX compile features - done
-  -- Looking for pthread.h
-  -- Looking for pthread.h - found
-  -- Looking for pthread_create
-  -- Looking for pthread_create - not found
-  -- Looking for pthread_create in pthreads
-  -- Looking for pthread_create in pthreads - not found
-  -- Looking for pthread_create in pthread
-  -- Looking for pthread_create in pthread - found
-  -- Found Threads: TRUE
-  -- Configuring done
-  -- Generating done
-  -- Build files have been written to: /example-app/build
-  root@4b5a67132e81:/example-app/build# make
-  Scanning dependencies of target example-app
-  [ 50%] Building CXX object CMakeFiles/example-app.dir/example-app.cpp.o
-  [100%] Linking CXX executable example-app
-  [100%] Built target example-app
-
-If we supply the path to the serialized ``ResNet18`` model we created earlier
-to the resulting ``example-app`` binary, we should be rewarded with a friendly
-"ok":
-
-.. code-block:: sh
-
-  root@4b5a67132e81:/example-app/build# ./example-app model.pt
-  ok
-
-Step 4: Executing the Script Module in C++
-------------------------------------------
-
-Having successfully loaded our serialized ``ResNet18`` in C++, we are now just a
-couple lines of code away from executing it! Let's add those lines to our C++
-application's ``main()`` function:
-
-.. code-block:: cpp
-
-    // Create a vector of inputs.
-    std::vector<torch::jit::IValue> inputs;
-    inputs.push_back(torch::ones({1, 3, 224, 224}));
-
-    // Execute the model and turn its output into a tensor.
-    at::Tensor output = module->forward(inputs).toTensor();
-
-    std::cout << output.slice(/*dim=*/1, /*start=*/0, /*end=*/5) << '\n';
-
-The first two lines set up the inputs to our model. We create a vector of
-``torch::jit::IValue`` (a type-erased value type ``script::Module`` methods
-accept and return) and add a single input. To create the input tensor, we use
-``torch::ones()``, the equivalent to ``torch.ones`` in the C++ API.  We then
-run the ``script::Module``'s ``forward`` method, passing it the input vector we
-created. In return we get a new ``IValue``, which we convert to a tensor by
-calling ``toTensor()``.
-
-.. tip::
-
-  To learn more about functions like ``torch::ones`` and the PyTorch C++ API in
-  general, refer to its documentation at https://pytorch.org/cppdocs. The
-  PyTorch C++ API provides near feature parity with the Python API, allowing
-  you to further manipulate and process tensors just like in Python.
-
-In the last line, we print the first five entries of the output. Since we
-supplied the same input to our model in Python earlier in this tutorial, we
-should ideally see the same output. Let's try it out by re-compiling our
-application and running it with the same serialized model:
-
-.. code-block:: sh
-
-  root@4b5a67132e81:/example-app/build# make
-  Scanning dependencies of target example-app
-  [ 50%] Building CXX object CMakeFiles/example-app.dir/example-app.cpp.o
-  [100%] Linking CXX executable example-app
-  [100%] Built target example-app
-  root@4b5a67132e81:/example-app/build# ./example-app model.pt
-  -0.2698 -0.0381  0.4023 -0.3010 -0.0448
-  [ Variable[CPUFloatType]{1,5} ]
-
-
-For reference, the output in Python previously was::
-
-  tensor([-0.2698, -0.0381,  0.4023, -0.3010, -0.0448], grad_fn=<SliceBackward>)
-
-Looks like a good match!
-
-.. tip::
-
-  To move your model to GPU memory, you can write ``model->to(at::kCUDA);``.
-  Make sure the inputs to a model living in CUDA memory are also in CUDA memory
-  by calling ``tensor.to(at::kCUDA)``, which will return a new tensor in CUDA
-  memory.
-
-Step 5: Getting Help and Exploring the API
-------------------------------------------
-
-This tutorial has hopefully equipped you with a general understanding of a
-PyTorch model's path from Python to C++. With the concepts described in this
-tutorial, you should be able to go from a vanilla, "eager" PyTorch model, to a
-compiled ``ScriptModule`` in Python, to a serialized file on disk and -- to
-close the loop -- to an executable ``script::Module`` in C++.
-
-Of course, there are many concepts we did not cover. For example, you may find
-yourself wanting to extend your ``ScriptModule`` with a custom operator
-implemented in C++ or CUDA, and executing this custom operator inside your
-``ScriptModule`` loaded in your pure C++ production environment. The good news
-is: this is possible, and well supported! For now, you can explore `this
-<https://github.com/pytorch/pytorch/tree/master/test/custom_operator>`_ folder
-for examples, and we will follow up with a tutorial shortly. In the time being,
-the following links may be generally helpful:
-
-- The Torch Script reference: https://pytorch.org/docs/master/jit.html
-- The PyTorch C++ API documentation: https://pytorch.org/cppdocs/
-- The PyTorch Python API documentation: https://pytorch.org/docs/
-
-As always, if you run into any problems or have questions, you can use our
-`forum <https://discuss.pytorch.org/>`_ or `GitHub issues
-<https://github.com/pytorch/pytorch/issues>`_ to get in touch.
+.. warning::
+    TorchScript is deprecated, please use 
+    `torch.export <https://docs.pytorch.org/tutorials/intermediate/torch_export_tutorial.html>`__ instead.
\ No newline at end of file
diff --git a/advanced_source/cpp_extension.rst b/advanced_source/cpp_extension.rst
deleted file mode 100644
index 383d14851d1..00000000000
--- a/advanced_source/cpp_extension.rst
+++ /dev/null
@@ -1,1182 +0,0 @@
-Custom C++ and CUDA Extensions
-==============================
-**Author**: `Peter Goldsborough <https://www.goldsborough.me/>`_
-
-
-PyTorch provides a plethora of operations related to neural networks, arbitrary
-tensor algebra, data wrangling and other purposes. However, you may still find
-yourself in need of a more customized operation. For example, you might want to
-use a novel activation function you found in a paper, or implement an operation
-you developed as part of your research.
-
-The easiest way of integrating such a custom operation in PyTorch is to write it
-in Python by extending :class:`Function` and :class:`Module` as outlined `here
-<https://pytorch.org/docs/master/notes/extending.html>`_. This gives you the full
-power of automatic differentiation (spares you from writing derivative
-functions) as well as the usual expressiveness of Python. However, there may be
-times when your operation is better implemented in C++. For example, your code
-may need to be *really* fast because it is called very frequently in your model
-or is very expensive even for few calls. Another plausible reason is that it
-depends on or interacts with other C or C++ libraries. To address such cases,
-PyTorch provides a very easy way of writing custom *C++ extensions*.
-
-C++ extensions are a mechanism we have developed to allow users (you) to create
-PyTorch operators defined *out-of-source*, i.e. separate from the PyTorch
-backend. This approach is *different* from the way native PyTorch operations are
-implemented. C++ extensions are intended to spare you much of the boilerplate
-associated with integrating an operation with PyTorch's backend while providing
-you with a high degree of flexibility for your PyTorch-based projects.
-Nevertheless, once you have defined your operation as a C++ extension, turning
-it into a native PyTorch function is largely a matter of code organization,
-which you can tackle after the fact if you decide to contribute your operation
-upstream.
-
-Motivation and Example
-----------------------
-
-The rest of this note will walk through a practical example of writing and using
-a C++ (and CUDA) extension. If you are being chased or someone will fire you if
-you don't get that op done by the end of the day, you can skip this section and
-head straight to the implementation details in the next section.
-
-Let's say you've come up with a new kind of recurrent unit that you found to
-have superior properties compared to the state of the art. This recurrent unit
-is similar to an LSTM, but differs in that it lacks a *forget gate* and uses an
-*Exponential Linear Unit* (ELU) as its internal activation function. Because
-this unit never forgets, we'll call it *LLTM*, or *Long-Long-Term-Memory* unit.
-
-The two ways in which LLTMs differ from vanilla LSTMs are significant enough
-that we can't configure PyTorch's ``LSTMCell`` for our purposes, so we'll have to
-create a custom cell. The first and easiest approach for this -- and likely in
-all cases a good first step -- is to implement our desired functionality in
-plain PyTorch with Python. For this, we need to subclass
-:class:`torch.nn.Module` and implement the forward pass of the LLTM. This would
-look something like this::
-
-  class LLTM(torch.nn.Module):
-      def __init__(self, input_features, state_size):
-          super(LLTM, self).__init__()
-          self.input_features = input_features
-          self.state_size = state_size
-          # 3 * state_size for input gate, output gate and candidate cell gate.
-          # input_features + state_size because we will multiply with [input, h].
-          self.weights = torch.nn.Parameter(
-              torch.empty(3 * state_size, input_features + state_size))
-          self.bias = torch.nn.Parameter(torch.empty(3 * state_size))
-          self.reset_parameters()
-
-      def reset_parameters(self):
-          stdv = 1.0 / math.sqrt(self.state_size)
-          for weight in self.parameters():
-              weight.data.uniform_(-stdv, +stdv)
-
-      def forward(self, input, state):
-          old_h, old_cell = state
-          X = torch.cat([old_h, input], dim=1)
-
-          # Compute the input, output and candidate cell gates with one MM.
-          gate_weights = F.linear(X, self.weights, self.bias)
-          # Split the combined gate weight matrix into its components.
-          gates = gate_weights.chunk(3, dim=1)
-
-          input_gate = torch.sigmoid(gates[0])
-          output_gate = torch.sigmoid(gates[1])
-          # Here we use an ELU instead of the usual tanh.
-          candidate_cell = F.elu(gates[2])
-
-          # Compute the new cell state.
-          new_cell = old_cell + candidate_cell * input_gate
-          # Compute the new hidden state and output.
-          new_h = torch.tanh(new_cell) * output_gate
-
-          return new_h, new_cell
-
-which we could then use as expected::
-
-  import torch
-
-  X = torch.randn(batch_size, input_features)
-  h = torch.randn(batch_size, state_size)
-  C = torch.randn(batch_size, state_size)
-
-  rnn = LLTM(input_features, state_size)
-
-  new_h, new_C = rnn(X, (h, C))
-
-Naturally, if at all possible and plausible, you should use this approach to
-extend PyTorch. Since PyTorch has highly optimized implementations of its
-operations for CPU *and* GPU, powered by libraries such as `NVIDIA cuDNN
-<https://developer.nvidia.com/cudnn>`_, `Intel MKL
-<https://software.intel.com/en-us/mkl>`_ or `NNPACK
-<https://github.com/Maratyszcza/NNPACK>`_, PyTorch code like above will often be
-fast enough. However, we can also see why, under certain circumstances, there is
-room for further performance improvements. The most obvious reason is that
-PyTorch has no knowledge of the *algorithm* you are implementing. It knows only
-of the individual operations you use to compose your algorithm. As such, PyTorch
-must execute your operations individually, one after the other. Since each
-individual call to the implementation (or *kernel*) of an operation, which may
-involve launch of a CUDA kernel, has a certain amount of overhead, this overhead
-may become significant across many function calls. Furthermore, the Python
-interpreter that is running our code can itself slow down our program.
-
-A definite method of speeding things up is therefore to rewrite parts in C++ (or
-CUDA) and *fuse* particular groups of operations. Fusing means combining the
-implementations of many functions into a single functions, which profits from
-fewer kernel launches as well as other optimizations we can perform with
-increased visibility of the global flow of data.
-
-Let's see how we can use C++ extensions to implement a *fused* version of the
-LLTM. We'll begin by writing it in plain C++, using the `ATen
-<https://github.com/zdevito/ATen>`_ library that powers much of PyTorch's
-backend, and see how easily it lets us translate our Python code. We'll then
-speed things up even more by moving parts of the model to CUDA kernel to benefit
-from the massive parallelism GPUs provide.
-
-Writing a C++ Extension
------------------------
-
-C++ extensions come in two flavors: They can be built "ahead of time" with
-:mod:`setuptools`, or "just in time" via
-:func:`torch.utils.cpp_extension.load`. We'll begin with the first approach and
-discuss the latter later.
-
-Building with :mod:`setuptools`
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-For the "ahead of time" flavor, we build our C++ extension by writing a
-``setup.py`` script that uses setuptools to compile our C++ code. For the LLTM, it
-looks as simple as this::
-
-  from setuptools import setup
-  from torch.utils.cpp_extension import CppExtension, BuildExtension
-
-  setup(name='lltm_cpp',
-        ext_modules=[CppExtension('lltm', ['lltm.cpp'])],
-        cmdclass={'build_ext': BuildExtension})
-
-
-In this code, :class:`CppExtension` is a convenience wrapper around
-:class:`setuptools.Extension` that passes the correct include paths and sets
-the language of the extension to C++. The equivalent vanilla :mod:`setuptools`
-code would simply be::
-
-  setuptools.Extension(
-     name='lltm_cpp',
-     sources=['lltm.cpp'],
-     include_dirs=torch.utils.cpp_extension.include_paths(),
-     language='c++')
-
-:class:`BuildExtension` performs a number of required configuration steps and
-checks and also manages mixed compilation in the case of mixed C++/CUDA
-extensions. And that's all we really need to know about building C++ extensions
-for now! Let's now take a look at the implementation of our C++ extension,
-which goes into ``lltm.cpp``.
-
-Writing the C++ Op
-^^^^^^^^^^^^^^^^^^
-
-Let's start implementing the LLTM in C++! One function we'll need for the
-backward pass is the derivative of the sigmoid. This is a small enough piece of
-code to discuss the overall environment that is available to us when writing C++
-extensions:
-
-.. code-block:: cpp
-
-  #include <torch/extension.h>
-
-  #include <iostream>
-
-  torch::Tensor d_sigmoid(torch::Tensor z) {
-    auto s = torch::sigmoid(z);
-    return (1 - s) * s;
-  }
-
-``<torch/extension.h>`` is the one-stop header to include all the necessary PyTorch
-bits to write C++ extensions. It includes:
-
-- The ATen library, which is our primary API for tensor computation,
-- `pybind11 <https://github.com/pybind/pybind11>`_, which is how we create Python bindings for our C++ code,
-- Headers that manage the details of interaction between ATen and pybind11.
-
-The implementation of :func:`d_sigmoid` shows how to use the ATen API.
-PyTorch's tensor and variable interface is generated automatically from the
-ATen library, so we can more or less translate our Python implementation 1:1
-into C++. Our primary datatype for all computations will be
-:class:`torch::Tensor`. Its full API can be inspected `here
-<https://pytorch.org/cppdocs/api/classat_1_1_tensor.html>`_. Notice
-also that we can include ``<iostream>`` or *any other C or C++ header* -- we have
-the full power of C++11 at our disposal.
-
-Forward Pass
-************
-
-Next we can port our entire forward pass to C++:
-
-.. code-block:: cpp
-
-  #include <vector>
-
-  std::vector<at::Tensor> lltm_forward(
-      torch::Tensor input,
-      torch::Tensor weights,
-      torch::Tensor bias,
-      torch::Tensor old_h,
-      torch::Tensor old_cell) {
-    auto X = torch::cat({old_h, input}, /*dim=*/1);
-
-    auto gate_weights = torch::addmm(bias, X, weights.transpose(0, 1));
-    auto gates = gate_weights.chunk(3, /*dim=*/1);
-
-    auto input_gate = torch::sigmoid(gates[0]);
-    auto output_gate = torch::sigmoid(gates[1]);
-    auto candidate_cell = torch::elu(gates[2], /*alpha=*/1.0);
-
-    auto new_cell = old_cell + candidate_cell * input_gate;
-    auto new_h = torch::tanh(new_cell) * output_gate;
-
-    return {new_h,
-            new_cell,
-            input_gate,
-            output_gate,
-            candidate_cell,
-            X,
-            gate_weights};
-  }
-
-Backward Pass
-*************
-
-The C++ extension API currently does not provide a way of automatically
-generating a backwards function for us. As such, we have to also implement the
-backward pass of our LLTM, which computes the derivative of the loss with
-respect to each input of the forward pass. Ultimately, we will plop both the
-forward and backward function into a :class:`torch.autograd.Function` to create
-a nice Python binding. The backward function is slightly more involved, so
-we'll not dig deeper into the code (if you are interested, `Alex Graves' thesis
-<https://www.cs.toronto.edu/~graves/phd.pdf>`_ is a good read for more
-information on this):
-
-.. code-block:: cpp
-
-  // tanh'(z) = 1 - tanh^2(z)
-  torch::Tensor d_tanh(torch::Tensor z) {
-    return 1 - z.tanh().pow(2);
-  }
-
-  // elu'(z) = relu'(z) + { alpha * exp(z) if (alpha * (exp(z) - 1)) < 0, else 0}
-  torch::Tensor d_elu(torch::Tensor z, torch::Scalar alpha = 1.0) {
-    auto e = z.exp();
-    auto mask = (alpha * (e - 1)) < 0;
-    return (z > 0).type_as(z) + mask.type_as(z) * (alpha * e);
-  }
-
-  std::vector<torch::Tensor> lltm_backward(
-      torch::Tensor grad_h,
-      torch::Tensor grad_cell,
-      torch::Tensor new_cell,
-      torch::Tensor input_gate,
-      torch::Tensor output_gate,
-      torch::Tensor candidate_cell,
-      torch::Tensor X,
-      torch::Tensor gate_weights,
-      torch::Tensor weights) {
-    auto d_output_gate = torch::tanh(new_cell) * grad_h;
-    auto d_tanh_new_cell = output_gate * grad_h;
-    auto d_new_cell = d_tanh(new_cell) * d_tanh_new_cell + grad_cell;
-
-    auto d_old_cell = d_new_cell;
-    auto d_candidate_cell = input_gate * d_new_cell;
-    auto d_input_gate = candidate_cell * d_new_cell;
-
-    auto gates = gate_weights.chunk(3, /*dim=*/1);
-    d_input_gate *= d_sigmoid(gates[0]);
-    d_output_gate *= d_sigmoid(gates[1]);
-    d_candidate_cell *= d_elu(gates[2]);
-
-    auto d_gates =
-        torch::cat({d_input_gate, d_output_gate, d_candidate_cell}, /*dim=*/1);
-
-    auto d_weights = d_gates.t().mm(X);
-    auto d_bias = d_gates.sum(/*dim=*/0, /*keepdim=*/true);
-
-    auto d_X = d_gates.mm(weights);
-    const auto state_size = grad_h.size(1);
-    auto d_old_h = d_X.slice(/*dim=*/1, 0, state_size);
-    auto d_input = d_X.slice(/*dim=*/1, state_size);
-
-    return {d_old_h, d_input, d_weights, d_bias, d_old_cell};
-  }
-
-Binding to Python
-^^^^^^^^^^^^^^^^^
-
-Once you have your operation written in C++ and ATen, you can use pybind11 to
-bind your C++ functions or classes into Python in a very simple manner.
-Questions or issues you have about this part of PyTorch C++ extensions will
-largely be addressed by `pybind11 documentation
-<https://pybind11.readthedocs.io/en/master/>`_.
-
-For our extensions, the necessary binding code spans only four lines:
-
-.. code-block:: cpp
-
-  PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
-    m.def("forward", &lltm_forward, "LLTM forward");
-    m.def("backward", &lltm_backward, "LLTM backward");
-  }
-
-One bit to note here is the macro ``TORCH_EXTENSION_NAME``. The torch extension
-build will define it as the name you give your extension in the ``setup.py``
-script. In this case, the value of ``TORCH_EXTENSION_NAME`` would be "lltm".
-This is to avoid having to maintain the name of the extension in two places
-(the build script and your C++ code), as a mismatch between the two can lead to
-nasty and hard to track issues.
-
-Using Your Extension
-^^^^^^^^^^^^^^^^^^^^
-
-We are now set to import our extension in PyTorch. At this point, your directory
-structure could look something like this::
-
-  pytorch/
-    lltm-extension/
-      lltm.cpp
-      setup.py
-
-Now, run ``python setup.py install`` to build and install your extension. This
-should look something like this::
-
-  running install
-  running bdist_egg
-  running egg_info
-  creating lltm_cpp.egg-info
-  writing lltm_cpp.egg-info/PKG-INFO
-  writing dependency_links to lltm_cpp.egg-info/dependency_links.txt
-  writing top-level names to lltm_cpp.egg-info/top_level.txt
-  writing manifest file 'lltm_cpp.egg-info/SOURCES.txt'
-  reading manifest file 'lltm_cpp.egg-info/SOURCES.txt'
-  writing manifest file 'lltm_cpp.egg-info/SOURCES.txt'
-  installing library code to build/bdist.linux-x86_64/egg
-  running install_lib
-  running build_ext
-  building 'lltm_cpp' extension
-  creating build
-  creating build/temp.linux-x86_64-3.7
-  gcc -pthread -B ~/local/miniconda/compiler_compat -Wl,--sysroot=/ -Wsign-compare -DNDEBUG -g -fwrapv -O3 -Wall -Wstrict-prototypes -fPIC -I~/local/miniconda/lib/python3.7/site-packages/torch/include -I~/local/miniconda/lib/python3.7/site-packages/torch/include/torch/csrc/api/include -I~/local/miniconda/lib/python3.7/site-packages/torch/include/TH -I~/local/miniconda/lib/python3.7/site-packages/torch/include/THC -I~/local/miniconda/include/python3.7m -c lltm.cpp -o build/temp.linux-x86_64-3.7/lltm.o -DTORCH_API_INCLUDE_EXTENSION_H -DTORCH_EXTENSION_NAME=lltm_cpp -D_GLIBCXX_USE_CXX11_ABI=1 -std=c++11
-  cc1plus: warning: command line option ‘-Wstrict-prototypes’ is valid for C/ObjC but not for C++
-  creating build/lib.linux-x86_64-3.7
-  g++ -pthread -shared -B ~/local/miniconda/compiler_compat -L~/local/miniconda/lib -Wl,-rpath=~/local/miniconda/lib -Wl,--no-as-needed -Wl,--sysroot=/ build/temp.linux-x86_64-3.7/lltm.o -o build/lib.linux-x86_64-3.7/lltm_cpp.cpython-37m-x86_64-linux-gnu.so
-  creating build/bdist.linux-x86_64
-  creating build/bdist.linux-x86_64/egg
-  copying build/lib.linux-x86_64-3.7/lltm_cpp.cpython-37m-x86_64-linux-gnu.so -> build/bdist.linux-x86_64/egg
-  creating stub loader for lltm_cpp.cpython-37m-x86_64-linux-gnu.so
-  byte-compiling build/bdist.linux-x86_64/egg/lltm_cpp.py to lltm_cpp.cpython-37.pyc
-  creating build/bdist.linux-x86_64/egg/EGG-INFO
-  copying lltm_cpp.egg-info/PKG-INFO -> build/bdist.linux-x86_64/egg/EGG-INFO
-  copying lltm_cpp.egg-info/SOURCES.txt -> build/bdist.linux-x86_64/egg/EGG-INFO
-  copying lltm_cpp.egg-info/dependency_links.txt -> build/bdist.linux-x86_64/egg/EGG-INFO
-  copying lltm_cpp.egg-info/top_level.txt -> build/bdist.linux-x86_64/egg/EGG-INFO
-  writing build/bdist.linux-x86_64/egg/EGG-INFO/native_libs.txt
-  zip_safe flag not set; analyzing archive contents...
-  __pycache__.lltm_cpp.cpython-37: module references __file__
-  creating 'dist/lltm_cpp-0.0.0-py3.7-linux-x86_64.egg' and adding 'build/bdist.linux-x86_64/egg' to it
-  removing 'build/bdist.linux-x86_64/egg' (and everything under it)
-  Processing lltm_cpp-0.0.0-py3.7-linux-x86_64.egg
-  removing '~/local/miniconda/lib/python3.7/site-packages/lltm_cpp-0.0.0-py3.7-linux-x86_64.egg' (and everything under it)
-  creating ~/local/miniconda/lib/python3.7/site-packages/lltm_cpp-0.0.0-py3.7-linux-x86_64.egg
-  Extracting lltm_cpp-0.0.0-py3.7-linux-x86_64.egg to ~/local/miniconda/lib/python3.7/site-packages
-  lltm-cpp 0.0.0 is already the active version in easy-install.pth
-
-  Installed ~/local/miniconda/lib/python3.7/site-packages/lltm_cpp-0.0.0-py3.7-linux-x86_64.egg
-  Processing dependencies for lltm-cpp==0.0.0
-  Finished processing dependencies for lltm-cpp==0.0.0
-
-
-A small note on compilers: Due to ABI versioning issues, the compiler you use to
-build your C++ extension must be *ABI-compatible* with the compiler PyTorch was
-built with. In practice, this means that you must use GCC version 4.9 and above on Linux.
-For Ubuntu 16.04 and other more-recent Linux distributions, this should be the
-default compiler already. On MacOS, you must use clang (which does not have any ABI versioning issues). In the worst
-case, you can build PyTorch from source with your compiler and then build the
-extension with that same compiler.
-
-Once your extension is built, you can simply import it in Python, using the
-name you specified in your ``setup.py`` script. Just be sure to ``import
-torch`` first, as this will resolve some symbols that the dynamic linker must
-see::
-
-  In [1]: import torch
-  In [2]: import lltm_cpp
-  In [3]: lltm_cpp.forward
-  Out[3]: <function lltm.PyCapsule.forward>
-
-If we call ``help()`` on the function or module, we can see that its signature
-matches our C++ code::
-
-  In[4] help(lltm.forward)
-  forward(...) method of builtins.PyCapsule instance
-      forward(arg0: torch::Tensor, arg1: torch::Tensor, arg2: torch::Tensor, arg3: torch::Tensor, arg4: torch::Tensor) -> List[torch::Tensor]
-
-      LLTM forward
-
-Since we are now able to call our C++ functions from Python, we can wrap them
-with :class:`torch.autograd.Function` and :class:`torch.nn.Module` to make them first
-class citizens of PyTorch::
-
-  import math
-  import torch
-
-  # Our module!
-  import lltm_cpp
-
-  class LLTMFunction(torch.autograd.Function):
-      @staticmethod
-      def forward(ctx, input, weights, bias, old_h, old_cell):
-          outputs = lltm_cpp.forward(input, weights, bias, old_h, old_cell)
-          new_h, new_cell = outputs[:2]
-          variables = outputs[1:] + [weights]
-          ctx.save_for_backward(*variables)
-
-          return new_h, new_cell
-
-      @staticmethod
-      def backward(ctx, grad_h, grad_cell):
-          outputs = lltm_cpp.backward(
-              grad_h.contiguous(), grad_cell.contiguous(), *ctx.saved_variables)
-          d_old_h, d_input, d_weights, d_bias, d_old_cell = outputs
-          return d_input, d_weights, d_bias, d_old_h, d_old_cell
-
-
-  class LLTM(torch.nn.Module):
-      def __init__(self, input_features, state_size):
-          super(LLTM, self).__init__()
-          self.input_features = input_features
-          self.state_size = state_size
-          self.weights = torch.nn.Parameter(
-              torch.empty(3 * state_size, input_features + state_size))
-          self.bias = torch.nn.Parameter(torch.empty(3 * state_size))
-          self.reset_parameters()
-
-      def reset_parameters(self):
-          stdv = 1.0 / math.sqrt(self.state_size)
-          for weight in self.parameters():
-              weight.data.uniform_(-stdv, +stdv)
-
-      def forward(self, input, state):
-          return LLTMFunction.apply(input, self.weights, self.bias, *state)
-
-Performance Comparison
-**********************
-
-Now that we are able to use and call our C++ code from PyTorch, we can run a
-small benchmark to see how much performance we gained from rewriting our op in
-C++. We'll run the LLTM forwards and backwards a few times and measure the
-duration::
-
-  import torch
-
-  batch_size = 16
-  input_features = 32
-  state_size = 128
-
-  X = torch.randn(batch_size, input_features)
-  h = torch.randn(batch_size, state_size)
-  C = torch.randn(batch_size, state_size)
-
-  rnn = LLTM(input_features, state_size)
-
-  forward = 0
-  backward = 0
-  for _ in range(100000):
-      start = time.time()
-      new_h, new_C = rnn(X, (h, C))
-      forward += time.time() - start
-
-      start = time.time()
-      (new_h.sum() + new_C.sum()).backward()
-      backward += time.time() - start
-
-  print('Forward: {:.3f} us | Backward {:.3f} us'.format(forward * 1e6/1e5, backward * 1e6/1e5))
-
-If we run this code with the original LLTM we wrote in pure Python at the start
-of this post, we get the following numbers (on my machine)::
-
-  Forward: 506.480 us | Backward 444.694 us
-
-and with our new C++ version::
-
-  Forward: 349.335 us | Backward 443.523 us
-
-We can already see a significant speedup for the forward function (more than
-30%). For the backward function a speedup is visible, albeit not major one. The
-backward pass I wrote above was not particularly optimized and could definitely
-be improved. Also, PyTorch's automatic differentiation engine can automatically
-parallelize computation graphs, may use a more efficient flow of operations
-overall, and is also implemented in C++, so it's expected to be fast.
-Nevertheless, this is a good start.
-
-Performance on GPU Devices
-**************************
-
-A wonderful fact about PyTorch's *ATen* backend is that it abstracts the
-computing device you are running on. This means the same code we wrote for CPU
-can *also* run on GPU, and individual operations will correspondingly dispatch
-to GPU-optimized implementations. For certain operations like matrix multiply
-(like ``mm`` or ``addmm``), this is a big win. Let's take a look at how much
-performance we gain from running our C++ code with CUDA tensors. No changes to
-our implementation are required, we simply need to put our tensors in GPU
-memory from Python, with either adding ``device=cuda_device`` argument at
-creation time or using ``.to(cuda_device)`` after creation::
-
-  import torch
-
-  assert torch.cuda.is_available()
-  cuda_device = torch.device("cuda")  # device object representing GPU
-
-  batch_size = 16
-  input_features = 32
-  state_size = 128
-
-  # Note the device=cuda_device arguments here
-  X = torch.randn(batch_size, input_features, device=cuda_device)
-  h = torch.randn(batch_size, state_size, device=cuda_device)
-  C = torch.randn(batch_size, state_size, device=cuda_device)
-
-  rnn = LLTM(input_features, state_size).to(cuda_device)
-
-  forward = 0
-  backward = 0
-  for _ in range(100000):
-      start = time.time()
-      new_h, new_C = rnn(X, (h, C))
-      torch.cuda.synchronize()
-      forward += time.time() - start
-
-      start = time.time()
-      (new_h.sum() + new_C.sum()).backward()
-      torch.cuda.synchronize()
-      backward += time.time() - start
-
-  print('Forward: {:.3f} us | Backward {:.3f} us'.format(forward * 1e6/1e5, backward * 1e6/1e5))
-
-Once more comparing our plain PyTorch code with our C++ version, now both
-running on CUDA devices, we again see performance gains. For Python/PyTorch::
-
-  Forward: 187.719 us | Backward 410.815 us
-
-And C++/ATen::
-
-  Forward: 149.802 us | Backward 393.458 us
-
-That's a great overall speedup compared to non-CUDA code. However, we can pull
-even more performance out of our C++ code by writing custom CUDA kernels, which
-we'll dive into soon. Before that, let's dicuss another way of building your C++
-extensions.
-
-JIT Compiling Extensions
-^^^^^^^^^^^^^^^^^^^^^^^^
-
-Previously, I mentioned there were two ways of building C++ extensions: using
-:mod:`setuptools` or just in time (JIT). Having covered the former, let's
-elaborate on the latter. The JIT compilation mechanism provides you with a way
-of compiling and loading your extensions on the fly by calling a simple
-function in PyTorch's API called :func:`torch.utils.cpp_extension.load`. For
-the LLTM, this would look as simple as this::
-
-  from torch.utils.cpp_extension import load
-
-  lltm_cpp = load(name="lltm_cpp", sources=["lltm.cpp"])
-
-Here, we provide the function with the same information as for
-:mod:`setuptools`. In the background, this will do the following:
-
-1. Create a temporary directory ``/tmp/torch_extensions/lltm``,
-2. Emit a `Ninja <https://ninja-build.org/>`_ build file into that temporary directory,
-3. Compile your source files into a shared library,
-4. Import this shared library as a Python module.
-
-In fact, if you pass ``verbose=True`` to :func:`cpp_extension.load`, you will
-be informed about the process::
-
-  Using /tmp/torch_extensions as PyTorch extensions root...
-  Emitting ninja build file /tmp/torch_extensions/lltm_cpp/build.ninja...
-  Building extension module lltm_cpp...
-  Loading extension module lltm_cpp...
-
-The resulting Python module will be exactly the same as produced by setuptools,
-but removes the requirement of having to maintain a separate ``setup.py`` build
-file. If your setup is more complicated and you do need the full power of
-:mod:`setuptools`, you *can* write your own ``setup.py`` -- but in many cases
-this JIT technique will do just fine. The first time you run through this line,
-it will take some time, as the extension is compiling in the background. Since
-we use the Ninja build system to build your sources, re-compilation is
-incremental and thus re-loading the extension when you run your Python module a
-second time is fast and has low overhead if you didn't change the extension's
-source files.
-
-Writing a Mixed C++/CUDA extension
-----------------------------------
-
-To really take our implementation to the next level, we can hand-write parts of
-our forward and backward passes with custom CUDA kernels. For the LLTM, this has
-the prospect of being particularly effective, as there are a large number of
-pointwise operations in sequence, that can all be fused and parallelized in a
-single CUDA kernel. Let's see how we could write such a CUDA kernel and
-integrate it with PyTorch using this extension mechanism.
-
-The general strategy for writing a CUDA extension is to first write a C++ file
-which defines the functions that will be called from Python, and binds those
-functions to Python with pybind11. Furthermore, this file will also *declare*
-functions that are defined in CUDA (``.cu``) files. The C++ functions will then
-do some checks and ultimately forward its calls to the CUDA functions. In the
-CUDA files, we write our actual CUDA kernels. The :mod:`cpp_extension` package
-will then take care of compiling the C++ sources with a C++ compiler like
-``gcc`` and the CUDA sources with NVIDIA's ``nvcc`` compiler. This ensures that
-each compiler takes care of files it knows best to compile. Ultimately, they
-will be linked into one shared library that is available to us from Python
-code.
-
-We'll start with the C++ file, which we'll call ``lltm_cuda.cpp``, for example:
-
-.. code-block:: cpp
-
-  #include <torch/extension.h>
-
-  #include <vector>
-
-  // CUDA forward declarations
-
-  std::vector<torch::Tensor> lltm_cuda_forward(
-      torch::Tensor input,
-      torch::Tensor weights,
-      torch::Tensor bias,
-      torch::Tensor old_h,
-      torch::Tensor old_cell);
-
-  std::vector<torch::Tensor> lltm_cuda_backward(
-      torch::Tensor grad_h,
-      torch::Tensor grad_cell,
-      torch::Tensor new_cell,
-      torch::Tensor input_gate,
-      torch::Tensor output_gate,
-      torch::Tensor candidate_cell,
-      torch::Tensor X,
-      torch::Tensor gate_weights,
-      torch::Tensor weights);
-
-  // C++ interface
-
-  #define CHECK_CUDA(x) AT_ASSERTM(x.type().is_cuda(), #x " must be a CUDA tensor")
-  #define CHECK_CONTIGUOUS(x) AT_ASSERTM(x.is_contiguous(), #x " must be contiguous")
-  #define CHECK_INPUT(x) CHECK_CUDA(x); CHECK_CONTIGUOUS(x)
-
-  std::vector<torch::Tensor> lltm_forward(
-      torch::Tensor input,
-      torch::Tensor weights,
-      torch::Tensor bias,
-      torch::Tensor old_h,
-      torch::Tensor old_cell) {
-    CHECK_INPUT(input);
-    CHECK_INPUT(weights);
-    CHECK_INPUT(bias);
-    CHECK_INPUT(old_h);
-    CHECK_INPUT(old_cell);
-
-    return lltm_cuda_forward(input, weights, bias, old_h, old_cell);
-  }
-
-  std::vector<torch::Tensor> lltm_backward(
-      torch::Tensor grad_h,
-      torch::Tensor grad_cell,
-      torch::Tensor new_cell,
-      torch::Tensor input_gate,
-      torch::Tensor output_gate,
-      torch::Tensor candidate_cell,
-      torch::Tensor X,
-      torch::Tensor gate_weights,
-      torch::Tensor weights) {
-    CHECK_INPUT(grad_h);
-    CHECK_INPUT(grad_cell);
-    CHECK_INPUT(input_gate);
-    CHECK_INPUT(output_gate);
-    CHECK_INPUT(candidate_cell);
-    CHECK_INPUT(X);
-    CHECK_INPUT(gate_weights);
-    CHECK_INPUT(weights);
-
-    return lltm_cuda_backward(
-        grad_h,
-        grad_cell,
-        new_cell,
-        input_gate,
-        output_gate,
-        candidate_cell,
-        X,
-        gate_weights,
-        weights);
-  }
-
-  PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
-    m.def("forward", &lltm_forward, "LLTM forward (CUDA)");
-    m.def("backward", &lltm_backward, "LLTM backward (CUDA)");
-  }
-
-As you can see, it is largely boilerplate, checks and forwarding to functions
-that we'll define in the CUDA file. We'll name this file
-``lltm_cuda_kernel.cu`` (note the ``.cu`` extension!). NVCC can reasonably
-compile C++11, thus we still have ATen and the C++ standard library available
-to us (but not ``torch.h``). Note that :mod:`setuptools` cannot handle files
-with the same name but different extensions, so if you use the ``setup.py``
-method instead of the JIT method, you must give your CUDA file a different name
-than your C++ file (for the JIT method, ``lltm.cpp`` and ``lltm.cu`` would work
-fine). Let's take a small peek at what this file will look like:
-
-.. code-block:: cpp
-
-  #include <torch/extension.h>
-
-  #include <cuda.h>
-  #include <cuda_runtime.h>
-
-  #include <vector>
-
-  template <typename scalar_t>
-  __device__ __forceinline__ scalar_t sigmoid(scalar_t z) {
-    return 1.0 / (1.0 + exp(-z));
-  }
-
-Here we see the headers I just described, as well as the fact that we are using
-CUDA-specific declarations like ``__device__`` and ``__forceinline__`` and
-functions like ``exp``. Let's continue with a few more helper functions that
-we'll need:
-
-.. code-block:: cpp
-
-  template <typename scalar_t>
-  __device__ __forceinline__ scalar_t d_sigmoid(scalar_t z) {
-    const auto s = sigmoid(z);
-    return (1.0 - s) * s;
-  }
-
-  template <typename scalar_t>
-  __device__ __forceinline__ scalar_t d_tanh(scalar_t z) {
-    const auto t = tanh(z);
-    return 1 - (t * t);
-  }
-
-  template <typename scalar_t>
-  __device__ __forceinline__ scalar_t elu(scalar_t z, scalar_t alpha = 1.0) {
-    return fmax(0.0, z) + fmin(0.0, alpha * (exp(z) - 1.0));
-  }
-
-  template <typename scalar_t>
-  __device__ __forceinline__ scalar_t d_elu(scalar_t z, scalar_t alpha = 1.0) {
-    const auto e = exp(z);
-    const auto d_relu = z < 0.0 ? 0.0 : 1.0;
-    return d_relu + (((alpha * (e - 1.0)) < 0.0) ? (alpha * e) : 0.0);
-  }
-
-To now actually implement a function, we'll again need two things: one function
-that performs operations we don't wish to explicitly write by hand and calls
-into CUDA kernels, and then the actual CUDA kernel for the parts we want to
-speed up. For the forward pass, the first function should look like this:
-
-.. code-block:: cpp
-
-  std::vector<torch::Tensor> lltm_cuda_forward(
-      torch::Tensor input,
-      torch::Tensor weights,
-      torch::Tensor bias,
-      torch::Tensor old_h,
-      torch::Tensor old_cell) {
-    auto X = torch::cat({old_h, input}, /*dim=*/1);
-    auto gates = torch::addmm(bias, X, weights.transpose(0, 1));
-
-    const auto batch_size = old_cell.size(0);
-    const auto state_size = old_cell.size(1);
-
-    auto new_h = torch::zeros_like(old_cell);
-    auto new_cell = torch::zeros_like(old_cell);
-    auto input_gate = torch::zeros_like(old_cell);
-    auto output_gate = torch::zeros_like(old_cell);
-    auto candidate_cell = torch::zeros_like(old_cell);
-
-    const int threads = 1024;
-    const dim3 blocks((state_size + threads - 1) / threads, batch_size);
-
-    AT_DISPATCH_FLOATING_TYPES(gates.type(), "lltm_forward_cuda", ([&] {
-      lltm_cuda_forward_kernel<scalar_t><<<blocks, threads>>>(
-          gates.data<scalar_t>(),
-          old_cell.data<scalar_t>(),
-          new_h.data<scalar_t>(),
-          new_cell.data<scalar_t>(),
-          input_gate.data<scalar_t>(),
-          output_gate.data<scalar_t>(),
-          candidate_cell.data<scalar_t>(),
-          state_size);
-    }));
-
-    return {new_h, new_cell, input_gate, output_gate, candidate_cell, X, gates};
-  }
-
-The main point of interest here is the ``AT_DISPATCH_FLOATING_TYPES`` macro and
-the kernel launch (indicated by the ``<<<...>>>``). While ATen abstracts away
-the device and datatype of the tensors we deal with, a tensor will, at runtime,
-still be backed by memory of a concrete type on a concrete device. As such, we
-need a way of determining at runtime what type a tensor is and then selectively
-call functions with the corresponding correct type signature. Done manually,
-this would (conceptually) look something like this:
-
-.. code-block:: cpp
-
-  switch (tensor.type().scalarType()) {
-    case torch::ScalarType::Double:
-      return function<double>(tensor.data<double>());
-    case torch::ScalarType::Float:
-      return function<float>(tensor.data<float>());
-    ...
-  }
-
-The purpose of ``AT_DISPATCH_FLOATING_TYPES`` is to take care of this dispatch
-for us. It takes a type (``gates.type()`` in our case), a name (for error
-messages) and a lambda function. Inside this lambda function, the type alias
-``scalar_t`` is available and is defined as the type that the tensor actually
-is at runtime in that context. As such, if we have a template function (which
-our CUDA kernel will be), we can instantiate it with this ``scalar_t`` alias,
-and the correct function will be called. In this case, we also want to retrieve
-the data pointers of the tensors as pointers of that ``scalar_t`` type. If you
-wanted to dispatch over all types and not just floating point types (``Float``
-and ``Double``), you can use ``AT_DISPATCH_ALL_TYPES``.
-
-Note that we perform some operations with plain ATen. These operations will
-still run on the GPU, but using ATen's default implementations. This makes
-sense, because ATen will use highly optimized routines for things like matrix
-multiplies (e.g. ``addmm``) or convolutions which would be much harder to
-implement and improve ourselves.
-
-As for the kernel launch itself, we are here specifying that each CUDA block
-will have 1024 threads, and that the entire GPU grid is split into as many
-blocks of ``1 x 1024`` threads as are required to fill our matrices with one
-thread per component. For example, if our state size was 2048 and our batch
-size 4, we'd launch a total of ``4 x 2 = 8`` blocks with each 1024 threads. If
-you've never heard of CUDA "blocks" or "grids" before, an `introductory read
-about CUDA <https://devblogs.nvidia.com/even-easier-introduction-cuda>`_ may
-help.
-
-The actual CUDA kernel is fairly simple (if you've ever programmed GPUs before):
-
-.. code-block:: cpp
-
-  template <typename scalar_t>
-  __global__ void lltm_cuda_forward_kernel(
-      const scalar_t* __restrict__ gates,
-      const scalar_t* __restrict__ old_cell,
-      scalar_t* __restrict__ new_h,
-      scalar_t* __restrict__ new_cell,
-      scalar_t* __restrict__ input_gate,
-      scalar_t* __restrict__ output_gate,
-      scalar_t* __restrict__ candidate_cell,
-      size_t state_size) {
-    const int column = blockIdx.x * blockDim.x + threadIdx.x;
-    const int index = blockIdx.y * state_size + column;
-    const int gates_row = blockIdx.y * (state_size * 3);
-    if (column < state_size) {
-      input_gate[index] = sigmoid(gates[gates_row + column]);
-      output_gate[index] = sigmoid(gates[gates_row + state_size + column]);
-      candidate_cell[index] = elu(gates[gates_row + 2 * state_size + column]);
-      new_cell[index] =
-          old_cell[index] + candidate_cell[index] * input_gate[index];
-      new_h[index] = tanh(new_cell[index]) * output_gate[index];
-    }
-  }
-
-What's primarily interesting here is that we are able to compute all of these
-pointwise operations entirely in parallel for each individual component in our
-gate matrices. If you imagine having to do this with a giant ``for`` loop over
-a million elements in serial, you can see why this would be much faster.
-
-Using accessors
-^^^^^^^^^^^^^^^
-
-You can see in the CUDA kernel that we work directly on pointers with the right
-type. Indeed, working directly with high level type agnostic tensors inside cuda
-kernels would be very inefficient.
-
-However, this comes at a cost of ease of use and readibility, especially for
-highly dimensional data. In our example, we know for example that the contiguous
-``gates`` tensor has 3 dimensions:
-
-1. batch, size of ``batch_size`` and stride of ``3*state_size``
-2. row, size of ``3`` and stride of ``state_size``
-3. index, size  of ``state_size`` and stride of ``1``
-
-How can we access the element ``gates[n][row][column]`` inside the kernel then?
-It turns out that you need the strides to access your element with some simple
-arithmetic.
-
-.. code-block:: cpp
-
-  gates.data<scalar_t>()[n*3*state_size + row*state_size + column]
-
-
-In addition to being verbose, this expression needs stride to be explicitely
-known, and thus passed to the kernel function within its arguments. You can see
-that in the case of kernel functions accepting multiple tensors with different
-sizes you will end up with a very long list of arguments.
-
-Fortunately for us, ATen provides accessors that are created with a single
-dynamic check that a Tensor is the type and number of dimensions.
-Accessors then expose an API for accessing the Tensor elements efficiently
-without having to convert to a single pointer:
-
-.. code-block:: cpp
-
-  torch::Tensor foo = torch::rand({12, 12});
-
-  // assert foo is 2-dimensional and holds floats.
-  auto foo_a = foo.accessor<float,2>();
-  float trace = 0;
-
-  for(int i = 0; i < foo_a.size(0); i++) {
-    // use the accessor foo_a to get tensor data.
-    trace += foo_a[i][i];
-  }
-
-Accessor objects have a relatively high level interface, with ``.size()`` and
-``.stride()`` methods and multi-dimensional indexing. The ``.accessor<>``
-interface is designed to access data efficiently on cpu tensor. The equivalent
-for cuda tensors is the ``packed_accessor<>``, which produces a Packed Accessor.
-
-The fundamental difference with Accessor is that a Packed Accessor copies size
-and stride data inside of its structure instead of pointing to it. It allows us
-to pass it to a CUDA kernel function and use its interface inside it.
-
-We can design a function that takes Packed Accessors instead of pointers.
-
-.. code-block:: cpp
-
-  __global__ void lltm_cuda_forward_kernel(
-      const torch::PackedTensorAccessor<scalar_t,3,torch::RestrictPtrTraits,size_t> gates,
-      const torch::PackedTensorAccessor<scalar_t,2,torch::RestrictPtrTraits,size_t> old_cell,
-      torch::PackedTensorAccessor<scalar_t,2,torch::RestrictPtrTraits,size_t> new_h,
-      torch::PackedTensorAccessor<scalar_t,2,torch::RestrictPtrTraits,size_t> new_cell,
-      torch::PackedTensorAccessor<scalar_t,2,torch::RestrictPtrTraits,size_t> input_gate,
-      torch::PackedTensorAccessor<scalar_t,2,torch::RestrictPtrTraits,size_t> output_gate,
-      torch::PackedTensorAccessor<scalar_t,2,torch::RestrictPtrTraits,size_t> candidate_cell)
-
-Let's decompose the template used here. the first two arguments ``scalar_t`` and
-``2`` are the same as regular Accessor. The argument
-``torch::RestrictPtrTraits`` indicates that the ``__restrict__`` keyword must be
-used. Finally, the argument ``size_t`` indicates that sizes and strides must be
-stored in a ``size_t`` integer. This is important as by default ``int64_t`` is
-used and can make the kernel slower.
-
-The function declaration becomes
-
-.. code-block:: cpp
-
-  template <typename scalar_t>
-  __global__ void lltm_cuda_forward_kernel(
-      const torch::PackedTensorAccessor<scalar_t,3,torch::RestrictPtrTraits,size_t> gates,
-      const torch::PackedTensorAccessor<scalar_t,2,torch::RestrictPtrTraits,size_t> old_cell,
-      torch::PackedTensorAccessor<scalar_t,2,torch::RestrictPtrTraits,size_t> new_h,
-      torch::PackedTensorAccessor<scalar_t,2,torch::RestrictPtrTraits,size_t> new_cell,
-      torch::PackedTensorAccessor<scalar_t,2,torch::RestrictPtrTraits,size_t> input_gate,
-      torch::PackedTensorAccessor<scalar_t,2,torch::RestrictPtrTraits,size_t> output_gate,
-      torch::PackedTensorAccessor<scalar_t,2,torch::RestrictPtrTraits,size_t> candidate_cell) {
-    //batch index
-    const int n = blockIdx.y;
-    // column index
-    const int c = blockIdx.x * blockDim.x + threadIdx.x;
-    if (c < gates.size(2)){
-      input_gate[n][c] = sigmoid(gates[n][0][c]);
-      output_gate[n][c] = sigmoid(gates[n][1][c]);
-      candidate_cell[n][c] = elu(gates[n][2][c]);
-      new_cell[n][c] =
-          old_cell[n][c] + candidate_cell[n][c] * input_gate[n][c];
-      new_h[n][c] = tanh(new_cell[n][c]) * output_gate[n][c];
-    }
-  }
-
-The implementation is much more readable! This function is then called by
-creating Packed Accessors with the ``.packed_accessor<>`` method within the
-host function.
-
-.. code-block:: cpp
-
-  std::vector<torch::Tensor> lltm_cuda_forward(
-      torch::Tensor input,
-      torch::Tensor weights,
-      torch::Tensor bias,
-      torch::Tensor old_h,
-      torch::Tensor old_cell) {
-    auto X = torch::cat({old_h, input}, /*dim=*/1);
-    auto gate_weights = torch::addmm(bias, X, weights.transpose(0, 1));
-
-    const auto batch_size = old_cell.size(0);
-    const auto state_size = old_cell.size(1);
-
-    auto gates = gate_weights.reshape({batch_size, 3, state_size});
-    auto new_h = torch::zeros_like(old_cell);
-    auto new_cell = torch::zeros_like(old_cell);
-    auto input_gate = torch::zeros_like(old_cell);
-    auto output_gate = torch::zeros_like(old_cell);
-    auto candidate_cell = torch::zeros_like(old_cell);
-
-    const int threads = 1024;
-    const dim3 blocks((state_size + threads - 1) / threads, batch_size);
-
-    AT_DISPATCH_FLOATING_TYPES(gates.type(), "lltm_forward_cuda", ([&] {
-      lltm_cuda_forward_kernel<scalar_t><<<blocks, threads>>>(
-          gates.packed_accessor<scalar_t,3,torch::RestrictPtrTraits,size_t>(),
-          old_cell.packed_accessor<scalar_t,2,torch::RestrictPtrTraits,size_t>(),
-          new_h.packed_accessor<scalar_t,2,torch::RestrictPtrTraits,size_t>(),
-          new_cell.packed_accessor<scalar_t,2,torch::RestrictPtrTraits,size_t>(),
-          input_gate.packed_accessor<scalar_t,2,torch::RestrictPtrTraits,size_t>(),
-          output_gate.packed_accessor<scalar_t,2,torch::RestrictPtrTraits,size_t>(),
-          candidate_cell.packed_accessor<scalar_t,2,torch::RestrictPtrTraits,size_t>());
-    }));
-
-    return {new_h, new_cell, input_gate, output_gate, candidate_cell, X, gates};
-  }
-
-The backwards pass follows much the same pattern and I won't elaborate further
-on it:
-
-.. code-block:: cpp
-
-  template <typename scalar_t>
-  __global__ void lltm_cuda_backward_kernel(
-      torch::PackedTensorAccessor<scalar_t,2,torch::RestrictPtrTraits,size_t> d_old_cell,
-      torch::PackedTensorAccessor<scalar_t,3,torch::RestrictPtrTraits,size_t> d_gates,
-      const torch::PackedTensorAccessor<scalar_t,2,torch::RestrictPtrTraits,size_t> grad_h,
-      const torch::PackedTensorAccessor<scalar_t,2,torch::RestrictPtrTraits,size_t> grad_cell,
-      const torch::PackedTensorAccessor<scalar_t,2,torch::RestrictPtrTraits,size_t> new_cell,
-      const torch::PackedTensorAccessor<scalar_t,2,torch::RestrictPtrTraits,size_t> input_gate,
-      const torch::PackedTensorAccessor<scalar_t,2,torch::RestrictPtrTraits,size_t> output_gate,
-      const torch::PackedTensorAccessor<scalar_t,2,torch::RestrictPtrTraits,size_t> candidate_cell,
-      const torch::PackedTensorAccessor<scalar_t,3,torch::RestrictPtrTraits,size_t> gate_weights) {
-    //batch index
-    const int n = blockIdx.y;
-    // column index
-    const int c = blockIdx.x * blockDim.x + threadIdx.x;
-    if (c < d_gates.size(2)){
-      const auto d_output_gate = tanh(new_cell[n][c]) * grad_h[n][c];
-      const auto d_tanh_new_cell = output_gate[n][c] * grad_h[n][c];
-      const auto d_new_cell =
-          d_tanh(new_cell[n][c]) * d_tanh_new_cell + grad_cell[n][c];
-
-
-      d_old_cell[n][c] = d_new_cell;
-      const auto d_candidate_cell = input_gate[n][c] * d_new_cell;
-      const auto d_input_gate = candidate_cell[n][c] * d_new_cell;
-
-      d_gates[n][0][c] =
-          d_input_gate * d_sigmoid(gate_weights[n][0][c]);
-      d_gates[n][1][c] =
-          d_output_gate * d_sigmoid(gate_weights[n][1][c]);
-      d_gates[n][2][c] =
-          d_candidate_cell * d_elu(gate_weights[n][2][c]);
-    }
-  }
-
-  std::vector<torch::Tensor> lltm_cuda_backward(
-      torch::Tensor grad_h,
-      torch::Tensor grad_cell,
-      torch::Tensor new_cell,
-      torch::Tensor input_gate,
-      torch::Tensor output_gate,
-      torch::Tensor candidate_cell,
-      torch::Tensor X,
-      torch::Tensor gates,
-      torch::Tensor weights) {
-    auto d_old_cell = torch::zeros_like(new_cell);
-    auto d_gates = torch::zeros_like(gates);
-
-    const auto batch_size = new_cell.size(0);
-    const auto state_size = new_cell.size(1);
-
-    const int threads = 1024;
-    const dim3 blocks((state_size + threads - 1) / threads, batch_size);
-
-    AT_DISPATCH_FLOATING_TYPES(X.type(), "lltm_forward_cuda", ([&] {
-      lltm_cuda_backward_kernel<scalar_t><<<blocks, threads>>>(
-          d_old_cell.packed_accessor<scalar_t,2,torch::RestrictPtrTraits,size_t>(),
-          d_gates.packed_accessor<scalar_t,3,torch::RestrictPtrTraits,size_t>(),
-          grad_h.packed_accessor<scalar_t,2,torch::RestrictPtrTraits,size_t>(),
-          grad_cell.packed_accessor<scalar_t,2,torch::RestrictPtrTraits,size_t>(),
-          new_cell.packed_accessor<scalar_t,2,torch::RestrictPtrTraits,size_t>(),
-          input_gate.packed_accessor<scalar_t,2,torch::RestrictPtrTraits,size_t>(),
-          output_gate.packed_accessor<scalar_t,2,torch::RestrictPtrTraits,size_t>(),
-          candidate_cell.packed_accessor<scalar_t,2,torch::RestrictPtrTraits,size_t>(),
-          gates.packed_accessor<scalar_t,3,torch::RestrictPtrTraits,size_t>());
-    }));
-
-    auto d_gate_weights = d_gates.reshape({batch_size, 3*state_size});
-    auto d_weights = d_gate_weights.t().mm(X);
-    auto d_bias = d_gate_weights.sum(/*dim=*/0, /*keepdim=*/true);
-
-    auto d_X = d_gate_weights.mm(weights);
-    auto d_old_h = d_X.slice(/*dim=*/1, 0, state_size);
-    auto d_input = d_X.slice(/*dim=*/1, state_size);
-
-    return {d_old_h, d_input, d_weights, d_bias, d_old_cell, d_gates};
-  }
-
-
-Integrating a C++/CUDA Operation with PyTorch
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-Integration of our CUDA-enabled op with PyTorch is again very straightforward.
-If you want to write a ``setup.py`` script, it could look like this::
-
-  from setuptools import setup
-  from torch.utils.cpp_extension import BuildExtension, CUDAExtension
-
-  setup(
-      name='lltm',
-      ext_modules=[
-          CUDAExtension('lltm_cuda', [
-              'lltm_cuda.cpp',
-              'lltm_cuda_kernel.cu',
-          ])
-      ],
-      cmdclass={
-          'build_ext': BuildExtension
-      })
-
-Instead of :func:`CppExtension`, we now use :func:`CUDAExtension`. We can just
-specify the ``.cu`` file along with the ``.cpp`` files -- the library takes
-care of all the hassle this entails for you. The JIT mechanism is even
-simpler::
-
-  from torch.utils.cpp_extension import load
-
-  lltm = load(name='lltm', sources=['lltm_cuda.cpp', 'lltm_cuda_kernel.cu'])
-
-Performance Comparison
-**********************
-
-Our hope was that parallelizing and fusing the pointwise operations of our code
-with CUDA would improve the performance of our LLTM. Let's see if that holds
-true. We can run the code I listed earlier to run a benchmark. Our fastest
-version earlier was the CUDA-based C++ code::
-
-  Forward: 149.802 us | Backward 393.458 us
-
-
-And now with our custom CUDA kernel::
-
-  Forward: 129.431 us | Backward 304.641 us
-
-More performance increases!
-
-Conclusion
-----------
-
-You should now be equipped with a good overview of PyTorch's C++ extension
-mechanism as well as a motivation for using them. You can find the code
-examples displayed in this note `here
-<https://github.com/pytorch/extension-cpp>`_. If you have questions, please use
-`the forums <https://discuss.pytorch.org>`_. Also be sure to check our `FAQ
-<https://pytorch.org/cppdocs/notes/faq.html>`_ in case you run into any issues.
diff --git a/advanced_source/cpp_frontend.rst b/advanced_source/cpp_frontend.rst
index bda9f3f256e..968afa01b23 100644
--- a/advanced_source/cpp_frontend.rst
+++ b/advanced_source/cpp_frontend.rst
@@ -1,11 +1,31 @@
+.. _cpp-frontend-tutorial:
+
 Using the PyTorch C++ Frontend
 ==============================
 
+**Author:** `Peter Goldsborough <https://github.com/goldsborough>`_
+
+.. grid:: 2
+
+    .. grid-item-card:: :octicon:`mortar-board;1em;` What you will learn
+       :class-card: card-prerequisites
+
+       * How to build a C++ application that utilizes the PyTorch C++ frontend
+       * How to define and train neural networks from C++ using PyTorch abstractions
+
+    .. grid-item-card:: :octicon:`list-unordered;1em;` Prerequisites
+       :class-card: card-prerequisites
+
+       * PyTorch 1.5 or later
+       * Basic understanding of C++ programming
+       * Basic Ubuntu Linux environment with CMake >= 3.5; similar commands will work in a MacOS / Windows environment
+       * (Optional) A CUDA-based GPU for the GPU training sections
+
 The PyTorch C++ frontend is a pure C++ interface to the PyTorch machine learning
 framework. While the primary interface to PyTorch naturally is Python, this
 Python API sits atop a substantial C++ codebase providing foundational data
 structures and functionality such as tensors and automatic differentiation. The
-C++ frontend exposes a pure C++11 API that extends this underlying C++ codebase
+C++ frontend exposes a pure C++17 API that extends this underlying C++ codebase
 with tools required for machine learning training and inference. This includes a
 built-in collection of common components for neural network modeling; an API to
 extend this collection with custom modules; a library of popular optimization
@@ -57,7 +77,7 @@ the right tool for the job. Examples for such environments include:
   Multiprocessing is an alternative, but not as scalable and has significant
   shortcomings. C++ has no such constraints and threads are easy to use and
   create. Models requiring heavy parallelization, like those used in `Deep
-  Neuroevolution <https://eng.uber.com/deep-neuroevolution/>`_, can benefit from
+  Neuroevolution <https://www.uber.com/blog/deep-neuroevolution/>`_, can benefit from
   this.
 - **Existing C++ Codebases**: You may be the owner of an existing C++
   application doing anything from serving web pages in a backend server to
@@ -105,6 +125,8 @@ environment, however you are free to follow along on MacOS or Windows too.
 .. tip::
   On Windows, debug and release builds are not ABI-compatible. If you plan to
   build your project in debug mode, please try the debug version of LibTorch.
+  Also, make sure you specify the correct configuration in the ``cmake --build .``
+  line below.
 
 The first step is to download the LibTorch distribution locally, via the link
 retrieved from the PyTorch website. For a vanilla Ubuntu Linux environment, this
@@ -135,14 +157,14 @@ on we'll use this ``CMakeLists.txt`` file:
 
 .. code-block:: cmake
 
-  cmake_minimum_required(VERSION 3.0 FATAL_ERROR)
+  cmake_minimum_required(VERSION 3.5 FATAL_ERROR)
   project(dcgan)
 
   find_package(Torch REQUIRED)
 
   add_executable(dcgan dcgan.cpp)
   target_link_libraries(dcgan "${TORCH_LIBRARIES}")
-  set_property(TARGET dcgan PROPERTY CXX_STANDARD 11)
+  set_property(TARGET dcgan PROPERTY CXX_STANDARD 17)
 
 .. note::
 
@@ -201,7 +223,7 @@ corresponding absolute path. Now, we are ready to build our application:
   -- Configuring done
   -- Generating done
   -- Build files have been written to: /home/build
-  root@fa350df05ecf:/home/build# make -j
+  root@fa350df05ecf:/home/build# cmake --build . --config Release
   Scanning dependencies of target dcgan
   [ 50%] Building CXX object CMakeFiles/dcgan.dir/dcgan.cpp.o
   [100%] Linking CXX executable dcgan
@@ -209,9 +231,9 @@ corresponding absolute path. Now, we are ready to build our application:
 
 Above, we first created a ``build`` folder inside of our ``dcgan`` directory,
 entered this folder, ran the ``cmake`` command to generate the necessary build
-(Make) files and finally compiled the project successfully by running ``make
--j``. We are now all set to execute our minimal binary and complete this section
-on basic project configuration:
+(Make) files and finally compiled the project successfully by running ``cmake
+--build . --config Release``. We are now all set to execute our minimal binary
+and complete this section on basic project configuration:
 
 .. code-block:: shell
 
@@ -660,7 +682,7 @@ Defining the DCGAN Modules
 We now have the necessary background and introduction to define the modules for
 the machine learning task we want to solve in this post. To recap: our task is
 to generate images of digits from the `MNIST dataset
-<http://yann.lecun.com/exdb/mnist/>`_. We want to use a `generative adversarial
+<https://huggingface.co/datasets/ylecun/mnist>`_. We want to use a `generative adversarial
 network (GAN)
 <https://papers.nips.cc/paper/5423-generative-adversarial-nets.pdf>`_ to solve
 this task. In particular, we'll use a `DCGAN architecture
@@ -696,136 +718,78 @@ The Generator Module
 ********************
 
 We begin by defining the generator module, which consists of a series of
-transposed 2D convolutions, batch normalizations and ReLU activation units. Like
-in Python, PyTorch here provides two APIs for model definition: a functional one
-where inputs are passed through successive functions, and a more object-oriented
-one where we build a ``Sequential`` module containing the entire model as
-submodules. Let's see how our generator looks with either API, and you can
-decide for yourself which one you prefer. First, using ``Sequential``:
+transposed 2D convolutions, batch normalizations and ReLU activation units.
+We explicitly pass inputs (in a functional way) between modules in the
+``forward()`` method of a module we define ourselves:
 
 .. code-block:: cpp
 
-  using namespace torch;
-
-  nn::Sequential generator(
-      // Layer 1
-      nn::Conv2d(nn::Conv2dOptions(kNoiseSize, 256, 4)
-                     .with_bias(false)
-                     .transposed(true)),
-      nn::BatchNorm(256),
-      nn::Functional(torch::relu),
-      // Layer 2
-      nn::Conv2d(nn::Conv2dOptions(256, 128, 3)
-                     .stride(2)
-                     .padding(1)
-                     .with_bias(false)
-                     .transposed(true)),
-      nn::BatchNorm(128),
-      nn::Functional(torch::relu),
-      // Layer 3
-      nn::Conv2d(nn::Conv2dOptions(128, 64, 4)
-                     .stride(2)
-                     .padding(1)
-                     .with_bias(false)
-                     .transposed(true)),
-      nn::BatchNorm(64),
-      nn::Functional(torch::relu),
-      // Layer 4
-      nn::Conv2d(nn::Conv2dOptions(64, 1, 4)
-                     .stride(2)
-                     .padding(1)
-                     .with_bias(false)
-                     .transposed(true)),
-      nn::Functional(torch::tanh));
-
-.. tip::
-
-	A ``Sequential`` module simply performs function composition. The output of
-	the first submodule becomes the input of the second, the output of the third
-	becomes the input of the fourth and so on.
-
-The particular modules chosen, like ``nn::Conv2d`` and ``nn::BatchNorm``,
-follows the structure outlined earlier. The ``kNoiseSize`` constant determines
-the size of the input noise vector and is set to ``100``. Notice also that we
-use the ``torch::nn::Functional`` module for our activation functions, passing
-it ``torch::relu`` for inner layers and ``torch::tanh`` as the final activation.
-Hyperparameters were, of course, found via grad student descent.
-
-.. note::
-
-	The Python frontend has one module for each activation function, like
-	``torch.nn.ReLU`` or ``torch.nn.Tanh``. In C++, we instead only provide the
-	``Functional`` module, to which you can pass any C++ function that will be
-	called inside the ``Functional``'s ``forward()`` method.
-
-.. attention::
-
-	No grad students were harmed in the discovery of hyperparameters. They were
-	fed Soylent regularly.
-
-For the second approach, we explicitly pass inputs (in a functional way) between
-modules in the ``forward()`` method of a module we define ourselves:
-
-.. code-block:: cpp
-
-  struct GeneratorImpl : nn::Module {
-    GeneratorImpl()
-        : conv1(nn::Conv2dOptions(kNoiseSize, 512, 4)
-                    .with_bias(false)
-                    .transposed(true)),
-          batch_norm1(512),
-          conv2(nn::Conv2dOptions(512, 256, 4)
-                    .stride(2)
-                    .padding(1)
-                    .with_bias(false)
-                    .transposed(true)),
-          batch_norm2(256),
-          conv3(nn::Conv2dOptions(256, 128, 4)
+  struct DCGANGeneratorImpl : nn::Module {
+    DCGANGeneratorImpl(int kNoiseSize)
+        : conv1(nn::ConvTranspose2dOptions(kNoiseSize, 256, 4)
+                    .bias(false)),
+          batch_norm1(256),
+          conv2(nn::ConvTranspose2dOptions(256, 128, 3)
                     .stride(2)
                     .padding(1)
-                    .with_bias(false)
-                    .transposed(true)),
-          batch_norm3(128),
-          conv4(nn::Conv2dOptions(128, 64, 4)
+                    .bias(false)),
+          batch_norm2(128),
+          conv3(nn::ConvTranspose2dOptions(128, 64, 4)
                     .stride(2)
                     .padding(1)
-                    .with_bias(false)
-                    .transposed(true)),
-          batch_norm4(64),
-          conv5(nn::Conv2dOptions(64, 1, 4)
+                    .bias(false)),
+          batch_norm3(64),
+          conv4(nn::ConvTranspose2dOptions(64, 1, 4)
                     .stride(2)
                     .padding(1)
-                    .with_bias(false)
-                    .transposed(true)) {}
-
-    torch::Tensor forward(torch::Tensor x) {
-      x = torch::relu(batch_norm1(conv1(x)));
-      x = torch::relu(batch_norm2(conv2(x)));
-      x = torch::relu(batch_norm3(conv3(x)));
-      x = torch::relu(batch_norm4(conv4(x)));
-      x = torch::tanh(conv5(x));
-      return x;
-    }
-
-    nn::Conv2d conv1, conv2, conv3, conv4, conv5;
-    nn::BatchNorm batch_norm1, batch_norm2, batch_norm3, batch_norm4;
+                    .bias(false))
+   {
+     // register_module() is needed if we want to use the parameters() method later on
+     register_module("conv1", conv1);
+     register_module("conv2", conv2);
+     register_module("conv3", conv3);
+     register_module("conv4", conv4);
+     register_module("batch_norm1", batch_norm1);
+     register_module("batch_norm2", batch_norm2);
+     register_module("batch_norm3", batch_norm3);
+   }
+
+   torch::Tensor forward(torch::Tensor x) {
+     x = torch::relu(batch_norm1(conv1(x)));
+     x = torch::relu(batch_norm2(conv2(x)));
+     x = torch::relu(batch_norm3(conv3(x)));
+     x = torch::tanh(conv4(x));
+     return x;
+   }
+
+   nn::ConvTranspose2d conv1, conv2, conv3, conv4;
+   nn::BatchNorm2d batch_norm1, batch_norm2, batch_norm3;
   };
-  TORCH_MODULE(Generator);
+  TORCH_MODULE(DCGANGenerator);
+
+  DCGANGenerator generator(kNoiseSize);
+
+We can now invoke ``forward()`` on the ``DCGANGenerator`` to map a noise sample to an image.
+
+The particular modules chosen, like ``nn::ConvTranspose2d`` and ``nn::BatchNorm2d``,
+follows the structure outlined earlier. The ``kNoiseSize`` constant determines
+the size of the input noise vector and is set to ``100``. Hyperparameters were,
+of course, found via grad student descent.
 
-  Generator generator;
+.. attention::
 
-Whichever approach we use, we can now invoke ``forward()`` on the ``Generator`` to
-map a noise sample to an image.
+	No grad students were harmed in the discovery of hyperparameters. They were
+	fed Soylent regularly.
 
 .. note::
 
 	A brief word on the way options are passed to built-in modules like ``Conv2d``
 	in the C++ frontend: Every module has some required options, like the number
-	of features for ``BatchNorm``. If you only need to configure the required
+	of features for ``BatchNorm2d``. If you only need to configure the required
 	options, you can pass them directly to the module's constructor, like
-	``BatchNorm(128)`` or ``Dropout(0.5)`` or ``Conv2d(8, 4, 2)`` (for input
+	``BatchNorm2d(128)`` or ``Dropout(0.5)`` or ``Conv2d(8, 4, 2)`` (for input
 	channel count, output channel count, and kernel size). If, however, you need
-	to modify other options, which are normally defaulted, such as ``with_bias``
+	to modify other options, which are normally defaulted, such as ``bias``
 	for ``Conv2d``, you need to construct and pass an *options* object. Every
 	module in the C++ frontend has an associated options struct, called
 	``ModuleOptions`` where ``Module`` is the name of the module, like
@@ -840,36 +804,42 @@ and activations. However, the convolutions are now regular ones instead of
 transposed, and we use a leaky ReLU with an alpha value of 0.2 instead of a
 vanilla ReLU. Also, the final activation becomes a Sigmoid, which squashes
 values into a range between 0 and 1. We can then interpret these squashed values
-as the probabilities the discriminator assigns to images being real:
+as the probabilities the discriminator assigns to images being real.
+
+To build the discriminator, we will try something different: a `Sequential` module.
+Like in Python, PyTorch here provides two APIs for model definition: a functional one
+where inputs are passed through successive functions (e.g. the generator module example),
+and a more object-oriented one where we build a `Sequential` module containing the
+entire model as submodules. Using `Sequential`, the discriminator would look like:
 
 .. code-block:: cpp
 
   nn::Sequential discriminator(
     // Layer 1
     nn::Conv2d(
-        nn::Conv2dOptions(1, 64, 4).stride(2).padding(1).with_bias(false)),
-    nn::Functional(torch::leaky_relu, 0.2),
+        nn::Conv2dOptions(1, 64, 4).stride(2).padding(1).bias(false)),
+    nn::LeakyReLU(nn::LeakyReLUOptions().negative_slope(0.2)),
     // Layer 2
     nn::Conv2d(
-        nn::Conv2dOptions(64, 128, 4).stride(2).padding(1).with_bias(false)),
-    nn::BatchNorm(128),
-    nn::Functional(torch::leaky_relu, 0.2),
+        nn::Conv2dOptions(64, 128, 4).stride(2).padding(1).bias(false)),
+    nn::BatchNorm2d(128),
+    nn::LeakyReLU(nn::LeakyReLUOptions().negative_slope(0.2)),
     // Layer 3
     nn::Conv2d(
-        nn::Conv2dOptions(128, 256, 4).stride(2).padding(1).with_bias(false)),
-    nn::BatchNorm(256),
-    nn::Functional(torch::leaky_relu, 0.2),
+        nn::Conv2dOptions(128, 256, 4).stride(2).padding(1).bias(false)),
+    nn::BatchNorm2d(256),
+    nn::LeakyReLU(nn::LeakyReLUOptions().negative_slope(0.2)),
     // Layer 4
     nn::Conv2d(
-        nn::Conv2dOptions(256, 1, 3).stride(1).padding(0).with_bias(false)),
-    nn::Functional(torch::sigmoid));
+        nn::Conv2dOptions(256, 1, 3).stride(1).padding(0).bias(false)),
+    nn::Sigmoid());
 
-.. note::
+.. tip::
+
+  A ``Sequential`` module simply performs function composition. The output of
+  the first submodule becomes the input of the second, the output of the third
+  becomes the input of the fourth and so on.
 
-	When the function we pass to ``Functional`` takes more arguments than a single
-	tensor, we can pass them to the ``Functional`` constructor, which will forward
-	them to each function call. For the leaky ReLU above, this means
-	``torch::leaky_relu(previous_output_tensor, 0.2)`` is called.
 
 Loading Data
 ------------
@@ -909,7 +879,7 @@ stacks them into a single tensor along the first dimension:
 
 Note that the MNIST dataset should be located in the ``./mnist`` directory
 relative to wherever you execute the training binary from. You can use `this
-script <https://gist.github.com/goldsborough/6dd52a5e01ed73a642c1e772084bcd03>`_
+script <https://gist.github.com/jbschlosser/94347505df6188f8764793ee29fd1bdd>`_
 to download the MNIST dataset.
 
 Next, we create a data loader and pass it this dataset. To make a new data
@@ -996,9 +966,9 @@ we use implement the `Adam <https://arxiv.org/pdf/1412.6980.pdf>`_ algorithm:
 .. code-block:: cpp
 
   torch::optim::Adam generator_optimizer(
-      generator->parameters(), torch::optim::AdamOptions(2e-4).beta1(0.5));
+      generator->parameters(), torch::optim::AdamOptions(2e-4).betas(std::make_tuple(0.5, 0.5)));
   torch::optim::Adam discriminator_optimizer(
-      discriminator->parameters(), torch::optim::AdamOptions(5e-4).beta1(0.5));
+      discriminator->parameters(), torch::optim::AdamOptions(5e-4).betas(std::make_tuple(0.5, 0.5)));
 
 .. note::
 
@@ -1019,7 +989,7 @@ the data loader every epoch and then write the GAN training code:
       discriminator->zero_grad();
       torch::Tensor real_images = batch.data;
       torch::Tensor real_labels = torch::empty(batch.data.size(0)).uniform_(0.8, 1.0);
-      torch::Tensor real_output = discriminator->forward(real_images);
+      torch::Tensor real_output = discriminator->forward(real_images).reshape(real_labels.sizes());
       torch::Tensor d_loss_real = torch::binary_cross_entropy(real_output, real_labels);
       d_loss_real.backward();
 
@@ -1027,7 +997,7 @@ the data loader every epoch and then write the GAN training code:
       torch::Tensor noise = torch::randn({batch.data.size(0), kNoiseSize, 1, 1});
       torch::Tensor fake_images = generator->forward(noise);
       torch::Tensor fake_labels = torch::zeros(batch.data.size(0));
-      torch::Tensor fake_output = discriminator->forward(fake_images.detach());
+      torch::Tensor fake_output = discriminator->forward(fake_images.detach()).reshape(fake_labels.sizes());
       torch::Tensor d_loss_fake = torch::binary_cross_entropy(fake_output, fake_labels);
       d_loss_fake.backward();
 
@@ -1037,7 +1007,7 @@ the data loader every epoch and then write the GAN training code:
       // Train generator.
       generator->zero_grad();
       fake_labels.fill_(1);
-      fake_output = discriminator->forward(fake_images);
+      fake_output = discriminator->forward(fake_images).reshape(fake_labels.sizes());
       torch::Tensor g_loss = torch::binary_cross_entropy(fake_output, fake_labels);
       g_loss.backward();
       generator_optimizer.step();
@@ -1065,7 +1035,7 @@ probabilities.
 	is called *label smoothing*.
 
 Before evaluating the discriminator, we zero out the gradients of its
-parameters. After computing the loss, we back-propagate through the network by
+parameters. After computing the loss, we back-propagate it through the network by
 calling ``d_loss.backward()`` to compute new gradients. We repeat this spiel for
 the fake images. Instead of using images from the dataset, we let the generator
 create fake images for this by feeding it a batch of random noise. We then
@@ -1266,9 +1236,6 @@ tensors and display them with matplotlib:
 
 .. code-block:: python
 
-  from __future__ import print_function
-  from __future__ import unicode_literals
-
   import argparse
 
   import matplotlib.pyplot as plt
@@ -1320,7 +1287,7 @@ Let's now train our model for around 30 epochs:
   -> checkpoint 120
   [30/30][938/938] D_loss: 0.3610 | G_loss: 3.8084
 
-And display the imags in a plot:
+And display the images in a plot:
 
 .. code-block:: shell
 
diff --git a/advanced_source/custom_class_pt2.rst b/advanced_source/custom_class_pt2.rst
new file mode 100644
index 00000000000..229a94f2ce9
--- /dev/null
+++ b/advanced_source/custom_class_pt2.rst
@@ -0,0 +1,275 @@
+Supporting Custom C++ Classes in torch.compile/torch.export
+===========================================================
+
+
+This tutorial is a follow-on to the
+:doc:`custom C++ classes <custom_classes>` tutorial, and
+introduces additional steps that are needed to support custom C++ classes in
+torch.compile/torch.export.
+
+.. warning::
+
+    This feature is in prototype status and is subject to backwards compatibility
+    breaking changes. This tutorial provides a snapshot as of PyTorch 2.8. If
+    you run into any issues, please reach out to us on Github!
+
+Concretely, there are a few steps:
+
+1. Implement an ``__obj_flatten__`` method to the C++ custom class
+   implementation to allow us to inspect its states and guard the changes. The
+   method should return a tuple of tuple of attribute_name, value
+   (``tuple[tuple[str, value] * n]``).
+
+2. Register a python fake class using ``@torch._library.register_fake_class``
+
+    a. Implement “fake methods” of each of the class’s c++ methods, which should
+       have the same schema as the C++ implementation.
+
+    b. Additionally, implement an ``__obj_unflatten__`` classmethod in the Python
+       fake class to tell us how to create a fake class from the flattened
+       states returned by ``__obj_flatten__``.
+
+Here is a breakdown of the diff. Following the guide in
+:doc:`Extending TorchScript with Custom C++ Classes <custom_classes>`,
+we can create a thread-safe tensor queue and build it.
+
+.. code-block:: cpp
+
+    // Thread-safe Tensor Queue
+
+    #include <torch/custom_class.h>
+    #include <torch/script.h>
+
+    #include <iostream>
+    #include <string>
+    #include <vector>
+
+    using namespace torch::jit;
+
+    // Thread-safe Tensor Queue
+    struct TensorQueue : torch::CustomClassHolder {
+    explicit TensorQueue(at::Tensor t) : init_tensor_(t) {}
+
+    explicit TensorQueue(c10::Dict<std::string, at::Tensor> dict) {
+        init_tensor_ = dict.at(std::string("init_tensor"));
+        const std::string key = "queue";
+        at::Tensor size_tensor;
+        size_tensor = dict.at(std::string(key + "/size")).cpu();
+        const auto* size_tensor_acc = size_tensor.const_data_ptr<int64_t>();
+        int64_t queue_size = size_tensor_acc[0];
+
+        for (const auto index : c10::irange(queue_size)) {
+            at::Tensor val;
+            queue_[index] = dict.at(key + "/" + std::to_string(index));
+            queue_.push_back(val);
+        }
+    }
+
+    // Push the element to the rear of queue.
+    // Lock is added for thread safe.
+    void push(at::Tensor x) {
+        std::lock_guard<std::mutex> guard(mutex_);
+        queue_.push_back(x);
+    }
+    // Pop the front element of queue and return it.
+    // If empty, return init_tensor_.
+    // Lock is added for thread safe.
+    at::Tensor pop() {
+        std::lock_guard<std::mutex> guard(mutex_);
+        if (!queue_.empty()) {
+            auto val = queue_.front();
+            queue_.pop_front();
+            return val;
+        } else {
+            return init_tensor_;
+        }
+    }
+
+    std::vector<at::Tensor> get_raw_queue() {
+        std::vector<at::Tensor> raw_queue(queue_.begin(), queue_.end());
+        return raw_queue;
+    }
+
+    private:
+        std::deque<at::Tensor> queue_;
+        std::mutex mutex_;
+        at::Tensor init_tensor_;
+    };
+
+    // The torch binding code
+    TORCH_LIBRARY(MyCustomClass, m) {
+        m.class_<TensorQueue>("TensorQueue")
+            .def(torch::init<at::Tensor>())
+            .def("push", &TensorQueue::push)
+            .def("pop", &TensorQueue::pop)
+            .def("get_raw_queue", &TensorQueue::get_raw_queue);
+    }
+
+**Step 1**: Add an ``__obj_flatten__`` method to the C++ custom class implementation:
+
+.. code-block:: cpp
+
+    // Thread-safe Tensor Queue
+    struct TensorQueue : torch::CustomClassHolder {
+    ...
+    std::tuple<std::tuple<std::string, std::vector<at::Tensor>>, std::tuple<std::string, at::Tensor>> __obj_flatten__() {
+        return std::tuple(std::tuple("queue", this->get_raw_queue()), std::tuple("init_tensor_", this->init_tensor_.clone()));
+    }
+    ...
+    };
+
+    TORCH_LIBRARY(MyCustomClass, m) {
+        m.class_<TensorQueue>("TensorQueue")
+            .def(torch::init<at::Tensor>())
+            ...
+            .def("__obj_flatten__", &TensorQueue::__obj_flatten__);
+    }
+
+**Step 2a**: Register a fake class in Python that implements each method.
+
+.. code-block:: python
+
+    # namespace::class_name
+    @torch._library.register_fake_class("MyCustomClass::TensorQueue")
+    class FakeTensorQueue:
+        def __init__(
+            self,
+            queue: List[torch.Tensor],
+            init_tensor_: torch.Tensor
+        ) -> None:
+            self.queue = queue
+            self.init_tensor_ = init_tensor_
+
+        def push(self, tensor: torch.Tensor) -> None:
+            self.queue.append(tensor)
+
+        def pop(self) -> torch.Tensor:
+            if len(self.queue) > 0:
+                return self.queue.pop(0)
+            return self.init_tensor_
+
+**Step 2b**: Implement an ``__obj_unflatten__`` classmethod in Python.
+
+.. code-block:: python
+
+    # namespace::class_name
+    @torch._library.register_fake_class("MyCustomClass::TensorQueue")
+    class FakeTensorQueue:
+        ...
+        @classmethod
+        def __obj_unflatten__(cls, flattened_tq):
+            return cls(**dict(flattened_tq))
+
+
+That’s it! Now we can create a module that uses this object and run it with ``torch.compile`` or ``torch.export``.
+
+.. code-block:: python
+
+    import torch
+
+    torch.classes.load_library("build/libcustom_class.so")
+    tq = torch.classes.MyCustomClass.TensorQueue(torch.empty(0).fill_(-1))
+
+    class Mod(torch.nn.Module):
+        def forward(self, tq, x):
+            tq.push(x.sin())
+            tq.push(x.cos())
+            poped_t = tq.pop()
+            assert torch.allclose(poped_t, x.sin())
+            return tq, poped_t
+
+    tq, poped_t = torch.compile(Mod(), backend="eager", fullgraph=True)(tq, torch.randn(2, 3))
+    assert tq.size() == 1
+
+    exported_program = torch.export.export(Mod(), (tq, torch.randn(2, 3),), strict=False)
+    exported_program.module()(tq, torch.randn(2, 3))
+
+We can also implement custom ops that take custom classes as inputs. For
+example, we could register a custom op ``for_each_add_(tq, tensor)``
+
+.. code-block:: cpp
+
+    struct TensorQueue : torch::CustomClassHolder {
+        ...
+        void for_each_add_(at::Tensor inc) {
+            for (auto& t : queue_) {
+                t.add_(inc);
+            }
+        }
+        ...
+    }
+
+
+    TORCH_LIBRARY_FRAGMENT(MyCustomClass, m) {
+        m.class_<TensorQueue>("TensorQueue")
+            ...
+            .def("for_each_add_", &TensorQueue::for_each_add_);
+
+        m.def(
+            "for_each_add_(__torch__.torch.classes.MyCustomClass.TensorQueue foo, Tensor inc) -> ()");
+    }
+
+    void for_each_add_(c10::intrusive_ptr<TensorQueue> tq, at::Tensor inc) {
+        tq->for_each_add_(inc);
+    }
+
+    TORCH_LIBRARY_IMPL(MyCustomClass, CPU, m) {
+        m.impl("for_each_add_", for_each_add_);
+    }
+
+
+Since the fake class is implemented in python, we require the fake
+implementation of custom op must also be registered in python:
+
+.. code-block:: python
+
+    @torch.library.register_fake("MyCustomClass::for_each_add_")
+    def fake_for_each_add_(tq, inc):
+        tq.for_each_add_(inc)
+
+After re-compilation, we can export the custom op with:
+
+.. code-block:: python
+
+    class ForEachAdd(torch.nn.Module):
+        def forward(self, tq: torch.ScriptObject, a: torch.Tensor) -> torch.ScriptObject:
+            torch.ops.MyCustomClass.for_each_add_(tq, a)
+            return tq
+
+    mod = ForEachAdd()
+    tq = empty_tensor_queue()
+    qlen = 10
+    for i in range(qlen):
+        tq.push(torch.zeros(1))
+
+    ep = torch.export.export(mod, (tq, torch.ones(1)), strict=False)
+
+Why do we need to make a Fake Class?
+------------------------------------
+
+Tracing with real custom object has several major downsides:
+
+1. Operators on real objects can be time consuming e.g. the custom object
+   might be reading from the network or loading data from the disk.
+
+2. We don’t want to mutate the real custom object or create side-effects to the environment while tracing.
+
+3. It cannot support dynamic shapes.
+
+However, it may be difficult for users to write a fake class, e.g. if the
+original class uses some third-party library that determines the output shape of
+the methods, or is complicated and written by others. In such cases, users can
+disable the fakification requirement by defining a ``tracing_mode`` method to
+return ``"real"``:
+
+.. code-block:: cpp
+
+    std::string tracing_mode() {
+        return "real";
+    }
+
+
+A caveat of fakification is regarding **tensor aliasing.** We assume that no
+tensors within a torchbind object aliases a tensor outside of the torchbind
+object. Therefore, mutating one of these tensors will result in undefined
+behavior.
diff --git a/advanced_source/custom_classes.rst b/advanced_source/custom_classes.rst
new file mode 100644
index 00000000000..014bac2eebf
--- /dev/null
+++ b/advanced_source/custom_classes.rst
@@ -0,0 +1,231 @@
+Extending PyTorch with Custom C++ Classes
+===============================================
+
+
+This tutorial introduces an API for binding C++ classes into PyTorch.
+The API is very similar to
+`pybind11 <https://github.com/pybind/pybind11>`_, and most of the concepts will transfer
+over if you're familiar with that system.
+
+Implementing and Binding the Class in C++
+-----------------------------------------
+
+For this tutorial, we are going to define a simple C++ class that maintains persistent
+state in a member variable.
+
+.. literalinclude:: ../advanced_source/custom_classes/custom_class_project/class.cpp
+  :language: cpp
+  :start-after: BEGIN class
+  :end-before: END class
+
+There are several things to note:
+
+- ``torch/custom_class.h`` is the header you need to include to extend PyTorch
+  with your custom class.
+- Notice that whenever we are working with instances of the custom
+  class, we do it via instances of ``c10::intrusive_ptr<>``. Think of ``intrusive_ptr``
+  as a smart pointer like ``std::shared_ptr``, but the reference count is stored
+  directly in the object, as opposed to a separate metadata block (as is done in
+  ``std::shared_ptr``.  ``torch::Tensor`` internally uses the same pointer type;
+  and custom classes have to also use this pointer type so that we can
+  consistently manage different object types.
+- The second thing to notice is that the user-defined class must inherit from
+  ``torch::CustomClassHolder``. This ensures that the custom class has space to
+  store the reference count.
+
+Now let's take a look at how we will make this class visible to PyTorch, a process called
+*binding* the class:
+
+.. literalinclude:: ../advanced_source/custom_classes/custom_class_project/class.cpp
+  :language: cpp
+  :start-after: BEGIN binding
+  :end-before: END binding
+  :append:
+      ;
+    }
+
+
+
+Building the Example as a C++ Project With CMake
+------------------------------------------------
+
+Now, we're going to build the above C++ code with the `CMake
+<https://cmake.org>`_ build system. First, take all the C++ code
+we've covered so far and place it in a file called ``class.cpp``.
+Then, write a simple ``CMakeLists.txt`` file and place it in the
+same directory. Here is what ``CMakeLists.txt`` should look like:
+
+.. literalinclude:: ../advanced_source/custom_classes/custom_class_project/CMakeLists.txt
+  :language: cmake
+
+Also, create a ``build`` directory. Your file tree should look like this::
+
+  custom_class_project/
+    class.cpp
+    CMakeLists.txt
+    build/
+
+Go ahead and invoke cmake and then make to build the project:
+
+.. code-block:: shell
+
+  $ cd build
+  $ cmake -DCMAKE_PREFIX_PATH="$(python -c 'import torch.utils; print(torch.utils.cmake_prefix_path)')" ..
+    -- The C compiler identification is GNU 7.3.1
+    -- The CXX compiler identification is GNU 7.3.1
+    -- Check for working C compiler: /opt/rh/devtoolset-7/root/usr/bin/cc
+    -- Check for working C compiler: /opt/rh/devtoolset-7/root/usr/bin/cc -- works
+    -- Detecting C compiler ABI info
+    -- Detecting C compiler ABI info - done
+    -- Detecting C compile features
+    -- Detecting C compile features - done
+    -- Check for working CXX compiler: /opt/rh/devtoolset-7/root/usr/bin/c++
+    -- Check for working CXX compiler: /opt/rh/devtoolset-7/root/usr/bin/c++ -- works
+    -- Detecting CXX compiler ABI info
+    -- Detecting CXX compiler ABI info - done
+    -- Detecting CXX compile features
+    -- Detecting CXX compile features - done
+    -- Looking for pthread.h
+    -- Looking for pthread.h - found
+    -- Looking for pthread_create
+    -- Looking for pthread_create - not found
+    -- Looking for pthread_create in pthreads
+    -- Looking for pthread_create in pthreads - not found
+    -- Looking for pthread_create in pthread
+    -- Looking for pthread_create in pthread - found
+    -- Found Threads: TRUE
+    -- Found torch: /torchbind_tutorial/libtorch/lib/libtorch.so
+    -- Configuring done
+    -- Generating done
+    -- Build files have been written to: /torchbind_tutorial/build
+  $ make -j
+    Scanning dependencies of target custom_class
+    [ 50%] Building CXX object CMakeFiles/custom_class.dir/class.cpp.o
+    [100%] Linking CXX shared library libcustom_class.so
+    [100%] Built target custom_class
+
+What you'll find is there is now (among other things) a dynamic library
+file present in the build directory. On Linux, this is probably named
+``libcustom_class.so``. So the file tree should look like::
+
+  custom_class_project/
+    class.cpp
+    CMakeLists.txt
+    build/
+      libcustom_class.so
+
+Using the C++ Class from Python
+-----------------------------------------------
+
+Now that we have our class and its registration compiled into an ``.so`` file,
+we can load that `.so` into Python and try it out. Here's a script that
+demonstrates that:
+
+.. literalinclude:: ../advanced_source/custom_classes/custom_class_project/custom_test.py
+  :language: python
+
+
+Defining Serialization/Deserialization Methods for Custom C++ Classes
+---------------------------------------------------------------------
+
+If you try to save a ``ScriptModule`` with a custom-bound C++ class as
+an attribute, you'll get the following error:
+
+.. literalinclude:: ../advanced_source/custom_classes/custom_class_project/export_attr.py
+  :language: python
+
+.. code-block:: shell
+
+  $ python export_attr.py
+  RuntimeError: Cannot serialize custom bound C++ class __torch__.torch.classes.my_classes.MyStackClass. Please define serialization methods via def_pickle for this class. (pushIValueImpl at ../torch/csrc/jit/pickler.cpp:128)
+
+This is because PyTorch cannot automatically figure out what information
+save from your C++ class. You must specify that manually. The way to do that
+is to define ``__getstate__`` and ``__setstate__`` methods on the class using
+the special ``def_pickle`` method on ``class_``.
+
+.. note::
+  The semantics of ``__getstate__`` and ``__setstate__`` are
+  equivalent to that of the Python pickle module. You can
+  `read more <https://github.com/pytorch/pytorch/blob/master/torch/csrc/jit/docs/serialization.md#getstate-and-setstate>`_
+  about how we use these methods.
+
+Here is an example of the ``def_pickle`` call we can add to the registration of
+``MyStackClass`` to include serialization methods:
+
+.. literalinclude:: ../advanced_source/custom_classes/custom_class_project/class.cpp
+  :language: cpp
+  :start-after: BEGIN def_pickle
+  :end-before: END def_pickle
+
+.. note::
+  We take a different approach from pybind11 in the pickle API. Whereas pybind11
+  as a special function ``pybind11::pickle()`` which you pass into ``class_::def()``,
+  we have a separate method ``def_pickle`` for this purpose. This is because the
+  name ``torch::jit::pickle`` was already taken, and we didn't want to cause confusion.
+
+Once we have defined the (de)serialization behavior in this way, our script can
+now run successfully:
+
+.. code-block:: shell
+
+  $ python ../export_attr.py
+  testing
+
+Defining Custom Operators that Take or Return Bound C++ Classes
+---------------------------------------------------------------
+
+Once you've defined a custom C++ class, you can also use that class
+as an argument or return from a custom operator (i.e. free functions). Suppose
+you have the following free function:
+
+.. literalinclude:: ../advanced_source/custom_classes/custom_class_project/class.cpp
+  :language: cpp
+  :start-after: BEGIN free_function
+  :end-before: END free_function
+
+You can register it running the following code inside your ``TORCH_LIBRARY``
+block:
+
+.. literalinclude:: ../advanced_source/custom_classes/custom_class_project/class.cpp
+  :language: cpp
+  :start-after: BEGIN def_free
+  :end-before: END def_free
+
+Once this is done, you can use the op like the following example:
+
+.. code-block:: python
+
+  class TryCustomOp(torch.nn.Module):
+      def __init__(self):
+          super(TryCustomOp, self).__init__()
+          self.f = torch.classes.my_classes.MyStackClass(["foo", "bar"])
+
+      def forward(self):
+          return torch.ops.my_classes.manipulate_instance(self.f)
+
+.. note::
+
+  Registration of an operator that takes a C++ class as an argument requires that
+  the custom class has already been registered.  You can enforce this by
+  making sure the custom class registration and your free function definitions
+  are in the same ``TORCH_LIBRARY`` block, and that the custom class
+  registration comes first.  In the future, we may relax this requirement,
+  so that these can be registered in any order.
+
+
+Conclusion
+----------
+
+This tutorial walked you through how to expose a C++ class to PyTorch, how to
+register its methods, how to use that class from Python, and how to save and
+load code using the class and run that code in a standalone C++ process. You
+are now ready to extend your PyTorch models with C++ classes that interface
+with third party C++ libraries or implement any other use case that requires
+the lines between Python and C++ to blend smoothly.
+
+As always, if you run into any problems or have questions, you can use our
+`forum <https://discuss.pytorch.org/>`_ or `GitHub issues
+<https://github.com/pytorch/pytorch/issues>`_ to get in touch. Also, our
+`frequently asked questions (FAQ) page
+<https://pytorch.org/cppdocs/notes/faq.html>`_ may have helpful information.
diff --git a/advanced_source/custom_classes/CMakeLists.txt b/advanced_source/custom_classes/CMakeLists.txt
new file mode 100644
index 00000000000..6a1eb3e87fa
--- /dev/null
+++ b/advanced_source/custom_classes/CMakeLists.txt
@@ -0,0 +1,15 @@
+cmake_minimum_required(VERSION 3.1 FATAL_ERROR)
+project(infer)
+
+find_package(Torch REQUIRED)
+
+add_subdirectory(custom_class_project)
+
+# Define our library target
+add_executable(infer infer.cpp)
+set(CMAKE_CXX_STANDARD 14)
+# Link against LibTorch
+target_link_libraries(infer "${TORCH_LIBRARIES}")
+# This is where we link in our libcustom_class code, making our
+# custom class available in our binary.
+target_link_libraries(infer -Wl,--no-as-needed custom_class)
diff --git a/advanced_source/custom_classes/custom_class_project/CMakeLists.txt b/advanced_source/custom_classes/custom_class_project/CMakeLists.txt
new file mode 100644
index 00000000000..bb3d41aa997
--- /dev/null
+++ b/advanced_source/custom_classes/custom_class_project/CMakeLists.txt
@@ -0,0 +1,10 @@
+cmake_minimum_required(VERSION 3.1 FATAL_ERROR)
+project(custom_class)
+
+find_package(Torch REQUIRED)
+
+# Define our library target
+add_library(custom_class SHARED class.cpp)
+set(CMAKE_CXX_STANDARD 14)
+# Link against LibTorch
+target_link_libraries(custom_class "${TORCH_LIBRARIES}")
diff --git a/advanced_source/custom_classes/custom_class_project/class.cpp b/advanced_source/custom_classes/custom_class_project/class.cpp
new file mode 100644
index 00000000000..dc89a3ecb2e
--- /dev/null
+++ b/advanced_source/custom_classes/custom_class_project/class.cpp
@@ -0,0 +1,132 @@
+// BEGIN class
+// This header is all you need to do the C++ portions of this
+// tutorial
+#include <torch/script.h>
+// This header is what defines the custom class registration
+// behavior specifically. script.h already includes this, but
+// we include it here so you know it exists in case you want
+// to look at the API or implementation.
+#include <torch/custom_class.h>
+
+#include <string>
+#include <vector>
+
+template <class T>
+struct MyStackClass : torch::CustomClassHolder {
+  std::vector<T> stack_;
+  MyStackClass(std::vector<T> init) : stack_(init.begin(), init.end()) {}
+
+  void push(T x) {
+    stack_.push_back(x);
+  }
+  T pop() {
+    auto val = stack_.back();
+    stack_.pop_back();
+    return val;
+  }
+
+  c10::intrusive_ptr<MyStackClass> clone() const {
+    return c10::make_intrusive<MyStackClass>(stack_);
+  }
+
+  void merge(const c10::intrusive_ptr<MyStackClass>& c) {
+    for (auto& elem : c->stack_) {
+      push(elem);
+    }
+  }
+};
+// END class
+
+// BEGIN free_function
+c10::intrusive_ptr<MyStackClass<std::string>> manipulate_instance(const c10::intrusive_ptr<MyStackClass<std::string>>& instance) {
+  instance->pop();
+  return instance;
+}
+// END free_function
+
+// BEGIN binding
+// Notice a few things:
+// - We pass the class to be registered as a template parameter to
+//   `torch::class_`. In this instance, we've passed the
+//   specialization of the MyStackClass class ``MyStackClass<std::string>``.
+//   In general, you cannot register a non-specialized template
+//   class. For non-templated classes, you can just pass the
+//   class name directly as the template parameter.
+// - The arguments passed to the constructor make up the "qualified name"
+//   of the class. In this case, the registered class will appear in
+//   Python and C++ as `torch.classes.my_classes.MyStackClass`. We call
+//   the first argument the "namespace" and the second argument the
+//   actual class name.
+TORCH_LIBRARY(my_classes, m) {
+  m.class_<MyStackClass<std::string>>("MyStackClass")
+    // The following line registers the contructor of our MyStackClass
+    // class that takes a single `std::vector<std::string>` argument,
+    // i.e. it exposes the C++ method `MyStackClass(std::vector<T> init)`.
+    // Currently, we do not support registering overloaded
+    // constructors, so for now you can only `def()` one instance of
+    // `torch::init`.
+    .def(torch::init<std::vector<std::string>>())
+    // The next line registers a stateless (i.e. no captures) C++ lambda
+    // function as a method. Note that a lambda function must take a
+    // `c10::intrusive_ptr<YourClass>` (or some const/ref version of that)
+    // as the first argument. Other arguments can be whatever you want.
+    .def("top", [](const c10::intrusive_ptr<MyStackClass<std::string>>& self) {
+      return self->stack_.back();
+    })
+    // The following four lines expose methods of the MyStackClass<std::string>
+    // class as-is. `torch::class_` will automatically examine the
+    // argument and return types of the passed-in method pointers and
+    // expose these to Python and TorchScript accordingly. Finally, notice
+    // that we must take the *address* of the fully-qualified method name,
+    // i.e. use the unary `&` operator, due to C++ typing rules.
+    .def("push", &MyStackClass<std::string>::push)
+    .def("pop", &MyStackClass<std::string>::pop)
+    .def("clone", &MyStackClass<std::string>::clone)
+    .def("merge", &MyStackClass<std::string>::merge)
+// END binding
+#ifndef NO_PICKLE
+// BEGIN def_pickle
+    // class_<>::def_pickle allows you to define the serialization
+    // and deserialization methods for your C++ class.
+    // Currently, we only support passing stateless lambda functions
+    // as arguments to def_pickle
+    .def_pickle(
+          // __getstate__
+          // This function defines what data structure should be produced
+          // when we serialize an instance of this class. The function
+          // must take a single `self` argument, which is an intrusive_ptr
+          // to the instance of the object. The function can return
+          // any type that is supported as a return value of the TorchScript
+          // custom operator API. In this instance, we've chosen to return
+          // a std::vector<std::string> as the salient data to preserve
+          // from the class.
+          [](const c10::intrusive_ptr<MyStackClass<std::string>>& self)
+              -> std::vector<std::string> {
+            return self->stack_;
+          },
+          // __setstate__
+          // This function defines how to create a new instance of the C++
+          // class when we are deserializing. The function must take a
+          // single argument of the same type as the return value of
+          // `__getstate__`. The function must return an intrusive_ptr
+          // to a new instance of the C++ class, initialized however
+          // you would like given the serialized state.
+          [](std::vector<std::string> state)
+              -> c10::intrusive_ptr<MyStackClass<std::string>> {
+            // A convenient way to instantiate an object and get an
+            // intrusive_ptr to it is via `make_intrusive`. We use
+            // that here to allocate an instance of MyStackClass<std::string>
+            // and call the single-argument std::vector<std::string>
+            // constructor with the serialized state.
+            return c10::make_intrusive<MyStackClass<std::string>>(std::move(state));
+          });
+// END def_pickle
+#endif // NO_PICKLE
+
+// BEGIN def_free
+    m.def(
+      "manipulate_instance(__torch__.torch.classes.my_classes.MyStackClass x) -> __torch__.torch.classes.my_classes.MyStackClass Y",
+      manipulate_instance
+    );
+// END def_free
+}
diff --git a/advanced_source/custom_classes/custom_class_project/custom_test.py b/advanced_source/custom_classes/custom_class_project/custom_test.py
new file mode 100644
index 00000000000..1deda445310
--- /dev/null
+++ b/advanced_source/custom_classes/custom_class_project/custom_test.py
@@ -0,0 +1,53 @@
+import torch
+
+# `torch.classes.load_library()` allows you to pass the path to your .so file
+# to load it in and make the custom C++ classes available to both Python and
+# TorchScript
+torch.classes.load_library("build/libcustom_class.so")
+# You can query the loaded libraries like this:
+print(torch.classes.loaded_libraries)
+# prints {'/custom_class_project/build/libcustom_class.so'}
+
+# We can find and instantiate our custom C++ class in python by using the
+# `torch.classes` namespace:
+#
+# This instantiation will invoke the MyStackClass(std::vector<T> init)
+# constructor we registered earlier
+s = torch.classes.my_classes.MyStackClass(["foo", "bar"])
+
+# We can call methods in Python
+s.push("pushed")
+assert s.pop() == "pushed"
+
+# Test custom operator
+s.push("pushed")
+torch.ops.my_classes.manipulate_instance(s)  # acting as s.pop()
+assert s.top() == "bar"
+
+# Returning and passing instances of custom classes works as you'd expect
+s2 = s.clone()
+s.merge(s2)
+for expected in ["bar", "foo", "bar", "foo"]:
+    assert s.pop() == expected
+
+# We can also use the class in TorchScript
+# For now, we need to assign the class's type to a local in order to
+# annotate the type on the TorchScript function. This may change
+# in the future.
+MyStackClass = torch.classes.my_classes.MyStackClass
+
+
+@torch.jit.script
+def do_stacks(s: MyStackClass):  # We can pass a custom class instance
+    # We can instantiate the class
+    s2 = torch.classes.my_classes.MyStackClass(["hi", "mom"])
+    s2.merge(s)  # We can call a method on the class
+    # We can also return instances of the class
+    # from TorchScript function/methods
+    return s2.clone(), s2.top()
+
+
+stack, top = do_stacks(torch.classes.my_classes.MyStackClass(["wow"]))
+assert top == "wow"
+for expected in ["wow", "mom", "hi"]:
+    assert stack.pop() == expected
diff --git a/advanced_source/custom_classes/custom_class_project/export_attr.py b/advanced_source/custom_classes/custom_class_project/export_attr.py
new file mode 100644
index 00000000000..9999d5c8183
--- /dev/null
+++ b/advanced_source/custom_classes/custom_class_project/export_attr.py
@@ -0,0 +1,21 @@
+# export_attr.py
+import torch
+
+torch.classes.load_library('build/libcustom_class.so')
+
+
+class Foo(torch.nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.stack = torch.classes.my_classes.MyStackClass(["just", "testing"])
+
+    def forward(self, s: str) -> str:
+        return self.stack.pop() + s
+
+
+scripted_foo = torch.jit.script(Foo())
+
+scripted_foo.save('foo.pt')
+loaded = torch.jit.load('foo.pt')
+
+print(loaded.stack.pop())
diff --git a/advanced_source/custom_classes/custom_class_project/save.py b/advanced_source/custom_classes/custom_class_project/save.py
new file mode 100644
index 00000000000..8826f95da7c
--- /dev/null
+++ b/advanced_source/custom_classes/custom_class_project/save.py
@@ -0,0 +1,18 @@
+import torch
+
+torch.classes.load_library('build/libcustom_class.so')
+
+
+class Foo(torch.nn.Module):
+    def __init__(self):
+        super().__init__()
+
+    def forward(self, s: str) -> str:
+        stack = torch.classes.my_classes.MyStackClass(["hi", "mom"])
+        return stack.pop() + s
+
+
+scripted_foo = torch.jit.script(Foo())
+print(scripted_foo.graph)
+
+scripted_foo.save('foo.pt')
diff --git a/advanced_source/custom_classes/infer.cpp b/advanced_source/custom_classes/infer.cpp
new file mode 100644
index 00000000000..1ca5b002383
--- /dev/null
+++ b/advanced_source/custom_classes/infer.cpp
@@ -0,0 +1,20 @@
+#include <torch/script.h>
+
+#include <iostream>
+#include <memory>
+
+int main(int argc, const char* argv[]) {
+  torch::jit::Module module;
+  try {
+    // Deserialize the ScriptModule from a file using torch::jit::load().
+    module = torch::jit::load("foo.pt");
+  }
+  catch (const c10::Error& e) {
+    std::cerr << "error loading the model\n";
+    return -1;
+  }
+
+  std::vector<c10::IValue> inputs = {"foobarbaz"};
+  auto output = module.forward(inputs).toString();
+  std::cout << output->string() << std::endl;
+}
diff --git a/advanced_source/custom_classes/run.sh b/advanced_source/custom_classes/run.sh
new file mode 100755
index 00000000000..52c59581309
--- /dev/null
+++ b/advanced_source/custom_classes/run.sh
@@ -0,0 +1,21 @@
+#!/bin/bash
+
+set -ex
+
+rm -rf build
+rm -rf custom_class_project/build
+
+pushd custom_class_project
+  mkdir build
+  (cd build && cmake CXXFLAGS="-DNO_PICKLE" -DCMAKE_PREFIX_PATH="$(python -c 'import torch.utils; print(torch.utils.cmake_prefix_path)')" ..)
+  (cd build && make)
+  python custom_test.py
+  python save.py
+  ! python export_attr.py
+popd
+
+mkdir build
+(cd build && cmake -DCMAKE_PREFIX_PATH="$(python -c 'import torch.utils; print(torch.utils.cmake_prefix_path)')" ..)
+(cd build && make)
+mv custom_class_project/foo.pt build/foo.pt
+(cd build && ./infer)
diff --git a/advanced_source/custom_classes/run2.sh b/advanced_source/custom_classes/run2.sh
new file mode 100755
index 00000000000..d4ef0101a83
--- /dev/null
+++ b/advanced_source/custom_classes/run2.sh
@@ -0,0 +1,13 @@
+#!/bin/bash
+
+set -ex
+
+rm -rf build
+rm -rf custom_class_project/build
+
+pushd custom_class_project
+  mkdir build
+  (cd build && cmake -DCMAKE_PREFIX_PATH="$(python -c 'import torch.utils; print(torch.utils.cmake_prefix_path)')" ..)
+  (cd build && make)
+  python export_attr.py
+popd
diff --git a/advanced_source/custom_ops_landing_page.rst b/advanced_source/custom_ops_landing_page.rst
new file mode 100644
index 00000000000..f05eee43060
--- /dev/null
+++ b/advanced_source/custom_ops_landing_page.rst
@@ -0,0 +1,66 @@
+.. _custom-ops-landing-page:
+
+PyTorch Custom Operators
+===========================
+
+PyTorch offers a large library of operators that work on Tensors (e.g. ``torch.add``,
+``torch.sum``, etc). However, you may wish to bring a new custom operation to PyTorch
+and get it to work with subsystems like ``torch.compile``, autograd, and ``torch.vmap``.
+In order to do so, you must register the custom operation with PyTorch via the Python
+`torch.library docs <https://pytorch.org/docs/stable/library.html>`_ or C++ ``TORCH_LIBRARY``
+APIs.
+
+
+
+Authoring a custom operator from Python
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Please see :ref:`python-custom-ops-tutorial`.
+
+You may wish to author a custom operator from Python (as opposed to C++) if:
+
+- you have a Python function you want PyTorch to treat as an opaque callable, especially with
+  respect to ``torch.compile`` and ``torch.export``.
+- you have some Python bindings to C++/CUDA kernels and want those to compose with PyTorch
+  subsystems (like ``torch.compile`` or ``torch.autograd``)
+- you are using Python (and not a C++-only environment like AOTInductor).
+
+Integrating custom C++ and/or CUDA code with PyTorch
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Please see :ref:`cpp-custom-ops-tutorial`.
+
+.. note::
+
+  ``SYCL`` serves as the backend programming language for Intel GPUs. Integrate custom Sycl code refer to :ref:`cpp-custom-ops-tutorial-sycl`.
+
+You may wish to author a custom operator from C++ (as opposed to Python) if:
+
+- you have custom C++ and/or CUDA code.
+- you plan to use this code with ``AOTInductor`` to do Python-less inference.
+
+The Custom Operators Manual
+^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+For information not covered in the tutorials and this page, please see
+`The Custom Operators Manual <https://docs.google.com/document/d/1_W62p8WJOQQUzPsJYa7s701JXt0qf2OfLub2sbkHOaU>`_
+(we're working on moving the information to our docs site). We recommend that you
+first read one of the tutorials above and then use the Custom Operators Manual as a reference;
+it is not meant to be read head to toe.
+
+When should I create a Custom Operator?
+---------------------------------------
+If your operation is expressible as a composition of built-in PyTorch operators
+then please write it as a Python function and call it instead of creating a
+custom operator. Use the operator registration APIs to create a custom operator if you
+are calling into some library that PyTorch doesn't understand (e.g. custom C/C++ code,
+a custom CUDA kernel, or Python bindings to C/C++/CUDA extensions).
+
+Why should I create a Custom Operator?
+--------------------------------------
+
+It is possible to use a C/C++/CUDA kernel by grabbing a Tensor's data pointer
+and passing it to a pybind'ed kernel. However, this approach doesn't compose with
+PyTorch subsystems like autograd, torch.compile, vmap, and more. In order
+for an operation to compose with PyTorch subsystems, it must be registered
+via the operator registration APIs.
diff --git a/advanced_source/ddp_pipeline.rst b/advanced_source/ddp_pipeline.rst
new file mode 100644
index 00000000000..bf9e4d28f33
--- /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/dispatcher.rst b/advanced_source/dispatcher.rst
new file mode 100644
index 00000000000..4b03803c15b
--- /dev/null
+++ b/advanced_source/dispatcher.rst
@@ -0,0 +1,410 @@
+Registering a Dispatched Operator in C++
+========================================
+
+.. warning::
+
+    This tutorial is deprecated as of PyTorch 2.4. Please see :ref:`custom-ops-landing-page`
+    for the newest up-to-date guides on extending PyTorch with Custom Operators.
+
+The dispatcher is an internal component of PyTorch which is responsible for
+figuring out what code should actually get run when you call a function like
+``torch::add``.  This can be nontrivial, because PyTorch operations need
+to handle a lot of cross-cutting concerns that are "layered" on top of one
+of another.  Here is a sampling of some of the things it handles:
+
+* Switching between the CPU and CUDA implementations of an operator, depending
+  on the devices of the input tensors.
+* Switching between the autograd and backend implementations of an operator,
+  depending on whether or not autograd handling is necessary.
+* Applying autocasting when necessary for automatic mixed precision.
+* Applying batching rules when an operator is run under a ``vmap`` call.
+* Tracing execution of operations, if you are tracing a model for export.
+
+If in your `custom operator code <torch_script_custom_ops>`_ you find yourself
+manually writing if statements to handle these cases, the dispatcher APIs can
+help organize your code.  (Conversely, if your custom operator is very simple
+and is only for CPU inference, you probably don't need to use the dispatcher,
+just use the basic API.)
+
+In this tutorial, we will describe how to structure a custom operator
+registration to use the dispatcher to organize various components.  We'll
+assume that you are familiar with how to
+`register an operator <torch_script_custom_ops>`_ and how to write
+a `custom autograd function <cpp_autograd>`_.
+
+Defining schema and backend implementations
+-------------------------------------------
+
+The general principle behind the dispatcher is that it divides the
+implementation of an operator into multiple kernels, each of which implements
+functionality for a specific *dispatch key*, e.g. CPU, CUDA.  The dispatcher
+determines what the highest priority dispatch key is at the time
+you call an operator (this is done by looking at both the tensor arguments as
+well as some thread local state), and transfers control to the kernel for that
+dispatch key.  The end effect is that when you call an operator, we first
+execute the Autograd kernel, and then we redispatch to the backend kernel
+depending on the device types of the passed in tensors.
+
+Let's take a look at the various parts involved in making this
+happen.  First, we must define the schema for the operator in question.
+Unlike simple pybind11-style operator registration, we don't actually
+provide an implementation of our operator at this point; we just
+provide a schema string specifying the type signature of the operator
+that all of our other kernels will abide by:
+
+.. literalinclude:: ../advanced_source/dispatcher/op.cpp
+  :language: cpp
+  :start-after: BEGIN TORCH_LIBRARY
+  :end-before: END TORCH_LIBRARY
+
+Next, we need to actually provide some implementations of this operator.
+For concreteness, here is a really simple implementation of addition on CPU:
+
+.. literalinclude:: ../advanced_source/dispatcher/op.cpp
+  :language: cpp
+  :start-after: BEGIN myadd_cpu
+  :end-before: END myadd_cpu
+
+We'd like to register this function as an implementation of ``myops::myadd``.
+However, the simple way of registering it (``def("myadd", myadd_cpu)``) would
+register the kernel to run in all cases, even if the tensor is not a CPU
+tensor!  (Internally, we refer to these as "catch-all" kernels, since they
+catch all cases.)  To ensure that ``myadd_cpu`` is only run for
+CPU tensors, we can use the ``TORCH_LIBRARY_IMPL`` macro:
+
+.. literalinclude:: ../advanced_source/dispatcher/op.cpp
+  :language: cpp
+  :start-after: BEGIN TORCH_LIBRARY_IMPL CPU
+  :end-before: END TORCH_LIBRARY_IMPL CPU
+
+The ``TORCH_LIBRARY_IMPL`` lets us register implementations for operators on
+a specific dispatch key (in this case, CPU).  Each call to ``impl``
+associates a CPU kernel with the corresponding operator (which we previously
+defined in the ``TORCH_LIBRARY`` block).  If we also have a CUDA implementation ``myadd_cuda``,
+we can register it in a separate ``TORCH_LIBRARY_IMPL`` block:
+
+.. literalinclude:: ../advanced_source/dispatcher/op.cpp
+  :language: cpp
+  :start-after: BEGIN TORCH_LIBRARY_IMPL CUDA
+  :end-before: END TORCH_LIBRARY_IMPL CUDA
+
+These registrations can be split across files or even across library boundaries; so
+for example, you could have these two ``TORCH_LIBRARY_IMPL`` blocks compiled
+into a separate ``myops_cpu`` and ``myops_cuda`` dynamic libraries.  Generally,
+speaking, the structure of your registrations will look like this:
+
+1. A single ``TORCH_LIBRARY`` that lists every custom operator in your namespace
+   in a centralized place.
+2. A ``TORCH_LIBRARY_IMPL`` per dispatch key that registers implementations for
+   that key (e.g., CPU or CUDA).  If you like, you can further subdivide
+   ``TORCH_LIBRARY_IMPL`` blocks into a block per operator. This is convenient
+   if you have a separate file per operator implementation, but don't want to
+   expose the operators in a header; you can just put the registration in the
+   cpp file that defines your operator.
+
+.. note::
+
+    Did you know that you can also write ``TORCH_LIBRARY_IMPL`` blocks for existing
+    core operators in PyTorch?  This is how XLA support for PyTorch is
+    implemented: the ``torch_xla`` library contains a ``TORCH_LIBRARY_IMPL``
+    that provides implementations for all basic operators on the XLA dispatch
+    key.
+
+
+For operators that do not need autograd
+---------------------------------------
+
+Note: This section only applies to versions of PyTorch ``>= 1.10``.
+
+In the next section, we will discuss how to add autograd support to an operator.
+But for the ops that do not need autograd support, the following kernel should be
+registered improve useability and make your op behave like PyTorch's built-in
+operators.
+
+.. code-block:: cpp
+
+  TORCH_LIBRARY_IMPL(myops, Autograd, m) {
+    m.impl(op, autogradNotImplementedFallback());
+  }
+
+The above lines registers an ``Autograd`` kernel that appends a dummy
+``NotImplemented`` node on forward (preserving the ``require_grad``-ness of the inputs).
+On backward, the ``NotImplemented`` node raises an error. This can be helpful
+for debugging in larger models where previously it can be hard to pin-point
+exactly where the ``requires_grad``-ness is lost during the forward pass.
+
+In-place or view ops
+^^^^^^^^^^^^^^^^^^^^
+
+To ensure correctness and best possible performance, if your op mutates an input
+in-place or returns a tensor that aliases with one of the inputs, two additional
+steps should be taken:
+
+1. Register an ``ADInplaceOrView`` kernel in addition to the ``Autograd`` kernel
+   above. This kernel handles the necessary bookkeeping to ensure the correctness
+   of in-place or view operations. It is important to note that this ADInplaceOrView
+   kernel should only be used with ``autogradNotImplementedFallback``.
+
+.. code-block:: cpp
+
+  TORCH_LIBRARY_IMPL(myops, Autograd, m) {
+    m.impl(op, autogradNotImplementedFallback());
+  }
+  TORCH_LIBRARY_IMPL(myops, ADInplaceOrView, m) {
+    m.impl(op, autogradNotImplementedInplaceOrViewFallback());
+  }
+
+2. The ``Autograd`` or ``ADInplaceOrView`` boxed kernels registered above
+   rely on operator schema information in their logi. If your op mutates an input
+   in-place or returns a tensor that aliases with one of the inputs it is important to
+   ensure that your schema properly reflects this. See
+   `here <https://github.com/pytorch/pytorch/blob/master/aten/src/ATen/native/README.md>`_
+   for more information on how to annotate the schema.
+
+.. _autograd-support:
+
+Adding autograd support
+-----------------------
+
+At this point, we have an operator with both CPU and CUDA implementations.  How
+can we add autograd support to it?  As you might guess, we will register an
+autograd kernel (similar to what's described in the `custom autograd function <cpp_autograd>`_ tutorial)!
+However, there is a twist: unlike the CPU and CUDA kernels, the autograd kernel
+needs to *redispatch*: it needs to call back into the dispatcher to get to
+the inference kernels, e.g. CPU or CUDA implementations.
+
+Thus, before we write the autograd kernel, let's write a *dispatching function*
+which calls into the dispatcher to find the right kernel for your operator.
+This function constitutes the public C++ API for your operators--in fact, all of
+the tensor functions in PyTorch's C++ API all call the dispatcher in the same
+way under the hood.  Here's what the dispatching function looks like:
+
+.. literalinclude:: ../advanced_source/dispatcher/op.cpp
+  :language: cpp
+  :start-after: BEGIN myadd
+  :end-before: END myadd
+
+Let's break it down:
+
+* In the first line, we look up a typed operator handle from the dispatcher
+  corresponding to the operator that we are going to dispatch to.
+  ``findSchemaOrThrow`` takes two arguments: the (namespace qualified) name
+  of the operator, and the overload name of the operator (typically just
+  the empty string).  ``typed`` casts the dynamically typed handle into
+  a statically typed handle (doing a runtime test to make sure you've given
+  the correct C++ type), so that we can do a normal C++ call on it.  We
+  pass it ``decltype(myadd)`` since the type of the dispatching function is
+  the same as the type of the underlying kernels registered to the dispatcher.
+
+  For performance, this computation is done in a static variable, so that
+  we only need to do the (slow) lookup once.  If you typoed the name of the
+  operator you want to call, this lookup will error the first time you call this
+  function.
+
+* In the second line, we simply ``call`` the operator handle with all of the
+  arguments passed into the dispatching function.  This will actually invoke
+  the dispatcher and in the end control will be transferred to whatever kernel
+  is appropriate for this call.
+
+With the dispatch function in hand, we can now write the autograd kernel:
+
+.. literalinclude:: ../advanced_source/dispatcher/op.cpp
+  :language: cpp
+  :start-after: BEGIN myadd_autograd
+  :end-before: END myadd_autograd
+
+The autograd function is written as normal using ``torch::autograd::Function``,
+except that instead of directly writing the implementation in ``forward()``,
+we:
+
+1. Turn off autograd handling with the ``at::AutoNonVariableTypeMode`` RAII
+   guard, and then
+2. Call the dispatch function ``myadd`` to call back into the dispatcher.
+
+Without (1), your calls will infinite loop (and stack overflow), because
+``myadd`` will send you back to this function (as the highest priority dispatch
+key would still be autograd.) With (1),
+autograd is excluded from the set of dispatch keys under consideration, and
+we will go to the next handlers, which will either be CPU and CUDA.
+
+We can now register this function in the same way we registered the CPU/CUDA
+functions:
+
+.. literalinclude:: ../advanced_source/dispatcher/op.cpp
+  :language: cpp
+  :start-after: BEGIN TORCH_LIBRARY_IMPL Autograd
+  :end-before: END TORCH_LIBRARY_IMPL Autograd
+
+
+.. note::
+
+    In this example we register the kernel to ``Autograd``, which installs it as the
+    autograd kernel for all backends. You can also register optimized kernels for specific
+    backends by using the corresponding backend-specific dispatch key - for example,
+    ``AutogradCPU`` or ``AutogradCUDA``. To explore these and other dispatch key
+    options in more detail, check out the ``PythonDispatcher`` tool provided in
+    `torch/_python_dispatcher.py <https://github.com/pytorch/pytorch/blob/master/torch/_python_dispatcher.py>`_.
+
+
+Going beyond autograd
+---------------------
+
+In some sense, the dispatcher isn't doing all that much: all it does is
+implement a glorified if-statement, along the lines of this:
+
+.. code-block:: cpp
+
+    class MyAddFunction : ... {
+    public:
+      static Tensor forward(
+        AutogradContext *ctx, torch::Tensor self, torch::Tensor other) {
+
+        if (self.device().type() == DeviceType::CPU) {
+          return add_cpu(self, other);
+        } else if (self.device().type() == DeviceType::CUDA) {
+          return add_cuda(self, other);
+        } else {
+          TORCH_CHECK(0, "Unsupported device ", self.device().type());
+        }
+      }
+      ...
+    }
+
+So why use the dispatcher?  There are a few reasons:
+
+1. It is decentralized.  You can assemble all of the pieces of an operator
+   (CPU, CUDA, Autograd) without having to write a single, centralized
+   if statement that refers to all of them.  Importantly, third parties can
+   register extra implementations for other aspects without having to patch the
+   original definition of an operator.  We'll talk more about extending the
+   dispatcher in `extending dispatcher for a new backend <extend_dispatcher>`_.
+
+2. It supports more dispatch keys than CPU, CUDA and Autograd.  You can
+   see a full list of dispatch keys that are currently implemented
+   in PyTorch in ``c10/core/DispatchKey.h``.  These dispatch keys
+   implement a variety of optional functionality for operators, and if you
+   decide you want your custom operator to support this functionality,
+   all you have to register a kernel for the appropriate key.
+
+3. The dispatcher implements support for boxed fallback functions, which
+   are functions that can be implemented once and apply to all operators
+   in the system.  Boxed fallbacks can be used to provide default behavior
+   for a dispatch key; if you use the dispatcher to implement your operator,
+   you also opt into the fallbacks for all of these operations.
+
+Here are some particular dispatch keys which you may need to define an operator
+for.
+
+Autocast
+^^^^^^^^
+
+The Autocast dispatch key implements support for
+`automatic mixed precision (AMP) <https://pytorch.org/docs/stable/amp.html>`_.
+An autocast wrapper kernel typically casts incoming ``float16`` or ``float32`` CUDA tensors
+to some preferred precision before running the op.
+For example, matmuls and convolutions on floating-point CUDA tensors usually run faster
+and use less memory in ``float16`` without impairing convergence.
+Autocast wrappers only have an effect in
+`autocast-enabled contexts <https://pytorch.org/docs/stable/amp.html#torch.cuda.amp.autocast>`_.
+
+Here's an autocast wrapper for a hypothetical custom matmul, along with its registration:
+
+.. code-block:: cpp
+
+    // Autocast-specific helper functions
+    #include <ATen/autocast_mode.h>
+
+    Tensor mymatmul_autocast(const Tensor& self, const Tensor& other) {
+      c10::impl::ExcludeDispatchKeyGuard no_autocast(c10::DispatchKey::Autocast);
+      return mymatmul(at::autocast::cached_cast(at::kHalf, self),
+                      at::autocast::cached_cast(at::kHalf, other));
+    }
+
+    TORCH_LIBRARY_IMPL(myops, Autocast, m) {
+      m.impl("mymatmul", mymatmul_autocast);
+    }
+
+``cached_cast(kHalf, tensor)`` casts ``tensor`` to ``float16`` if ``tensor`` is CUDA and ``float32``,
+otherwise, it leaves ``tensor`` unchanged (c.f. the
+`eligibility policy <https://pytorch.org/docs/stable/amp.html#op-eligibility>`_ for natively autocasted ops).
+This ensures if the network calls ``mymatmul`` on any mixture of ``float16`` and ``float32`` CUDA tensors,
+``mymatmul`` runs in ``float16``.  Meanwhile, calls to ``mymatmul`` with non-CUDA, integer-type, or ``float64``
+inputs are unaffected.  Using ``cached_cast`` to follow the native eligibility policy in your own autocast wrapper
+is recommended, but not required.  For example, if you wanted to force ``float16`` execution for all input types,
+you could ``return mymatmul(self.half(), other.half());`` instead of using ``cached_cast``.
+
+Notice that, like our autograd kernels, we exclude the ``Autocast`` key from
+dispatch before redispatching.
+
+By default, if no autocast wrapper is provided,
+we fallthrough directly to the regular operator implementation (no
+autocasting occurs).  (We didn't use ``myadd`` for this example, since pointwise
+addition doesn't need autocasting and should just fall through.)
+
+When should an autocast wrapper be registered? Unfortunately, there aren't
+cut-and-dried rules for an op's preferred precision.  You can
+get a sense for some native ops' preferred precisions by looking at the
+`cast lists <https://pytorch.org/docs/master/amp.html#op-specific-behavior>`_.
+General guidance:
+
+* Ops that do reductions should probably execute in ``float32``,
+* Any op that does a convolution or gemm under the hood should
+  probably execute in ``float16``, and
+* Other ops with multiple floating-point tensor inputs should standardize
+  them to a common precision (unless the implementation supports inputs with different precisions).
+
+If your custom op falls into the third category, the ``promote_type`` template
+helps figure out the widest floating-point type present among input tensors, which is
+the safest choice for the execution type:
+
+.. code-block:: cpp
+
+    #include <ATen/autocast_mode.h>
+
+    Tensor my_multiple_input_op_autocast(const Tensor& t0, const Tensor& t1) {
+      c10::impl::ExcludeDispatchKeyGuard no_autocast(c10::DispatchKey::Autocast);
+      // The required at::kHalf argument is an optimistic initial guess.
+      auto exec_type = at::autocast::promote_type(at::kHalf, t0, t1);
+      return my_multiple_input_op(at::autocast::cached_cast(exec_type, t0),
+                                  at::autocast::cached_cast(exec_type, t1));
+    }
+
+If your custom op is :ref:`autograd-enabled<autograd-support>`, you only need to write and register
+an autocast wrapper for the same name onto which the autograd wrapper is registered.
+For example, if you wanted an autocast wrapper for the ``myadd`` function shown
+in the autograd section, all you'd need is
+
+.. code-block:: cpp
+
+    Tensor myadd_autocast(const Tensor& self, const Tensor& other) {
+      c10::impl::ExcludeDispatchKeyGuard no_autocast(c10::DispatchKey::Autocast);
+      return myadd(at::autocast::cached_cast(<desired dtype>, self),
+                   at::autocast::cached_cast(<desired dtype>, other));
+    }
+
+    TORCH_LIBRARY_IMPL(myops, Autocast, m) {
+      m.impl("myadd", myadd_autocast);
+    }
+
+There are no separate gymnastics to make the backward method autocast compatible.
+However, the backward method defined in your custom autograd function will run in the same
+dtype as autocast sets for the forward method, so you should choose a ``<desired dtype>``
+suitable for both your forward and backward methods.
+
+Batched
+^^^^^^^
+
+Batched tensors allow you to write your code in a per-example manner, and then
+have them be automatically batched when run under a ``vmap`` invocation.  The
+API for writing batching rules is currently under development, but once it is
+stabilized, you can add support for ``vmap`` for your operators by registering
+a kernel at the Batched dispatch key.
+
+Tracer
+^^^^^^
+
+The Tracer dispatch key implements support for recording invocations of operators
+into a trace when you run ``torch.jit.trace``.  We intend to provide a
+boxed fallback that will implement tracing for arbitrary operations,
+see `issue #41478 <https://github.com/pytorch/pytorch/issues/41478>`_ to track
+progress.
diff --git a/advanced_source/dispatcher/CMakeLists.txt b/advanced_source/dispatcher/CMakeLists.txt
new file mode 100644
index 00000000000..0ef448a9644
--- /dev/null
+++ b/advanced_source/dispatcher/CMakeLists.txt
@@ -0,0 +1,8 @@
+cmake_minimum_required(VERSION 3.1 FATAL_ERROR)
+project(dispatcher)
+
+find_package(Torch REQUIRED)
+
+add_library(dispatcher SHARED op.cpp)
+target_compile_features(dispatcher PRIVATE cxx_std_14)
+target_link_libraries(dispatcher "${TORCH_LIBRARIES}")
diff --git a/advanced_source/dispatcher/op.cpp b/advanced_source/dispatcher/op.cpp
new file mode 100644
index 00000000000..c3a90aed448
--- /dev/null
+++ b/advanced_source/dispatcher/op.cpp
@@ -0,0 +1,105 @@
+#include <torch/torch.h>
+#include <torch/script.h>
+
+#include <ATen/NamedTensorUtils.h>
+
+using torch::Tensor;
+using torch::DeviceType;
+using torch::autograd::tensor_list;
+using torch::autograd::AutogradContext;
+
+// BEGIN myadd
+Tensor myadd(const Tensor& self, const Tensor& other) {
+  static auto op = torch::Dispatcher::singleton()
+    .findSchemaOrThrow("myops::myadd", "")
+    .typed<decltype(myadd)>();
+  return op.call(self, other);
+}
+// END myadd
+
+// BEGIN TORCH_LIBRARY
+TORCH_LIBRARY(myops, m) {
+  m.def("myadd(Tensor self, Tensor other) -> Tensor");
+}
+// END TORCH_LIBRARY
+
+// BEGIN myadd_cpu
+Tensor myadd_cpu(const Tensor& self_, const Tensor& other_) {
+  TORCH_CHECK(self_.sizes() == other_.sizes());
+  TORCH_INTERNAL_ASSERT(self_.device().type() == DeviceType::CPU);
+  TORCH_INTERNAL_ASSERT(other_.device().type() == DeviceType::CPU);
+  Tensor self = self_.contiguous();
+  Tensor other = other_.contiguous();
+  Tensor result = torch::empty(self.sizes(), self.options());
+  const float* self_ptr = self.data_ptr<float>();
+  const float* other_ptr = other.data_ptr<float>();
+  float* result_ptr = result.data_ptr<float>();
+  for (int64_t i = 0; i < result.numel(); i++) {
+    result_ptr[i] = self_ptr[i] + other_ptr[i];
+  }
+  return result;
+}
+// END myadd_cpu
+
+// BEGIN TORCH_LIBRARY_IMPL CPU
+TORCH_LIBRARY_IMPL(myops, CPU, m) {
+  m.impl("myadd", myadd_cpu);
+}
+// END TORCH_LIBRARY_IMPL CPU
+
+Tensor myadd_cuda(const Tensor& self, const Tensor& other) {
+  // Insert your CUDA implementation here
+  TORCH_CHECK(0, "CUDA not yet implemented");
+}
+
+// BEGIN TORCH_LIBRARY_IMPL CUDA
+TORCH_LIBRARY_IMPL(myops, CUDA, m) {
+  m.impl("myadd", myadd_cuda);
+}
+// END TORCH_LIBRARY_IMPL CUDA
+
+// BEGIN myadd_autograd
+class MyAddFunction : public torch::autograd::Function<MyAddFunction> {
+ public:
+  static Tensor forward(
+      AutogradContext *ctx, torch::Tensor self, torch::Tensor other) {
+    at::AutoNonVariableTypeMode g;
+    return myadd(self, other);
+  }
+
+  static tensor_list backward(AutogradContext *ctx, tensor_list grad_outputs) {
+    auto grad_output = grad_outputs[0];
+    return {grad_output, grad_output};
+  }
+};
+
+Tensor myadd_autograd(const Tensor& self, const Tensor& other) {
+  return MyAddFunction::apply(self, other)[0];
+}
+// END myadd_autograd
+
+// BEGIN TORCH_LIBRARY_IMPL Autograd
+TORCH_LIBRARY_IMPL(myops, Autograd, m) {
+  m.impl("myadd", myadd_autograd);
+}
+// END TORCH_LIBRARY_IMPL Autograd
+
+#if 0
+// BEGIN TORCH_LIBRARY_IMPL Named
+Tensor myadd_named(const Tensor& self, const Tensor& other) {
+  // TODO: shouldn't need to do size check here
+  TORCH_CHECK(self.sizes() == other.sizes());
+  auto maybe_outnames = at::unify_from_right(self.names(), other.names());
+  auto result = ([&]() {
+    at::NoNamesGuard guard;
+    return myadd(self, other);
+  })();
+  at::namedinference::propagate_names_if_nonempty(result, maybe_outnames);
+  return result;
+}
+
+TORCH_LIBRARY_IMPL(myops, Named, m) {
+  m.impl("myadd", myadd_named);
+}
+// END TORCH_LIBRARY_IMPL Named
+#endif
diff --git a/advanced_source/dispatcher/test.py b/advanced_source/dispatcher/test.py
new file mode 100644
index 00000000000..cd35b05a47a
--- /dev/null
+++ b/advanced_source/dispatcher/test.py
@@ -0,0 +1,11 @@
+import torch
+
+torch.ops.load_library("build/libdispatcher.so")
+print(torch.ops.myops.myadd(torch.randn(32, 32), torch.rand(32, 32)))
+"""
+# Doesn't currently work, because Python frontend on torch.ops doesn't
+# support names (for not a good reason?)
+x = torch.randn(32, 32, names=('A', 'B'))
+y = torch.rand(32, 32, names=('A', 'B'))
+print(torch.ops.myops.myadd(x, y))
+"""
diff --git a/advanced_source/extend_dispatcher.rst b/advanced_source/extend_dispatcher.rst
new file mode 100644
index 00000000000..12f15355f5f
--- /dev/null
+++ b/advanced_source/extend_dispatcher.rst
@@ -0,0 +1,380 @@
+Extending dispatcher for a new backend in C++
+=============================================
+
+In this tutorial we will walk through all necessary steps to extend the dispatcher to
+add a new device living outside ``pytorch/pytorch`` repo and maintain it to keep in
+sync with native PyTorch devices.  Here we'll assume that you're familiar with how
+to `register a dispatched operator in C++ <dispatcher>`_ and how to write a
+`custom autograd function <cpp_autograd>`_.
+
+
+.. note::
+
+   This tutorial touches a lot of internal components inside PyTorch which are being actively improved,
+   please expect changes to APIs if you decide to follow this tutorial.  We'll keep this tutorial
+   up to date with the latest APIs.
+
+What's a new backend?
+---------------------
+
+Adding a new backend to PyTorch requires a lot of development and maintenance from backend extenders.
+Before adding a new backend, let's first consider a few common use cases and recommended solutions for them:
+
+* If you have new algorithms for an existing PyTorch operator, send a PR to PyTorch.
+* If you want to propose a new operator, send a feature request/PR to PyTorch.
+* If you want to add support for a new device/hardware like Google TPU and customized chips, which often requires using
+  hardware-specific API to write kernels, follow this tutorial and add a out-of-tree backend to PyTorch.
+* If you want to add support for existing operators but with a different Tensor layout/representation
+  like sparse and quantized, which enforces your kernels to be written in a way that's more efficient
+  given the layout/representation limitation, follow this tutorial and add a out-of-tree backend to PyTorch.
+
+In this tutorial we'll mainly focus on adding a new out-of-tree device below.  Adding out-of-tree support
+for a different tensor layout might share many common steps with devices, but we haven't seen an example of
+such integrations yet so it might require additional work from PyTorch to support it.
+
+Get a dispatch key for your backend
+-----------------------------------
+
+PyTorch operators are implemented in C++ and made available in Python frontend through Python bindings.
+The PyTorch dispatcher divides the implementation of an operator into multiple kernels, each of which is
+associated with a specific dispatch key.  Supporting a new backend in PyTorch essentially means writing
+a kernel for each PyTorch operator in C++ and then registering them to a dispatch key representing your
+customized backend in the dispatcher.
+
+Dispatch key is your identifier in the dispatcher system. The dispatcher looks at the dispatch keys carried on
+input tensors and calls the right kernel accordingly.  PyTorch provides three reserved dispatch keys
+(and their corresponding Autograd keys) for prototyping out-of-tree backend extensions:
+
+* PrivateUse1/AutogradPrivateUse1
+* PrivateUse2/AutogradPrivateUse2
+* PrivateUse3/AutogradPrivateUse3
+
+You can choose any of keys above to prototype your customized backend.
+To create a Tensor on ``PrivateUse1`` backend, you need to set dispatch key in ``TensorImpl`` constructor.
+
+.. code-block:: cpp
+
+  /* Example TensorImpl constructor */
+  TensorImpl(
+      Storage&& storage,
+      DispatchKeySet ks,
+      const caffe2::TypeMeta data_type);
+
+  // To create a TensorImpl on PrivateUse1 backend, pass in the following ks to TensorImpl creation.
+  DispatchKeySet ks = c10::DispatchKeySet{c10::DispatchKey::PrivateUse1, c10::DispatchKey::AutogradPrivateUse1};
+
+
+Note that ``TensorImpl`` class above assumes your Tensor is backed by a storage like CPU/CUDA. We also
+provide ``OpaqueTensorImpl`` for backends without a storage. And you might need to tweak/override certain
+methods to fit your customized hardware.
+One example in pytorch repo is `Vulkan TensorImpl <https://github.com/pytorch/pytorch/blob/main/aten/src/ATen/native/vulkan/VulkanOpaqueTensorImpl.h>`_.
+
+
+.. note::
+   Once the prototype is done and you plan to do regular releases for your backend extension,  please feel free to
+   submit a PR to ``pytorch/pytorch`` to reserve a dedicated dispatch key for your backend.
+
+
+Get the full list of PyTorch operators
+--------------------------------------
+
+PyTorch provides a full list of extensible C++ operators in generated file
+``build/aten/src/ATen/RegistrationDeclarations.h``.
+This file is only available after building PyTorch from source.
+Here's a snippet of the file:
+
+.. code-block:: cpp
+
+  Tensor abs(const Tensor & self); // {"schema": "aten::abs(Tensor self) -> Tensor", "dispatch": "True", "default": "True"}
+  Tensor & abs_(Tensor & self); // {"schema": "aten::abs_(Tensor(a!) self) -> Tensor(a!)", "dispatch": "True", "default": "True"}
+  Tensor & abs_out(Tensor & out, const Tensor & self); // {"schema": "aten::abs.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)", "dispatch": "True", "default": "False"}
+  Tensor absolute(const Tensor & self); // {"schema": "aten::absolute(Tensor self) -> Tensor", "dispatch": "False", "default": "False"}
+  Tensor & absolute_(Tensor & self); // {"schema": "aten::absolute_(Tensor(a!) self) -> Tensor(a!)", "dispatch": "False", "default": "False"}
+  Tensor & absolute_out(Tensor & out, const Tensor & self); // {"schema": "aten::absolute.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)", "dispatch": "False", "default": "False"}
+  Tensor angle(const Tensor & self); // {"schema": "aten::angle(Tensor self) -> Tensor", "dispatch": "True", "default": "True"}
+  Tensor & angle_out(Tensor & out, const Tensor & self); // {"schema": "aten::angle.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)", "dispatch": "True", "default": "False"}
+  Tensor sgn(const Tensor & self); // {"schema": "aten::sgn(Tensor self) -> Tensor", "dispatch": "True", "default": "True"}
+
+There're multiple fields associated with a single operator. Let's break it down using ``abs_out`` as an example:
+
+* ``Tensor & abs_out(Tensor & out, const Tensor & self);`` is the C++ signature of the operator, your C++
+  kernel should match this signature exactly.
+* ``aten::abs.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)`` is the unique schema representing the operator,
+  which also contains aliasing and mutation annotations compared to the C++ signature.  This is the unique identifier
+  the dispatcher uses to find an operator.
+* ``dispatch`` and ``default`` are boolean fields that provide information about what native PyTorch kernels
+  can do, thus implies whether it's required for backend extenders to implement the kernel.
+  More details can be found in :ref:`register kernels for the new backend<register-kernel>`.
+
+
+.. _register-kernel:
+
+Register kernels for the new backend
+------------------------------------
+
+To register your kernels to PyTorch dispatcher, you can use the
+``TORCH_LIBRARY_IMPL`` API described in
+`Registering a Dispatched Operator in C++ <dispatcher>`_:
+
+.. code-block:: cpp
+
+  TORCH_LIBRARY_IMPL(aten, PrivateUse1, m) {
+    m.impl(<schema_my_op1>, &my_op1);
+    m.impl(<schema_my_op2>, &my_op2);
+    m.impl(<schema_my_op2_backward>, &my_op2_backward);
+  }
+
+Now let's zoom in and what operator requires a kernel from a customized backend and what's
+inside the kernels exactly.
+
+PyTorch currently has more than 1600 operators and it’s still growing.  It’s unrealistic
+for backend extensions to keep up with this speed.  Even for native backends like CPU
+or CUDA, it often requires a lot of work to write dedicated kernels for every new op.
+
+Fortunately, some native PyTorch kernels are written in a way that they decompose to
+combination of several known operators. In other words, you only need to implement
+a set of known operators (ops that require registration below) instead of all PyTorch operators.
+
+PyTorch operators can be classified into two categories:
+
+* Ops that require registration: PyTorch native implementation for these ops is backend specific
+  and thus it’s required to provide a kernel for customized backend.  Otherwise calling such op
+  on the customized backend will error out.
+    * In ``RegistrationDeclarations.h`` these operators have ``dispatch`` set to True *and* ``default`` set to False
+      in the metadata found in their accompanying comments.
+
+
+* Registration is optional: backend extenders can skip registering to these ops without sacrificing any support.
+  However, if a backend extender wants to override the default kernel provided by PyTorch, they can still
+  register their customized kernel to their backend and the dispatcher will use it for your backend only.
+  For example, current implementation of PyTorch's ``max_pool2d`` returns ``indices`` as part of forward outputs which
+  creates overhead in torch_xla, so torch_xla registers its own kernel for ``max_pool2d`` instead.
+    * In ``RegistrationDeclarations.h`` these operators have ``dispatch`` set to False *or* ``default`` set to True
+      in the metadata found in their accompanying comments.
+
+
+
+Autograd support for the new backend
+------------------------------------
+
+Gradient formulas are mostly purely mathematical and thus are general for all backends.
+PyTorch often registers a kernel to alias dispatch key Autograd, which means it can be used by all backends.
+
+For these operators you don't have to worry about their derivative formulas,
+you can just write forward definitions for operators in ``RegistrationDeclarations.h`` and PyTorch handles
+backward for you automatically.
+
+.. code-block:: cpp
+
+
+  Tensor my_op1(const Tensor& self, const Tensor& other) {
+    // call your backend-specific APIs to implement my_op so that
+    // it matches PyTorch's native behavior
+  }
+  TORCH_LIBRARY_IMPL(aten, PrivateUse1, m) {
+    m.impl(<schema_my_op1>, &my_op);
+  }
+
+
+In some cases, PyTorch backward kernel implementations are also device specific so that they can squeeze out
+max performance out of each backend. For those operators you’ll see op_backward showing up in
+``RegistrationDeclarations.h`` as *required registration* as well.
+
+.. code-block:: cpp
+
+
+  Tensor my_op2_backward(const Tensor& self, const Tensor& other) {
+    // call your backend-specific APIs to implement my_op2_backward so that
+    // it matches PyTorch's native behavior
+  }
+
+  // Note backward kernel is still registered to PrivateUse1 instead of AutogradPrivateUse1.
+  // PyTorch will wrap your backward kernel with proper autograd setup and then link to it in
+  // my_op2's AutogradPrivateUse1 kernel.
+  TORCH_LIBRARY_IMPL(aten, PrivateUse1, m) {
+    m.impl(<schema_my_op2>, &my_op2);
+    m.impl(<schema_my_op2_backward>, &my_op2_backward);
+  }
+
+
+In a few *rare* cases, PyTorch’s gradient formula for certain operators may have assumptions that don’t generalize
+for all backends. In those cases backend extenders can optionally override PyTorch Autograd layer by registering
+a kernel from torch::autograd::Function to the corresponding dispatch key (for example, AutogradPrivateUse1 if
+you're using PrivateUse1 for your backend):
+
+
+.. code-block:: cpp
+
+
+  class MyAddFunction : public torch::autograd::Function<MyAddFunction> {
+    public:
+    static Tensor forward(AutogradContext *ctx, torch::Tensor self, torch::Tensor other) {
+      at::AutoNonVariableTypeMode g;
+      return myadd(self, other);
+    }
+
+    static tensor_list backward(AutogradContext *ctx, tensor_list grad_outputs) {
+      auto grad_output = grad_outputs[0];
+      return {grad_output, grad_output};
+    }
+  };
+
+  Tensor myadd_autograd(const Tensor& self, const Tensor& other) {
+    return MyAddFunction::apply(self, other)[0];
+  }
+
+  // Register the autograd kernel to AutogradPrivateUse1
+  TORCH_LIBRARY_IMPL(aten, AutogradPrivateUse1, m) {
+    m.impl(<myadd_schema>, &myadd_autograd);
+  }
+
+  // Register the inference kernel to PrivateUse1
+  TORCH_LIBRARY_IMPL(aten, PrivateUse1, m) {
+    m.impl(<myadd_schema>, &myadd);
+  }
+
+
+
+With this trick you have full control over both training and inference behavior for ``my_add`` operator in your backend.
+Here's `an example <https://github.com/pytorch/xla/blob/r1.7/torch_xla/csrc/aten_autograd_ops.h>`_ in the ``pytorch/xla`` repository.
+
+
+Build an extension
+------------------
+
+Out-of-tree backend is supported by adding a C++ extension to PyTorch.
+Once you have kernels and registrations ready, you can build a C++ extension by
+writing a ``setup.py`` script that uses ``setuptools`` to compile C++ code.  Here's a simplified example from
+`pytorch/xla repo <https://github.com/pytorch/xla/blob/master/setup.py>`_::
+
+  from setuptools import setup
+  from torch.utils.cpp_extension import BuildExtension, CppExtension
+
+  setup(
+      name='torch_xla',
+      ext_modules=[
+          CppExtension(
+              '_XLAC',
+              torch_xla_sources,
+              include_dirs=include_dirs,
+              extra_compile_args=extra_compile_args,
+              library_dirs=library_dirs,
+              extra_link_args=extra_link_args + \
+                  [make_relative_rpath('torch_xla/lib')],
+          ),
+      ],
+      cmdclass={
+          'build_ext': Build,  # Build is a derived class of BuildExtension
+      }
+      # more configs...
+  )
+
+
+See `our C++ extension tutorial <https://pytorch.org/tutorials/advanced/cpp_extension.html#building-with-setuptools>`_
+for more details.
+
+
+Custom operator support
+-----------------------
+
+Your new backend should work seamlessly with
+`customized operators extended in python <https://pytorch.org/docs/stable/notes/extending.html>`_
+without writing any new kernels as long as the customized operator is composed of existing
+PyTorch operators (which are already supported by your backend).
+
+For `custom operators extended in C++ <cpp_autograd>`_ they often come with a
+`backend specific C++ kernel implementation e.g. nms kernel in torchvsion <https://github.com/pytorch/vision/blob/master/torchvision/csrc/ops/cuda/nms_kernel.cu>`_
+as well as `a customized Python API e.g. torch.ops.torchvision.nms <https://github.com/pytorch/vision/blob/master/torchvision/csrc/ops/nms.cpp#L18>`_.
+To support these operators, backend extenders will need to write a C++ kernel for your backend and properly
+register it to the corresponding namespace in the dispatcher similar to supporting PyTorch native operators.
+Alternatively you could also add a customized API in your extension e.g ``torch_xla.core.functions.nms`` for
+these adhoc requests.
+
+JIT support
+-----------
+
+As we mentioned in `Registering a Dispatched Operator in C++ <dispatcher>`_, kernels registered through `m.impl()` API
+support being called in both unboxed and boxed ways. In other words your customized backend can also work with our
+JIT tracing/scripting frontend just like the in-tree backends like CPU or CUDA do.  You could potentially also write specialized optimization
+passes for your backend on a JIT graph.  But we will not discuss it here since we haven't finalized the integration point
+in JIT, so the current backend support will focus on the eager frontend for now.
+
+
+Testing your backend against native PyTorch backends
+----------------------------------------------------
+
+PyTorch lets tests run on multiple device types using its `generic device type testing framework <https://github.com/pytorch/pytorch/blob/master/torch/testing/_internal/common_device_type.py>`_.
+You can find details about `how tests use it <https://github.com/pytorch/pytorch/blob/5a8198eb3c594aa18352930fd21f3c25bd7b7100/torch/testing/_internal/common_device_type.py#L23>`_
+and information about `how to add a new device type <https://github.com/pytorch/pytorch/blob/5a8198eb3c594aa18352930fd21f3c25bd7b7100/torch/testing/_internal/common_device_type.py#L369>`_.
+Once added, PyTorch tests using the generic device type testing framework will be run using your device type, too.
+See `this Wiki page <https://github.com/pytorch/pytorch/wiki/Writing-tests-that-run-on-all-available-device-types>`_ for an example of how tests are instantiated.
+
+Running PyTorch’s existing test suites with your device type is important to ensure correctness,
+but not all PyTorch features are supported by every device type.  The generic device type testing
+framework allows for considerable customization so that device types can select which tests to run,
+which dtypes they support, and even which precisions to use when comparing tensors for equality.
+
+An example device type that uses the generic device type testing framework and doesn’t ship with
+PyTorch is XLA.  See `its extension of the generic device type testing framework <https://github.com/pytorch/xla/blob/master/test/pytorch_test_base.py>`_,
+which contains examples of block listing tests, block listing dtypes, and overriding test precision.
+
+The generic device type testing framework is actively developed. To request a feature please file an
+issue on PyTorch’s Github.
+
+
+Backward Compatibility
+----------------------
+
+Currently PyTorch can’t guarantee backward compatibility for registered operators.
+Operators, as well as their schemas, might be added/modified/deleted as needed.  Registered
+kernels must be *exactly* the same as PyTorch version.  If PyTorch adds more parameters (
+even with defaults) for an operator, your old registration won't work until it's updated
+to match PyTorch's new signature.
+
+As a result, we *highly recommend* out-of-tree backend extenders only sync with major PyTorch
+releases to minimize interruptions in development.  PyTorch is on a quarterly release cadence.
+Backend extenders should join the *#announcement* channel at `pytorch.slack.com <http://pytorch.slack.com/>`_
+to get latest updates on releases.
+
+Known issues & additional notes
+-------------------------------
+
+*  Not all test suites are device generic yet. Extensible test classes can be found by searching
+   ``instantiate_device_type_tests`` in PyTorch codebase, e.g
+   ``TestTorchDeviceType, TestViewOps, TestTensorDeviceOps, TestTypePromotion`` etc.
+* There's no extension point in C++ for serializing a python Tensor object on customized backend. Currently
+  you can only extend it by modifying `PyTorch Tensor __reduce_ex__ method <https://github.com/pytorch/pytorch/blob/5640b79bf8a5412a0209a919c05c811d5427cc12/torch/tensor.py#L83-L150>`_
+  or monkey patching in out-of-tree repository.
+* If your backend doesn't allow direct memory access, you should pay additional attention to supporting
+  view ops since they're supposed to share storage. Changes to view tensor need to propagated to its
+  base tensor and vice versa.
+* There's no extension point in C++ for Optimizer if your backend doesn't work with the native PyTorch
+  Optimizers, e.g. need to carry the states to be updated in backward like torch-xla. Such use cases
+  currently can only be done through adding customized API or monkey patching in out-of-tree repository.
+
+Future Work
+-----------
+
+Making every component in PyTorch extensible for an out-of-tree backend seamless
+requires a lot of changes to PyTorch internals.  Here are a few items that we're
+actively working on might improve the experience in the future:
+
+* Improve test coverage of generic testing framework.
+* Improve ``Math`` kernel coverage and more comprehensive tests to make sure ``Math``
+  kernel behavior matches other backends like ``CPU/CUDA``.
+* Refactor ``RegistrationDeclarations.h`` to carry the minimal information and reuse
+  PyTorch's codegen as much as possible.
+* Support a backend fallback kernel to automatic convert inputs to CPU and convert the
+  result back to the customized backend. This will allow "full" operator coverage even
+  though you don't have kernels written for every operator.
+
+
+Stay in touch
+-------------
+
+Please use `PyTorch dev discussions <https://dev-discuss.pytorch.org/>`_ for questions and discussions. If you have
+any feature requests or bug reports, please `file an issue on github <https://github.com/pytorch/pytorch/issues>`_.
+
+If you're interested in helping in any of the future work items above (e.g adding more ``Math``
+kernels for PyTorch operators in C++), please reach out to us through Github or Slack!
+
diff --git a/advanced_source/generic_join.rst b/advanced_source/generic_join.rst
new file mode 100644
index 00000000000..0fb0d5528d2
--- /dev/null
+++ b/advanced_source/generic_join.rst
@@ -0,0 +1,450 @@
+Distributed Training with Uneven Inputs Using the Join Context Manager
+======================================================================
+
+**Author**\ : `Andrew Gu <https://github.com/andwgu>`_
+
+.. note::
+   |edit| View and edit this tutorial in `github <https://github.com/pytorch/tutorials/blob/main/advanced_source/generic_join.rst>`__.
+
+.. note:: ``Join`` is introduced in PyTorch 1.10 as a prototype feature. This
+    API is subject to change.
+
+In this tutorial, you will see:
+
+- An overview of the `Join`_ context manager.
+- An example of how to use the context manager with ``DistributedDataParallel``.
+- An example of how to use the context manager with both
+  ``DistributedDataParallel`` and ``ZeroRedundancyOptimizer``.
+- An example of passing in keyword arguments to the context manager.
+- A dive into how the `Join`_ context manager works.
+- An example showing how to make a toy class compatible with the context
+  manager.
+
+Requirements
+------------
+
+- PyTorch 1.10+
+- `Getting Started with Distributed Data Parallel`_
+- `Shard Optimizer States with ZeroRedundancyOptimizer`_
+
+What is ``Join``?
+-----------------
+In `Getting Started with Distributed Data Parallel - Basic Use Case`_, you saw
+the general skeleton for using `DistributedDataParallel`_ to perform data
+parallel training. This implicitly schedules all-reduces in each backward pass
+to synchronize gradients across ranks. Such `collective communications
+<https://pytorch.org/docs/stable/distributed.html>`__ require participation
+from all ranks in the process group, so if a rank has fewer inputs, then the
+other ranks will hang or error (depending on the backend). More generally, this
+problem persists for any class that performs per-iteration synchronous
+collective communications.
+
+``Join`` is a context manager to be used around your per-rank training loop to
+facilitate training with uneven inputs. The context manager allows the ranks
+that exhaust their inputs early (i.e. *join* early) to shadow the collective
+communications performed by those that have not yet joined. The ways in which
+the communications are shadowed are specified by hooks.
+
+Using ``Join`` with ``DistributedDataParallel``
+-----------------------------------------------
+PyTorch's `DistributedDataParallel`_ works out-of-the-box with the ``Join``
+context manager. Here is an example usage:
+
+::
+
+    import os
+    import torch
+    import torch.distributed as dist
+    import torch.multiprocessing as mp
+    from torch.distributed.algorithms.join import Join
+    from torch.nn.parallel import DistributedDataParallel as DDP
+
+    BACKEND = "nccl"
+    WORLD_SIZE = 2
+    NUM_INPUTS = 5
+
+    def worker(rank):
+        os.environ['MASTER_ADDR'] = 'localhost'
+        os.environ['MASTER_PORT'] = '29500'
+        dist.init_process_group(BACKEND, rank=rank, world_size=WORLD_SIZE)
+
+        model = DDP(torch.nn.Linear(1, 1).to(rank), device_ids=[rank])
+        # Rank 1 gets one more input than rank 0
+        inputs = [torch.tensor([1]).float() for _ in range(NUM_INPUTS + rank)]
+
+        num_inputs = 0
+        with Join([model]):
+            for input in inputs:
+                num_inputs += 1
+                loss = model(input).sum()
+                loss.backward()
+
+        print(f"Rank {rank} has exhausted all {num_inputs} of its inputs!")
+
+    def main():
+        mp.spawn(worker, nprocs=WORLD_SIZE, join=True)
+
+    if __name__ == "__main__":
+        main()
+
+This produces the following output (where the ``print()`` s from rank 0 and
+rank 1 may be arbitrarily ordered):
+
+::
+
+  Rank 0 has exhausted all 5 of its inputs!
+  Rank 1 has exhausted all 6 of its inputs!
+
+.. note::
+    `DistributedDataParallel`_ provided its own `join()`_ context manager
+    prior to the introduction of this generic ``Join`` context manager. In the
+    above example, using ``with Join([model]):`` is equivalent to using
+    ``with model.join():``. One limitation of the existing
+    ``DistributedDataParallel.join()`` is that it does not allow multiple
+    participating classes, e.g. ``DistributedDataParallel`` and
+    `ZeroRedundancyOptimizer`_ together.
+
+Using ``Join`` with ``DistributedDataParallel`` and ``ZeroRedundancyOptimizer``
+-------------------------------------------------------------------------------
+The ``Join`` context manager works not only with a single class but also with
+multiple classes together. PyTorch's ``ZeroRedundancyOptimizer`` is also
+compatible with the context manager, so here, we examine how to modify the
+previous example to use both ``DistributedDataParallel`` and
+``ZeroRedundancyOptimizer``:
+
+::
+
+    from torch.distributed.optim import ZeroRedundancyOptimizer as ZeRO
+    from torch.optim import Adam
+
+    def worker(rank):
+        os.environ['MASTER_ADDR'] = 'localhost'
+        os.environ['MASTER_PORT'] = '29500'
+        dist.init_process_group(BACKEND, rank=rank, world_size=WORLD_SIZE)
+
+        model = DDP(torch.nn.Linear(1, 1).to(rank), device_ids=[rank])
+        optim = ZeRO(model.parameters(), Adam, lr=0.01)
+        # Rank 1 gets one more input than rank 0
+        inputs = [torch.tensor([1]).float() for _ in range(NUM_INPUTS + rank)]
+
+        num_inputs = 0
+        # Pass both `model` and `optim` into `Join()`
+        with Join([model, optim]):
+            for input in inputs:
+                num_inputs += 1
+                loss = model(input).sum()
+                loss.backward()
+                optim.step()
+
+        print(f"Rank {rank} has exhausted all {num_inputs} of its inputs!")
+
+This will yield the same output as before. The notable change was
+additionally passing in the ``ZeroRedundancyOptimizer`` instance into
+``Join()``.
+
+Passing Keyword Arguments
+-------------------------
+Classes may provide keyword arguments that modify their behavior in the context
+manager at run time. For example, ``DistributedDataParallel`` provides an
+argument ``divide_by_initial_world_size``, which determines if gradients are
+divided by the initial world size or by the effective world size (i.e. number
+of non-joined ranks). Such keyword arguments can be passed directly into the
+context manager.
+
+::
+
+    with Join([model, optim], divide_by_initial_world_size=False):
+        for input in inputs:
+            ...
+
+.. warning::
+    The keyword arguments passed into the context manager are shared across
+    all participating classes. This should not be a limitation since we do
+    not expect cases where multiple ``Joinable`` s need differing settings
+    of the same argument. Nonetheless, this is something to keep in mind.
+
+How Does ``Join`` Work?
+-----------------------
+Now that we have seen some preliminary examples of how to use the ``Join``
+context manager, let us delve deeper into how it works. This will provide a
+greater insight into the full capability that it offers and prepare you to make
+your own custom classes compatible. Here, we will go over the ``Join`` class as
+well as the supporting classes ``Joinable`` and ``JoinHook``.
+
+``Joinable``
+^^^^^^^^^^^^
+
+To begin, classes compatible with the ``Join`` context manager must inherit
+from the abstract base class ``Joinable``. In particular, a ``Joinable`` must
+implement:
+
+- ``join_hook(self, **kwargs) -> JoinHook``
+
+This returns the ``JoinHook`` instance for the ``Joinable``, determining how
+joined processes should shadow the per-iteration collective communications
+performed by the ``Joinable``.
+
+- ``join_device(self) -> torch.device``
+
+This returns a device to be used by the ``Join`` context manager to perform
+collective communications, e.g. ``torch.device("cuda:0")`` or
+``torch.device("cpu")``.
+
+- ``join_process_group(self) -> ProcessGroup``
+
+This returns the process group to be used by the ``Join`` context manager to
+perform collective communications.
+
+In particular, the ``join_device`` and ``join_process_group`` are required
+attributes to ensure that the context manager can schedule collective
+communications between joined and non-joined processes. One usage is to count
+the number of non-joined processes on each iteration using an all-reduce.
+Another usage is for implementing the mechanism required for
+``throw_on_early_termination=True``, which we will explain later below.
+
+``DistributedDataParallel`` and ``ZeroRedundancyOptimizer`` already inherit
+from ``Joinable`` and implement the above methods, which is why we could
+directly use them in the previous examples.
+
+``Joinable`` classes should make sure to call the ``Joinable`` constructor
+since it initializes a ``JoinConfig`` instance, which is used internally by
+the context manager to ensure correctness. This will be saved in each
+``Joinable`` as a field ``_join_config``.
+
+``JoinHook``
+^^^^^^^^^^^^
+
+Next, let us break down the ``JoinHook`` class. A ``JoinHook`` provides two
+entry points into a context manager:
+
+- ``main_hook(self) -> None``
+
+This hook is called repeatedly by each joined rank while there exists a rank
+that has not yet joined. It is meant to shadow the collective communications
+performed by the ``Joinable`` in each training iteration (e.g. in one forward
+pass, backward pass, and optimizer step).
+
+- ``post_hook(self, is_last_joiner: bool) -> None``
+
+This hook is called once all ranks have joined. It is passed an additional
+``bool`` argument ``is_last_joiner``, which indicates if the rank was one of
+the last to join. The argument may be useful for synchronization.
+
+To give concrete examples of what these hooks may look like, the provided
+``ZeroRedundancyOptimizer`` main hook performs an optimizer step per normal
+since the joined rank is still responsible for updating and synchronizing its
+shard of the parameters, and the provided ``DistributedDataParallel`` post-hook
+broadcasts the final updated model from one of the last joining ranks to ensure
+that it is the same across all ranks.
+
+``Join``
+^^^^^^^^
+
+Finally, let us examine how these fit into the ``Join`` class itself.
+
+- ``__init__(self, joinables: List[Joinable], enable: bool = True, throw_on_early_termination: bool = False)``
+
+As we saw in the previous examples, the constructor takes in a list of the
+``Joinable`` s that participate in the training loop. These should be the
+classes that perform collective communications in each iteration.
+
+``enable`` is a ``bool`` that can be set to ``False`` if you know that there
+will not be uneven inputs, in which case the context manager becomes vacuous
+similar to ``contextlib.nullcontext()``. This also may disable join-related
+computation in the participating ``Joinable`` s.
+
+``throw_on_early_termination`` is a ``bool`` that can be set to ``True`` to
+have each rank raise an exception the moment that uneven inputs are detected.
+This is useful for cases that do not conform to the context manager's
+requirements, which is most typically when there are collective communications
+from different classes that may be arbitrarily interleaved, such as when using
+``DistributedDataParallel`` with a model that has ``SyncBatchNorm`` layers. In
+such cases, this argument should be set to ``True`` so that the application
+logic can catch the exception and determine how to proceed.
+
+- The core logic occurs in the ``__exit__()`` method, which loops while there
+  exists a non-joined rank, calling each ``Joinable`` 's main hook, and
+  then once all ranks have joined, calls their post hooks. Both the main hooks
+  and post-hooks are iterated over in the order that the ``Joinable`` s are
+  passed in.
+
+- The context manager requires a heartbeat from non-joined processes. As such,
+  each ``Joinable`` class should make a call to ``Join.notify_join_context()``
+  before its per-iteration collective communications. The context manager will
+  ensure that only the first ``Joinable`` passed in actually sends the
+  heartbeat.
+
+.. warning:: As mentioned above regarding ``throw_on_early_termination``, the
+    ``Join`` context manager is not compatible with certain compositions of
+    classes. The ``Joinable`` 's ``JoinHook`` s must be serializable since each
+    hook is fully executed before proceeding to the next. In other words, two
+    hooks cannot overlap. Moreover, currently, both the main hooks and post-
+    hooks are iterated over in the same deterministic order. If this appears to
+    be a major limitation, we may modify the API to permit a customizable
+    ordering.
+
+Making a Toy Class Work with ``Join``
+-------------------------------------
+Since the previous section introduced several concepts, let us see them in
+practice with a toy example. Here, we will implement a class that counts the
+number of inputs that are seen across all ranks before its rank joins. This
+should provide a basic idea of how you may make your own class compatible
+with the ``Join`` context manager.
+
+Specifically, the following code has each rank print out (1) the number of
+inputs across all ranks that seen before it joins and (2) the total number
+of inputs across all ranks.
+
+::
+
+    import os
+    import torch
+    import torch.distributed as dist
+    import torch.multiprocessing as mp
+    from torch.distributed.algorithms.join import Join, Joinable, JoinHook
+
+    BACKEND = "nccl"
+    WORLD_SIZE = 2
+    NUM_INPUTS = 5
+
+    class CounterJoinHook(JoinHook):
+        r"""
+        Join hook for :class:`Counter`.
+
+        Arguments:
+            counter (Counter): the :class:`Counter` object using this hook.
+            sync_max_count (bool): whether to sync the max count once all ranks
+                join.
+        """
+        def __init__(
+            self,
+            counter,
+            sync_max_count
+        ):
+            self.counter = counter
+            self.sync_max_count = sync_max_count
+
+        def main_hook(self):
+            r"""
+            Shadows the counter's all-reduce by all-reducing a dim-1 zero tensor.
+            """
+            t = torch.zeros(1, device=self.counter.device)
+            dist.all_reduce(t)
+
+        def post_hook(self, is_last_joiner: bool):
+            r"""
+            Synchronizes the max count across all :class:`Counter` s if
+            ``sync_max_count=True``.
+            """
+            if not self.sync_max_count:
+                return
+            rank = dist.get_rank(self.counter.process_group)
+            common_rank = self.counter.find_common_rank(rank, is_last_joiner)
+            if rank == common_rank:
+                self.counter.max_count = self.counter.count.detach().clone()
+            dist.broadcast(self.counter.max_count, src=common_rank)
+
+    class Counter(Joinable):
+        r"""
+        Example :class:`Joinable` that counts the number of training iterations
+        that it participates in.
+        """
+        def __init__(self, device, process_group):
+            super(Counter, self).__init__()
+            self.device = device
+            self.process_group = process_group
+            self.count = torch.tensor([0], device=device).float()
+            self.max_count = torch.tensor([0], device=device).float()
+
+        def __call__(self):
+            r"""
+            Counts the number of inputs processed on this iteration by all ranks
+            by all-reducing a dim-1 one tensor; increments its own internal count.
+            """
+            Join.notify_join_context(self)
+            t = torch.ones(1, device=self.device).float()
+            dist.all_reduce(t)
+            self.count += t
+
+        def join_hook(self, **kwargs) -> JoinHook:
+            r"""
+            Return a join hook that shadows the all-reduce in :meth:`__call__`.
+
+            This join hook supports the following keyword arguments:
+                sync_max_count (bool, optional): whether to synchronize the maximum
+                    count across all ranks once all ranks join; default is ``False``.
+            """
+            sync_max_count = kwargs.get("sync_max_count", False)
+            return CounterJoinHook(self, sync_max_count)
+
+        @property
+        def join_device(self) -> torch.device:
+            return self.device
+
+        @property
+        def join_process_group(self):
+            return self.process_group
+
+        def find_common_rank(self, rank, to_consider):
+            r"""
+            Returns the max rank of the ones to consider over the process group.
+            """
+            common_rank = torch.tensor([rank if to_consider else -1], device=self.device)
+            dist.all_reduce(common_rank, op=dist.ReduceOp.MAX, group=self.process_group)
+            common_rank = common_rank.item()
+            return common_rank
+
+    def worker(rank):
+        assert torch.cuda.device_count() >= WORLD_SIZE
+        os.environ['MASTER_ADDR'] = 'localhost'
+        os.environ['MASTER_PORT'] = '29500'
+        dist.init_process_group(BACKEND, rank=rank, world_size=WORLD_SIZE)
+
+        counter = Counter(torch.device(f"cuda:{rank}"), dist.group.WORLD)
+        inputs = [torch.tensor([1]).float() for _ in range(NUM_INPUTS + rank)]
+
+        with Join([counter], sync_max_count=True):
+            for _ in inputs:
+                counter()
+
+        print(f"{int(counter.count.item())} inputs processed before rank {rank} joined!")
+        print(f"{int(counter.max_count.item())} inputs processed across all ranks!")
+
+    def main():
+        mp.spawn(worker, nprocs=WORLD_SIZE, join=True)
+
+    if __name__ == "__main__":
+        main()
+
+Since rank 0 sees 5 inputs and rank 1 sees 6, this yields the output:
+
+::
+
+    10 inputs processed before rank 0 joined!
+    11 inputs processed across all ranks!
+    11 inputs processed before rank 1 joined!
+    11 inputs processed across all ranks!
+
+Some key points to highlight:
+
+- A ``Counter`` instance performs a single all-reduce per iteration, so the
+  main hook performs a single all-reduce as well to shadow it.
+
+- The ``Counter`` class makes a call to ``Join.notify_join_context()`` at the
+  beginning of its ``__call__()`` method since that is a place before its per-
+  iteration collective communications (i.e. its all-reduce).
+
+- The ``is_last_joiner`` argument is used to determine the broadcast source in
+  the post-hooks.
+
+- We pass in the ``sync_max_count`` keyword argument to the context manager,
+  which is then forwarded to ``Counter`` 's join hook.
+
+
+.. _Join: https://pytorch.org/docs/master/distributed.algorithms.join.html
+.. _Getting Started with Distributed Data Parallel: https://pytorch.org/tutorials/intermediate/ddp_tutorial.html
+.. _Getting Started with Distributed Data Parallel - Basic Use Case: https://pytorch.org/tutorials/intermediate/ddp_tutorial.html#basic-use-case
+.. _Shard Optimizer States with ZeroRedundancyOptimizer: https://pytorch.org/tutorials/recipes/zero_redundancy_optimizer.html
+.. _DistributedDataParallel: https://pytorch.org/docs/stable/generated/torch.nn.parallel.DistributedDataParallel.html
+.. _join(): https://docs.pytorch.org/docs/stable/generated/torch.nn.parallel.DistributedDataParallel.html#torch.nn.parallel.DistributedDataParallel.join
+.. _ZeroRedundancyOptimizer: https://pytorch.org/docs/stable/distributed.optim.html
diff --git a/advanced_source/neural_style_tutorial.py b/advanced_source/neural_style_tutorial.py
index 374e6794238..b4ab10ef01d 100644
--- a/advanced_source/neural_style_tutorial.py
+++ b/advanced_source/neural_style_tutorial.py
@@ -14,7 +14,7 @@
 developed by Leon A. Gatys, Alexander S. Ecker and Matthias Bethge.
 Neural-Style, or Neural-Transfer, allows you to take an image and
 reproduce it with a new artistic style. The algorithm takes three images,
-an input image, a content-image, and a style-image, and changes the input 
+an input image, a content-image, and a style-image, and changes the input
 to resemble the content of the content-image and the artistic style of the style-image.
 
  
@@ -44,11 +44,9 @@
 # -  ``PIL``, ``PIL.Image``, ``matplotlib.pyplot`` (load and display
 #    images)
 # -  ``torchvision.transforms`` (transform PIL images into tensors)
-# -  ``torchvision.models`` (train or load pre-trained models)
+# -  ``torchvision.models`` (train or load pretrained models)
 # -  ``copy`` (to deep copy the models; system package)
 
-from __future__ import print_function
-
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
@@ -58,7 +56,7 @@
 import matplotlib.pyplot as plt
 
 import torchvision.transforms as transforms
-import torchvision.models as models
+from torchvision.models import vgg19, VGG19_Weights
 
 import copy
 
@@ -72,6 +70,7 @@
 # method is used to move tensors or modules to a desired device. 
 
 device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+torch.set_default_device(device)
 
 ######################################################################
 # Loading the Images
@@ -83,12 +82,12 @@
 # An important detail to note is that neural networks from the
 # torch library are trained with tensor values ranging from 0 to 1. If you
 # try to feed the networks with 0 to 255 tensor images, then the activated
-# feature maps will be unable sense the intended content and style.
-# However, pre-trained networks from the Caffe library are trained with 0
+# feature maps will be unable to sense the intended content and style.
+# However, pretrained networks from the Caffe library are trained with 0
 # to 255 tensor images. 
 #
 #
-# .. Note::
+# .. note::
 #     Here are links to download the images required to run the tutorial:
 #     `picasso.jpg <https://pytorch.org/tutorials/_static/img/neural-style/picasso.jpg>`__ and
 #     `dancing.jpg <https://pytorch.org/tutorials/_static/img/neural-style/dancing.jpg>`__.
@@ -96,7 +95,7 @@
 #     with name ``images`` in your current working directory.
 
 # desired size of the output image
-imsize = 512 if torch.cuda.is_available() else 128  # use small size if no gpu
+imsize = 512 if torch.cuda.is_available() else 128  # use small size if no GPU
 
 loader = transforms.Compose([
     transforms.Resize(imsize),  # scale imported image
@@ -184,7 +183,7 @@ def forward(self, input):
         return input
 
 ######################################################################
-# .. Note::
+# .. note::
 #    **Important detail**: although this module is named ``ContentLoss``, it
 #    is not a true PyTorch Loss function. If you want to define your content
 #    loss as a PyTorch Loss function, you have to create a PyTorch autograd function 
@@ -220,7 +219,7 @@ def gram_matrix(input):
     # b=number of feature maps
     # (c,d)=dimensions of a f. map (N=c*d)
 
-    features = input.view(a * b, c * d)  # resise F_XL into \hat F_XL
+    features = input.view(a * b, c * d)  # resize F_XL into \hat F_XL
 
     G = torch.mm(features, features.t())  # compute the gram product
 
@@ -251,7 +250,7 @@ def forward(self, input):
 # Importing the Model
 # -------------------
 # 
-# Now we need to import a pre-trained neural network. We will use a 19
+# Now we need to import a pretrained neural network. We will use a 19
 # layer VGG network like the one used in the paper.
 # 
 # PyTorch’s implementation of VGG is a module divided into two child
@@ -263,7 +262,7 @@ def forward(self, input):
 # network to evaluation mode using ``.eval()``.
 # 
 
-cnn = models.vgg19(pretrained=True).features.to(device).eval()
+cnn = vgg19(weights=VGG19_Weights.DEFAULT).features.eval()
 
 
 
@@ -273,11 +272,11 @@ def forward(self, input):
 # We will use them to normalize the image before sending it into the network.
 # 
 
-cnn_normalization_mean = torch.tensor([0.485, 0.456, 0.406]).to(device)
-cnn_normalization_std = torch.tensor([0.229, 0.224, 0.225]).to(device)
+cnn_normalization_mean = torch.tensor([0.485, 0.456, 0.406])
+cnn_normalization_std = torch.tensor([0.229, 0.224, 0.225])
 
 # create a module to normalize input image so we can easily put it in a
-# nn.Sequential
+# ``nn.Sequential``
 class Normalization(nn.Module):
     def __init__(self, mean, std):
         super(Normalization, self).__init__()
@@ -288,14 +287,14 @@ def __init__(self, mean, std):
         self.std = torch.tensor(std).view(-1, 1, 1)
 
     def forward(self, img):
-        # normalize img
+        # normalize ``img``
         return (img - self.mean) / self.std
 
 
 ######################################################################
 # A ``Sequential`` module contains an ordered list of child modules. For
-# instance, ``vgg19.features`` contains a sequence (Conv2d, ReLU, MaxPool2d,
-# Conv2d, ReLU…) aligned in the right order of depth. We need to add our
+# instance, ``vgg19.features`` contains a sequence (``Conv2d``, ``ReLU``, ``MaxPool2d``,
+# ``Conv2d``, ``ReLU``…) aligned in the right order of depth. We need to add our
 # content loss and style loss layers immediately after the convolution
 # layer they are detecting. To do this we must create a new ``Sequential``
 # module that has content loss and style loss modules correctly inserted.
@@ -309,17 +308,15 @@ def get_style_model_and_losses(cnn, normalization_mean, normalization_std,
                                style_img, content_img,
                                content_layers=content_layers_default,
                                style_layers=style_layers_default):
-    cnn = copy.deepcopy(cnn)
-
     # normalization module
-    normalization = Normalization(normalization_mean, normalization_std).to(device)
+    normalization = Normalization(normalization_mean, normalization_std)
 
-    # just in order to have an iterable access to or list of content/syle
+    # just in order to have an iterable access to or list of content/style
     # losses
     content_losses = []
     style_losses = []
 
-    # assuming that cnn is a nn.Sequential, so we make a new nn.Sequential
+    # assuming that ``cnn`` is a ``nn.Sequential``, so we make a new ``nn.Sequential``
     # to put in modules that are supposed to be activated sequentially
     model = nn.Sequential(normalization)
 
@@ -330,8 +327,8 @@ def get_style_model_and_losses(cnn, normalization_mean, normalization_std,
             name = 'conv_{}'.format(i)
         elif isinstance(layer, nn.ReLU):
             name = 'relu_{}'.format(i)
-            # The in-place version doesn't play very nicely with the ContentLoss
-            # and StyleLoss we insert below. So we replace with out-of-place
+            # The in-place version doesn't play very nicely with the ``ContentLoss``
+            # and ``StyleLoss`` we insert below. So we replace with out-of-place
             # ones here.
             layer = nn.ReLU(inplace=False)
         elif isinstance(layer, nn.MaxPool2d):
@@ -373,8 +370,11 @@ def get_style_model_and_losses(cnn, normalization_mean, normalization_std,
 # 
 
 input_img = content_img.clone()
-# if you want to use white noise instead uncomment the below line:
-# input_img = torch.randn(content_img.data.size(), device=device)
+# if you want to use white noise by using the following code:
+#
+# .. code-block:: python
+#
+#    input_img = torch.randn(content_img.data.size())
 
 # add the original input image to the figure:
 plt.figure()
@@ -387,14 +387,14 @@ def get_style_model_and_losses(cnn, normalization_mean, normalization_std,
 # 
 # As Leon Gatys, the author of the algorithm, suggested `here <https://discuss.pytorch.org/t/pytorch-tutorial-for-neural-transfert-of-artistic-style/336/20?u=alexis-jacq>`__, we will use
 # L-BFGS algorithm to run our gradient descent. Unlike training a network,
-# we want to train the input image in order to minimise the content/style
+# we want to train the input image in order to minimize the content/style
 # losses. We will create a PyTorch L-BFGS optimizer ``optim.LBFGS`` and pass
 # our image to it as the tensor to optimize.
 # 
 
 def get_input_optimizer(input_img):
     # this line to show that input is a parameter that requires a gradient
-    optimizer = optim.LBFGS([input_img.requires_grad_()])
+    optimizer = optim.LBFGS([input_img])
     return optimizer
 
 
@@ -402,8 +402,8 @@ def get_input_optimizer(input_img):
 # Finally, we must define a function that performs the neural transfer. For
 # each iteration of the networks, it is fed an updated input and computes
 # new losses. We will run the ``backward`` methods of each loss module to
-# dynamicaly compute their gradients. The optimizer requires a “closure”
-# function, which reevaluates the modul and returns the loss.
+# dynamically compute their gradients. The optimizer requires a “closure”
+# function, which reevaluates the module and returns the loss.
 # 
 # We still have one final constraint to address. The network may try to
 # optimize the input with values that exceed the 0 to 1 tensor range for
@@ -418,6 +418,15 @@ def run_style_transfer(cnn, normalization_mean, normalization_std,
     print('Building the style transfer model..')
     model, style_losses, content_losses = get_style_model_and_losses(cnn,
         normalization_mean, normalization_std, style_img, content_img)
+
+    # We want to optimize the input and not the model parameters so we
+    # update all the requires_grad fields accordingly
+    input_img.requires_grad_(True)
+    # We also put the model in evaluation mode, so that specific layers 
+    # such as dropout or batch normalization layers behave correctly. 
+    model.eval()
+    model.requires_grad_(False)
+
     optimizer = get_input_optimizer(input_img)
 
     print('Optimizing..')
@@ -426,7 +435,8 @@ def run_style_transfer(cnn, normalization_mean, normalization_std,
 
         def closure():
             # correct the values of updated input image
-            input_img.data.clamp_(0, 1)
+            with torch.no_grad():
+                input_img.clamp_(0, 1)
 
             optimizer.zero_grad()
             model(input_img)
@@ -456,7 +466,8 @@ def closure():
         optimizer.step(closure)
 
     # a last correction...
-    input_img.data.clamp_(0, 1)
+    with torch.no_grad():
+        input_img.clamp_(0, 1)
 
     return input_img
 
diff --git a/advanced_source/numpy_extensions_tutorial.py b/advanced_source/numpy_extensions_tutorial.py
index 237fdc540ba..8ccd92d3765 100644
--- a/advanced_source/numpy_extensions_tutorial.py
+++ b/advanced_source/numpy_extensions_tutorial.py
@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 """
-Creating Extensions Using numpy and scipy
+Creating Extensions Using NumPy and SciPy
 =========================================
 **Author**: `Adam Paszke <https://github.com/apaszke>`_
 
@@ -27,7 +27,7 @@
 # This layer doesn’t particularly do anything useful or mathematically
 # correct.
 #
-# It is aptly named BadFFTFunction
+# It is aptly named ``BadFFTFunction``
 #
 # **Layer Implementation**
 
@@ -35,23 +35,24 @@
 
 
 class BadFFTFunction(Function):
-
-    def forward(self, input):
+    @staticmethod
+    def forward(ctx, input):
         numpy_input = input.detach().numpy()
         result = abs(rfft2(numpy_input))
         return input.new(result)
 
-    def backward(self, grad_output):
+    @staticmethod
+    def backward(ctx, grad_output):
         numpy_go = grad_output.numpy()
         result = irfft2(numpy_go)
         return grad_output.new(result)
 
 # since this layer does not have any parameters, we can
-# simply declare this as a function, rather than as an nn.Module class
+# simply declare this as a function, rather than as an ``nn.Module`` class
 
 
 def incorrect_fft(input):
-    return BadFFTFunction()(input)
+    return BadFFTFunction.apply(input)
 
 ###############################################################
 # **Example usage of the created layer:**
@@ -74,7 +75,7 @@ def incorrect_fft(input):
 # Implementation of a layer with learnable weights, where cross-correlation
 # has a filter (kernel) that represents weights.
 #
-# The backward pass computes the gradient wrt the input and the gradient wrt the filter.
+# The backward pass computes the gradient ``wrt`` the input and the gradient ``wrt`` the filter.
 
 from numpy import flip
 import numpy as np
diff --git a/advanced_source/pendulum.py b/advanced_source/pendulum.py
new file mode 100644
index 00000000000..3084fe8312b
--- /dev/null
+++ b/advanced_source/pendulum.py
@@ -0,0 +1,930 @@
+# -*- coding: utf-8 -*-
+
+"""
+Pendulum: Writing your environment and transforms with TorchRL
+==============================================================
+
+**Author**: `Vincent Moens <https://github.com/vmoens>`_
+
+Creating an environment (a simulator or an interface to a physical control system)
+is an integrative part of reinforcement learning and control engineering.
+
+TorchRL provides a set of tools to do this in multiple contexts.
+This tutorial demonstrates how to use PyTorch and TorchRL code a pendulum
+simulator from the ground up.
+It is freely inspired by the Pendulum-v1 implementation from `OpenAI-Gym/Farama-Gymnasium
+control library <https://github.com/Farama-Foundation/Gymnasium>`__.
+
+.. figure:: /_static/img/pendulum.gif
+   :alt: Pendulum
+   :align: center
+
+   Simple Pendulum
+
+Key learnings:
+
+- How to design an environment in TorchRL:
+  - Writing specs (input, observation and reward);
+  - Implementing behavior: seeding, reset and step.
+- Transforming your environment inputs and outputs, and writing your own
+  transforms;
+- How to use :class:`~tensordict.TensorDict` to carry arbitrary data structures 
+  through the ``codebase``.
+
+  In the process, we will touch three crucial components of TorchRL:
+
+* `environments <https://pytorch.org/rl/stable/reference/envs.html>`__
+* `transforms <https://pytorch.org/rl/stable/reference/envs.html#transforms>`__
+* `models (policy and value function) <https://pytorch.org/rl/stable/reference/modules.html>`__
+
+"""
+
+######################################################################
+# To give a sense of what can be achieved with TorchRL's environments, we will
+# be designing a *stateless* environment. While stateful environments keep track of
+# the latest physical state encountered and rely on this to simulate the state-to-state
+# transition, stateless environments expect the current state to be provided to
+# them at each step, along with the action undertaken. TorchRL supports both
+# types of environments, but stateless environments are more generic and hence
+# cover a broader range of features of the environment API in TorchRL.
+#
+# Modeling stateless environments gives users full control over the input and
+# outputs of the simulator: one can reset an experiment at any stage or actively
+# modify the dynamics from the outside. However, it assumes that we have some control
+# over a task, which may not always be the case: solving a problem where we cannot
+# control the current state is more challenging but has a much wider set of applications.
+#
+# Another advantage of stateless environments is that they can enable
+# batched execution of transition simulations. If the backend and the
+# implementation allow it, an algebraic operation can be executed seamlessly on
+# scalars, vectors, or tensors. This tutorial gives such examples.
+#
+# This tutorial will be structured as follows:
+#
+# * We will first get acquainted with the environment properties:
+#   its shape (``batch_size``), its methods (mainly :meth:`~torchrl.envs.EnvBase.step`,
+#   :meth:`~torchrl.envs.EnvBase.reset` and :meth:`~torchrl.envs.EnvBase.set_seed`)
+#   and finally its specs.
+# * After having coded our simulator, we will demonstrate how it can be used
+#   during training with transforms.
+# * We will explore new avenues that follow from the TorchRL's API,
+#   including: the possibility of transforming inputs, the vectorized execution
+#   of the simulation and the possibility of backpropagation through the
+#   simulation graph.
+# * Finally, we will train a simple policy to solve the system we implemented.
+#
+
+# sphinx_gallery_start_ignore
+import warnings
+
+warnings.filterwarnings("ignore")
+from torch import multiprocessing
+
+# TorchRL prefers spawn method, that restricts creation of  ``~torchrl.envs.ParallelEnv`` inside
+# `__main__` method call, but for the easy of reading the code switch to fork
+# which is also a default spawn method in Google's Colaboratory
+try:
+    multiprocessing.set_start_method("fork")
+except RuntimeError:
+    pass
+
+# sphinx_gallery_end_ignore
+
+from collections import defaultdict
+from typing import Optional
+
+import numpy as np
+import torch
+import tqdm
+from tensordict import TensorDict, TensorDictBase
+from tensordict.nn import TensorDictModule
+from torch import nn
+
+from torchrl.data import BoundedTensorSpec, CompositeSpec, UnboundedContinuousTensorSpec
+from torchrl.envs import (
+    CatTensors,
+    EnvBase,
+    Transform,
+    TransformedEnv,
+    UnsqueezeTransform,
+)
+from torchrl.envs.transforms.transforms import _apply_to_composite
+from torchrl.envs.utils import check_env_specs, step_mdp
+
+DEFAULT_X = np.pi
+DEFAULT_Y = 1.0
+
+######################################################################
+# There are four things you must take care of when designing a new environment
+# class:
+#
+# * :meth:`EnvBase._reset`, which codes for the resetting of the simulator
+#   at a (potentially random) initial state;
+# * :meth:`EnvBase._step` which codes for the state transition dynamic;
+# * :meth:`EnvBase._set_seed`` which implements the seeding mechanism;
+# * the environment specs.
+#
+# Let us first describe the problem at hand: we would like to model a simple
+# pendulum over which we can control the torque applied on its fixed point.
+# Our goal is to place the pendulum in upward position (angular position at 0
+# by convention) and having it standing still in that position.
+# To design our dynamic system, we need to define two equations: the motion
+# equation following an action (the torque applied) and the reward equation
+# that will constitute our objective function.
+#
+# For the motion equation, we will update the angular velocity following:
+#
+# .. math::
+#
+#    \dot{\theta}_{t+1} = \dot{\theta}_t + (3 * g / (2 * L) * \sin(\theta_t) + 3 / (m * L^2) * u) * dt
+#
+# where :math:`\dot{\theta}` is the angular velocity in rad/sec, :math:`g` is the
+# gravitational force, :math:`L` is the pendulum length, :math:`m` is its mass,
+# :math:`\theta` is its angular position and :math:`u` is the torque. The
+# angular position is then updated according to
+#
+# .. math::
+#
+#    \theta_{t+1} = \theta_{t} + \dot{\theta}_{t+1} dt
+#
+# We define our reward as
+#
+# .. math::
+#
+#    r = -(\theta^2 + 0.1 * \dot{\theta}^2 + 0.001 * u^2)
+#
+# which will be maximized when the angle is close to 0 (pendulum in upward
+# position), the angular velocity is close to 0 (no motion) and the torque is
+# 0 too.
+#
+# Coding the effect of an action: :func:`~torchrl.envs.EnvBase._step`
+# -------------------------------------------------------------------
+#
+# The step method is the first thing to consider, as it will encode
+# the simulation that is of interest to us. In TorchRL, the
+# :class:`~torchrl.envs.EnvBase` class has a :meth:`EnvBase.step`
+# method that receives a :class:`tensordict.TensorDict`
+# instance with an ``"action"`` entry indicating what action is to be taken.
+#
+# To facilitate the reading and writing from that ``tensordict`` and to make sure
+# that the keys are consistent with what's expected from the library, the
+# simulation part has been delegated to a private abstract method :meth:`_step`
+# which reads input data from a ``tensordict``, and writes a *new*  ``tensordict``
+# with the output data.
+#
+# The :func:`_step` method should do the following:
+#
+#   1. Read the input keys (such as ``"action"``) and execute the simulation
+#      based on these;
+#   2. Retrieve observations, done state and reward;
+#   3. Write the set of observation values along with the reward and done state
+#      at the corresponding entries in a new :class:`TensorDict`.
+#
+# Next, the :meth:`~torchrl.envs.EnvBase.step` method will merge the output
+# of :meth:`~torchrl.envs.EnvBase.step` in the input ``tensordict`` to enforce
+# input/output consistency.
+#
+# Typically, for stateful environments, this will look like this:
+#
+# .. code-block::
+#
+#   >>> policy(env.reset())
+#   >>> print(tensordict)
+#   TensorDict(
+#       fields={
+#           action: Tensor(shape=torch.Size([1]), device=cpu, dtype=torch.float32, is_shared=False),
+#           done: Tensor(shape=torch.Size([1]), device=cpu, dtype=torch.bool, is_shared=False),
+#           observation: Tensor(shape=torch.Size([]), device=cpu, dtype=torch.float32, is_shared=False)},
+#       batch_size=torch.Size([]),
+#       device=cpu,
+#       is_shared=False)
+#   >>> env.step(tensordict)
+#   >>> print(tensordict)
+#   TensorDict(
+#       fields={
+#           action: Tensor(shape=torch.Size([1]), device=cpu, dtype=torch.float32, is_shared=False),
+#           done: Tensor(shape=torch.Size([1]), device=cpu, dtype=torch.bool, is_shared=False),
+#           next: TensorDict(
+#               fields={
+#                   done: Tensor(shape=torch.Size([1]), device=cpu, dtype=torch.bool, is_shared=False),
+#                   observation: Tensor(shape=torch.Size([]), device=cpu, dtype=torch.float32, is_shared=False),
+#                   reward: Tensor(shape=torch.Size([1]), device=cpu, dtype=torch.float32, is_shared=False)},
+#               batch_size=torch.Size([]),
+#               device=cpu,
+#               is_shared=False),
+#           observation: Tensor(shape=torch.Size([]), device=cpu, dtype=torch.float32, is_shared=False)},
+#       batch_size=torch.Size([]),
+#       device=cpu,
+#       is_shared=False)
+#
+# Notice that the root ``tensordict`` has not changed, the only modification is the
+# appearance of a new ``"next"`` entry that contains the new information.
+#
+# In the Pendulum example, our :meth:`_step` method will read the relevant
+# entries from the input ``tensordict`` and compute the position and velocity of
+# the pendulum after the force encoded by the ``"action"`` key has been applied
+# onto it. We compute the new angular position of the pendulum
+# ``"new_th"`` as the result of the previous position ``"th"`` plus the new
+# velocity ``"new_thdot"`` over a time interval ``dt``.
+#
+# Since our goal is to turn the pendulum up and maintain it still in that
+# position, our ``cost`` (negative reward) function is lower for positions
+# close to the target and low speeds.
+# Indeed, we want to discourage positions that are far from being "upward"
+# and/or speeds that are far from 0.
+#
+# In our example, :meth:`EnvBase._step` is encoded as a static method since our
+# environment is stateless. In stateful settings, the ``self`` argument is
+# needed as the state needs to be read from the environment.
+#
+
+
+def _step(tensordict):
+    th, thdot = tensordict["th"], tensordict["thdot"]  # th := theta
+
+    g_force = tensordict["params", "g"]
+    mass = tensordict["params", "m"]
+    length = tensordict["params", "l"]
+    dt = tensordict["params", "dt"]
+    u = tensordict["action"].squeeze(-1)
+    u = u.clamp(-tensordict["params", "max_torque"], tensordict["params", "max_torque"])
+    costs = angle_normalize(th) ** 2 + 0.1 * thdot**2 + 0.001 * (u**2)
+
+    new_thdot = (
+        thdot
+        + (3 * g_force / (2 * length) * th.sin() + 3.0 / (mass * length**2) * u) * dt
+    )
+    new_thdot = new_thdot.clamp(
+        -tensordict["params", "max_speed"], tensordict["params", "max_speed"]
+    )
+    new_th = th + new_thdot * dt
+    reward = -costs.view(*tensordict.shape, 1)
+    done = torch.zeros_like(reward, dtype=torch.bool)
+    out = TensorDict(
+        {
+            "th": new_th,
+            "thdot": new_thdot,
+            "params": tensordict["params"],
+            "reward": reward,
+            "done": done,
+        },
+        tensordict.shape,
+    )
+    return out
+
+
+def angle_normalize(x):
+    return ((x + torch.pi) % (2 * torch.pi)) - torch.pi
+
+
+######################################################################
+# Resetting the simulator: :func:`~torchrl.envs.EnvBase._reset`
+# -------------------------------------------------------------
+#
+# The second method we need to care about is the
+# :meth:`~torchrl.envs.EnvBase._reset` method. Like
+# :meth:`~torchrl.envs.EnvBase._step`, it should write the observation entries
+# and possibly a done state in the ``tensordict`` it outputs (if the done state is
+# omitted, it will be filled as ``False`` by the parent method
+# :meth:`~torchrl.envs.EnvBase.reset`). In some contexts, it is required that
+# the ``_reset`` method receives a command from the function that called
+# it (for example, in multi-agent settings we may want to indicate which agents need
+# to be reset). This is why the :meth:`~torchrl.envs.EnvBase._reset` method
+# also expects a ``tensordict`` as input, albeit it may perfectly be empty or
+# ``None``.
+#
+# The parent :meth:`EnvBase.reset` does some simple checks like the
+# :meth:`EnvBase.step` does, such as making sure that a ``"done"`` state
+# is returned in the output ``tensordict`` and that the shapes match what is
+# expected from the specs.
+#
+# For us, the only important thing to consider is whether
+# :meth:`EnvBase._reset` contains all the expected observations. Once more,
+# since we are working with a stateless environment, we pass the configuration
+# of the pendulum in a nested ``tensordict`` named ``"params"``.
+#
+# In this example, we do not pass a done state as this is not mandatory
+# for :meth:`_reset` and our environment is non-terminating, so we always
+# expect it to be ``False``.
+#
+
+
+def _reset(self, tensordict):
+    if tensordict is None or tensordict.is_empty():
+        # if no ``tensordict`` is passed, we generate a single set of hyperparameters
+        # Otherwise, we assume that the input ``tensordict`` contains all the relevant
+        # parameters to get started.
+        tensordict = self.gen_params(batch_size=self.batch_size)
+
+    high_th = torch.tensor(DEFAULT_X, device=self.device)
+    high_thdot = torch.tensor(DEFAULT_Y, device=self.device)
+    low_th = -high_th
+    low_thdot = -high_thdot
+
+    # for non batch-locked environments, the input ``tensordict`` shape dictates the number
+    # of simulators run simultaneously. In other contexts, the initial
+    # random state's shape will depend upon the environment batch-size instead.
+    th = (
+        torch.rand(tensordict.shape, generator=self.rng, device=self.device)
+        * (high_th - low_th)
+        + low_th
+    )
+    thdot = (
+        torch.rand(tensordict.shape, generator=self.rng, device=self.device)
+        * (high_thdot - low_thdot)
+        + low_thdot
+    )
+    out = TensorDict(
+        {
+            "th": th,
+            "thdot": thdot,
+            "params": tensordict["params"],
+        },
+        batch_size=tensordict.shape,
+    )
+    return out
+
+
+######################################################################
+# Environment metadata: ``env.*_spec``
+# ------------------------------------
+#
+# The specs define the input and output domain of the environment.
+# It is important that the specs accurately define the tensors that will be
+# received at runtime, as they are often used to carry information about
+# environments in multiprocessing and distributed settings. They can also be
+# used to instantiate lazily defined neural networks and test scripts without
+# actually querying the environment (which can be costly with real-world
+# physical systems for instance).
+#
+# There are four specs that we must code in our environment:
+#
+# * :obj:`EnvBase.observation_spec`: This will be a :class:`~torchrl.data.CompositeSpec`
+#   instance where each key is an observation (a :class:`CompositeSpec` can be
+#   viewed as a dictionary of specs).
+# * :obj:`EnvBase.action_spec`: It can be any type of spec, but it is required
+#   that it corresponds to the ``"action"`` entry in the input ``tensordict``;
+# * :obj:`EnvBase.reward_spec`: provides information about the reward space;
+# * :obj:`EnvBase.done_spec`: provides information about the space of the done
+#   flag.
+#
+# TorchRL specs are organized in two general containers: ``input_spec`` which
+# contains the specs of the information that the step function reads (divided
+# between ``action_spec`` containing the action and ``state_spec`` containing
+# all the rest), and ``output_spec`` which encodes the specs that the
+# step outputs (``observation_spec``, ``reward_spec`` and ``done_spec``).
+# In general, you should not interact directly with ``output_spec`` and
+# ``input_spec`` but only with their content: ``observation_spec``,
+# ``reward_spec``, ``done_spec``, ``action_spec`` and ``state_spec``.
+# The reason if that the specs are organized in a non-trivial way
+# within ``output_spec`` and
+# ``input_spec`` and neither of these should be directly modified.
+#
+# In other words, the ``observation_spec`` and related properties are
+# convenient shortcuts to the content of the output and input spec containers.
+#
+# TorchRL offers multiple :class:`~torchrl.data.TensorSpec`
+# `subclasses <https://pytorch.org/rl/stable/reference/data.html#tensorspec>`_ to
+# encode the environment's input and output characteristics.
+#
+# Specs shape
+# ^^^^^^^^^^^
+#
+# The environment specs leading dimensions must match the
+# environment batch-size. This is done to enforce that every component of an
+# environment (including its transforms) have an accurate representation of
+# the expected input and output shapes. This is something that should be
+# accurately coded in stateful settings.
+#
+# For non batch-locked environments, such as the one in our example (see below),
+# this is irrelevant as the environment batch size will most likely be empty.
+#
+
+
+def _make_spec(self, td_params):
+    # Under the hood, this will populate self.output_spec["observation"]
+    self.observation_spec = CompositeSpec(
+        th=BoundedTensorSpec(
+            low=-torch.pi,
+            high=torch.pi,
+            shape=(),
+            dtype=torch.float32,
+        ),
+        thdot=BoundedTensorSpec(
+            low=-td_params["params", "max_speed"],
+            high=td_params["params", "max_speed"],
+            shape=(),
+            dtype=torch.float32,
+        ),
+        # we need to add the ``params`` to the observation specs, as we want
+        # to pass it at each step during a rollout
+        params=make_composite_from_td(td_params["params"]),
+        shape=(),
+    )
+    # since the environment is stateless, we expect the previous output as input.
+    # For this, ``EnvBase`` expects some state_spec to be available
+    self.state_spec = self.observation_spec.clone()
+    # action-spec will be automatically wrapped in input_spec when
+    # `self.action_spec = spec` will be called supported
+    self.action_spec = BoundedTensorSpec(
+        low=-td_params["params", "max_torque"],
+        high=td_params["params", "max_torque"],
+        shape=(1,),
+        dtype=torch.float32,
+    )
+    self.reward_spec = UnboundedContinuousTensorSpec(shape=(*td_params.shape, 1))
+
+
+def make_composite_from_td(td):
+    # custom function to convert a ``tensordict`` in a similar spec structure
+    # of unbounded values.
+    composite = CompositeSpec(
+        {
+            key: make_composite_from_td(tensor)
+            if isinstance(tensor, TensorDictBase)
+            else UnboundedContinuousTensorSpec(
+                dtype=tensor.dtype, device=tensor.device, shape=tensor.shape
+            )
+            for key, tensor in td.items()
+        },
+        shape=td.shape,
+    )
+    return composite
+
+
+######################################################################
+# Reproducible experiments: seeding
+# ---------------------------------
+#
+# Seeding an environment is a common operation when initializing an experiment.
+# The only goal of :func:`EnvBase._set_seed` is to set the seed of the contained
+# simulator. If possible, this operation should not call ``reset()`` or interact
+# with the environment execution. The parent :func:`EnvBase.set_seed` method
+# incorporates a mechanism that allows seeding multiple environments with a
+# different pseudo-random and reproducible seed.
+#
+
+
+def _set_seed(self, seed: Optional[int]):
+    rng = torch.manual_seed(seed)
+    self.rng = rng
+
+
+######################################################################
+# Wrapping things together: the :class:`~torchrl.envs.EnvBase` class
+# ------------------------------------------------------------------
+#
+# We can finally put together the pieces and design our environment class.
+# The specs initialization needs to be performed during the environment
+# construction, so we must take care of calling the :func:`_make_spec` method
+# within :func:`PendulumEnv.__init__`.
+#
+# We add a static method :meth:`PendulumEnv.gen_params` which deterministically
+# generates a set of hyperparameters to be used during execution:
+#
+
+
+def gen_params(g=10.0, batch_size=None) -> TensorDictBase:
+    """Returns a ``tensordict`` containing the physical parameters such as gravitational force and torque or speed limits."""
+    if batch_size is None:
+        batch_size = []
+    td = TensorDict(
+        {
+            "params": TensorDict(
+                {
+                    "max_speed": 8,
+                    "max_torque": 2.0,
+                    "dt": 0.05,
+                    "g": g,
+                    "m": 1.0,
+                    "l": 1.0,
+                },
+                [],
+            )
+        },
+        [],
+    )
+    if batch_size:
+        td = td.expand(batch_size).contiguous()
+    return td
+
+
+######################################################################
+# We define the environment as non-``batch_locked`` by turning the ``homonymous``
+# attribute to ``False``. This means that we will **not** enforce the input
+# ``tensordict`` to have a ``batch-size`` that matches the one of the environment.
+#
+# The following code will just put together the pieces we have coded above.
+#
+
+
+class PendulumEnv(EnvBase):
+    metadata = {
+        "render_modes": ["human", "rgb_array"],
+        "render_fps": 30,
+    }
+    batch_locked = False
+
+    def __init__(self, td_params=None, seed=None, device="cpu"):
+        if td_params is None:
+            td_params = self.gen_params()
+
+        super().__init__(device=device, batch_size=[])
+        self._make_spec(td_params)
+        if seed is None:
+            seed = torch.empty((), dtype=torch.int64).random_().item()
+        self.set_seed(seed)
+
+    # Helpers: _make_step and gen_params
+    gen_params = staticmethod(gen_params)
+    _make_spec = _make_spec
+
+    # Mandatory methods: _step, _reset and _set_seed
+    _reset = _reset
+    _step = staticmethod(_step)
+    _set_seed = _set_seed
+
+
+######################################################################
+# Testing our environment
+# -----------------------
+#
+# TorchRL provides a simple function :func:`~torchrl.envs.utils.check_env_specs`
+# to check that a (transformed) environment has an input/output structure that
+# matches the one dictated by its specs.
+# Let us try it out:
+#
+
+env = PendulumEnv()
+check_env_specs(env)
+
+######################################################################
+# We can have a look at our specs to have a visual representation of the environment
+# signature:
+#
+
+print("observation_spec:", env.observation_spec)
+print("state_spec:", env.state_spec)
+print("reward_spec:", env.reward_spec)
+
+######################################################################
+# We can execute a couple of commands too to check that the output structure
+# matches what is expected.
+
+td = env.reset()
+print("reset tensordict", td)
+
+######################################################################
+# We can run the :func:`env.rand_step` to generate
+# an action randomly from the ``action_spec`` domain. A ``tensordict`` containing
+# the hyperparameters and the current state **must** be passed since our
+# environment is stateless. In stateful contexts, ``env.rand_step()`` works
+# perfectly too.
+#
+td = env.rand_step(td)
+print("random step tensordict", td)
+
+######################################################################
+# Transforming an environment
+# ---------------------------
+#
+# Writing environment transforms for stateless simulators is slightly more
+# complicated than for stateful ones: transforming an output entry that needs
+# to be read at the following iteration requires to apply the inverse transform
+# before calling :func:`meth.step` at the next step.
+# This is an ideal scenario to showcase all the features of TorchRL's
+# transforms!
+#
+# For instance, in the following transformed environment we ``unsqueeze`` the entries
+# ``["th", "thdot"]`` to be able to stack them along the last
+# dimension. We also pass them as ``in_keys_inv`` to squeeze them back to their
+# original shape once they are passed as input in the next iteration.
+#
+env = TransformedEnv(
+    env,
+    # ``Unsqueeze`` the observations that we will concatenate
+    UnsqueezeTransform(
+        dim=-1,
+        in_keys=["th", "thdot"],
+        in_keys_inv=["th", "thdot"],
+    ),
+)
+
+######################################################################
+# Writing custom transforms
+# ^^^^^^^^^^^^^^^^^^^^^^^^^
+#
+# TorchRL's transforms may not cover all the operations one wants to execute
+# after an environment has been executed.
+# Writing a transform does not require much effort. As for the environment
+# design, there are two steps in writing a transform:
+#
+# - Getting the dynamics right (forward and inverse);
+# - Adapting the environment specs.
+#
+# A transform can be used in two settings: on its own, it can be used as a
+# :class:`~torch.nn.Module`. It can also be used appended to a
+# :class:`~torchrl.envs.transforms.TransformedEnv`. The structure of the class allows to
+# customize the behavior in the different contexts.
+#
+# A :class:`~torchrl.envs.transforms.Transform` skeleton can be summarized as follows:
+#
+# .. code-block::
+#
+#   class Transform(nn.Module):
+#       def forward(self, tensordict):
+#           ...
+#       def _apply_transform(self, tensordict):
+#           ...
+#       def _step(self, tensordict):
+#           ...
+#       def _call(self, tensordict):
+#           ...
+#       def inv(self, tensordict):
+#           ...
+#       def _inv_apply_transform(self, tensordict):
+#           ...
+#
+# There are three entry points (:func:`forward`, :func:`_step` and :func:`inv`)
+# which all receive :class:`tensordict.TensorDict` instances. The first two
+# will eventually go through the keys indicated by :obj:`~tochrl.envs.transforms.Transform.in_keys`
+# and call :meth:`~torchrl.envs.transforms.Transform._apply_transform` to each of these. The results will
+# be written in the entries pointed by :obj:`Transform.out_keys` if provided
+# (if not the ``in_keys`` will be updated with the transformed values).
+# If inverse transforms need to be executed, a similar data flow will be
+# executed but with the :func:`Transform.inv` and
+# :func:`Transform._inv_apply_transform` methods and across the ``in_keys_inv``
+# and ``out_keys_inv`` list of keys.
+# The following figure summarized this flow for environments and replay
+# buffers.
+#
+#
+#    Transform API
+#
+# In some cases, a transform will not work on a subset of keys in a unitary
+# manner, but will execute some operation on the parent environment or
+# work with the entire input ``tensordict``.
+# In those cases, the :func:`_call` and :func:`forward` methods should be
+# re-written, and the :func:`_apply_transform` method can be skipped.
+#
+# Let us code new transforms that will compute the ``sine`` and ``cosine``
+# values of the position angle, as these values are more useful to us to learn
+# a policy than the raw angle value:
+
+
+class SinTransform(Transform):
+    def _apply_transform(self, obs: torch.Tensor) -> None:
+        return obs.sin()
+
+    # The transform must also modify the data at reset time
+    def _reset(
+        self, tensordict: TensorDictBase, tensordict_reset: TensorDictBase
+    ) -> TensorDictBase:
+        return self._call(tensordict_reset)
+
+    # _apply_to_composite will execute the observation spec transform across all
+    # in_keys/out_keys pairs and write the result in the observation_spec which
+    # is of type ``Composite``
+    @_apply_to_composite
+    def transform_observation_spec(self, observation_spec):
+        return BoundedTensorSpec(
+            low=-1,
+            high=1,
+            shape=observation_spec.shape,
+            dtype=observation_spec.dtype,
+            device=observation_spec.device,
+        )
+
+
+class CosTransform(Transform):
+    def _apply_transform(self, obs: torch.Tensor) -> None:
+        return obs.cos()
+
+    # The transform must also modify the data at reset time
+    def _reset(
+        self, tensordict: TensorDictBase, tensordict_reset: TensorDictBase
+    ) -> TensorDictBase:
+        return self._call(tensordict_reset)
+
+    # _apply_to_composite will execute the observation spec transform across all
+    # in_keys/out_keys pairs and write the result in the observation_spec which
+    # is of type ``Composite``
+    @_apply_to_composite
+    def transform_observation_spec(self, observation_spec):
+        return BoundedTensorSpec(
+            low=-1,
+            high=1,
+            shape=observation_spec.shape,
+            dtype=observation_spec.dtype,
+            device=observation_spec.device,
+        )
+
+
+t_sin = SinTransform(in_keys=["th"], out_keys=["sin"])
+t_cos = CosTransform(in_keys=["th"], out_keys=["cos"])
+env.append_transform(t_sin)
+env.append_transform(t_cos)
+
+######################################################################
+# Concatenates the observations onto an "observation" entry.
+# ``del_keys=False`` ensures that we keep these values for the next
+# iteration.
+cat_transform = CatTensors(
+    in_keys=["sin", "cos", "thdot"], dim=-1, out_key="observation", del_keys=False
+)
+env.append_transform(cat_transform)
+
+######################################################################
+# Once more, let us check that our environment specs match what is received:
+check_env_specs(env)
+
+######################################################################
+# Executing a rollout
+# -------------------
+#
+# Executing a rollout is a succession of simple steps:
+#
+# * reset the environment
+# * while some condition is not met:
+#
+#   * compute an action given a policy
+#   * execute a step given this action
+#   * collect the data
+#   * make a ``MDP`` step
+#
+# * gather the data and return
+#
+# These operations have been conveniently wrapped in the :meth:`~torchrl.envs.EnvBase.rollout`
+# method, from which we provide a simplified version here below.
+
+
+def simple_rollout(steps=100):
+    # preallocate:
+    data = TensorDict({}, [steps])
+    # reset
+    _data = env.reset()
+    for i in range(steps):
+        _data["action"] = env.action_spec.rand()
+        _data = env.step(_data)
+        data[i] = _data
+        _data = step_mdp(_data, keep_other=True)
+    return data
+
+
+print("data from rollout:", simple_rollout(100))
+
+######################################################################
+# Batching computations
+# ---------------------
+#
+# The last unexplored end of our tutorial is the ability that we have to
+# batch computations in TorchRL. Because our environment does not
+# make any assumptions regarding the input data shape, we can seamlessly
+# execute it over batches of data. Even better: for non-batch-locked
+# environments such as our Pendulum, we can change the batch size on the fly
+# without recreating the environment.
+# To do this, we just generate parameters with the desired shape.
+#
+
+batch_size = 10  # number of environments to be executed in batch
+td = env.reset(env.gen_params(batch_size=[batch_size]))
+print("reset (batch size of 10)", td)
+td = env.rand_step(td)
+print("rand step (batch size of 10)", td)
+
+######################################################################
+# Executing a rollout with a batch of data requires us to reset the environment
+# out of the rollout function, since we need to define the batch_size
+# dynamically and this is not supported by :meth:`~torchrl.envs.EnvBase.rollout`:
+#
+
+rollout = env.rollout(
+    3,
+    auto_reset=False,  # we're executing the reset out of the ``rollout`` call
+    tensordict=env.reset(env.gen_params(batch_size=[batch_size])),
+)
+print("rollout of len 3 (batch size of 10):", rollout)
+
+
+######################################################################
+# Training a simple policy
+# ------------------------
+#
+# In this example, we will train a simple policy using the reward as a
+# differentiable objective, such as a negative loss.
+# We will take advantage of the fact that our dynamic system is fully
+# differentiable to backpropagate through the trajectory return and adjust the
+# weights of our policy to maximize this value directly. Of course, in many
+# settings many of the assumptions we make do not hold, such as
+# differentiable system and full access to the underlying mechanics.
+#
+# Still, this is a very simple example that showcases how a training loop can
+# be coded with a custom environment in TorchRL.
+#
+# Let us first write the policy network:
+#
+torch.manual_seed(0)
+env.set_seed(0)
+
+net = nn.Sequential(
+    nn.LazyLinear(64),
+    nn.Tanh(),
+    nn.LazyLinear(64),
+    nn.Tanh(),
+    nn.LazyLinear(64),
+    nn.Tanh(),
+    nn.LazyLinear(1),
+)
+policy = TensorDictModule(
+    net,
+    in_keys=["observation"],
+    out_keys=["action"],
+)
+
+######################################################################
+# and our optimizer:
+#
+
+optim = torch.optim.Adam(policy.parameters(), lr=2e-3)
+
+######################################################################
+# Training loop
+# ^^^^^^^^^^^^^
+#
+# We will successively:
+#
+# * generate a trajectory
+# * sum the rewards
+# * backpropagate through the graph defined by these operations
+# * clip the gradient norm and make an optimization step
+# * repeat
+#
+# At the end of the training loop, we should have a final reward close to 0
+# which demonstrates that the pendulum is upward and still as desired.
+#
+batch_size = 32
+pbar = tqdm.tqdm(range(20_000 // batch_size))
+scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optim, 20_000)
+logs = defaultdict(list)
+
+for _ in pbar:
+    init_td = env.reset(env.gen_params(batch_size=[batch_size]))
+    rollout = env.rollout(100, policy, tensordict=init_td, auto_reset=False)
+    traj_return = rollout["next", "reward"].mean()
+    (-traj_return).backward()
+    gn = torch.nn.utils.clip_grad_norm_(net.parameters(), 1.0)
+    optim.step()
+    optim.zero_grad()
+    pbar.set_description(
+        f"reward: {traj_return: 4.4f}, "
+        f"last reward: {rollout[..., -1]['next', 'reward'].mean(): 4.4f}, gradient norm: {gn: 4.4}"
+    )
+    logs["return"].append(traj_return.item())
+    logs["last_reward"].append(rollout[..., -1]["next", "reward"].mean().item())
+    scheduler.step()
+
+
+def plot():
+    import matplotlib
+    from matplotlib import pyplot as plt
+
+    is_ipython = "inline" in matplotlib.get_backend()
+    if is_ipython:
+        from IPython import display
+
+    with plt.ion():
+        plt.figure(figsize=(10, 5))
+        plt.subplot(1, 2, 1)
+        plt.plot(logs["return"])
+        plt.title("returns")
+        plt.xlabel("iteration")
+        plt.subplot(1, 2, 2)
+        plt.plot(logs["last_reward"])
+        plt.title("last reward")
+        plt.xlabel("iteration")
+        if is_ipython:
+            display.display(plt.gcf())
+            display.clear_output(wait=True)
+        plt.show()
+
+
+plot()
+
+
+######################################################################
+# Conclusion
+# ----------
+#
+# In this tutorial, we have learned how to code a stateless environment from
+# scratch. We touched the subjects of:
+#
+# * The four essential components that need to be taken care of when coding
+#   an environment (``step``, ``reset``, seeding and building specs).
+#   We saw how these methods and classes interact with the
+#   :class:`~tensordict.TensorDict` class;
+# * How to test that an environment is properly coded using
+#   :func:`~torchrl.envs.utils.check_env_specs`;
+# * How to append transforms in the context of stateless environments and how
+#   to write custom transformations;
+# * How to train a policy on a fully differentiable simulator.
+#
diff --git a/advanced_source/privateuseone.rst b/advanced_source/privateuseone.rst
new file mode 100644
index 00000000000..5b5b37c20e2
--- /dev/null
+++ b/advanced_source/privateuseone.rst
@@ -0,0 +1,309 @@
+Facilitating New Backend Integration by PrivateUse1
+===================================================
+
+In this tutorial we will walk through some necessary steps to integrate a new backend
+living outside ``pytorch/pytorch`` repo by ``PrivateUse1``. Note that this tutorial assumes that
+you already have a basic understanding of PyTorch.
+you are an advanced user of PyTorch.
+
+.. note::
+
+   This tutorial only involves the parts related to the PrivateUse1 mechanism that facilitates the integration of new devices,
+   and other parts will not be covered. At the same time, not all the modules involved in this tutorial are required,
+   and you can choose the modules that are helpful to you according to your actual needs.
+
+
+What is PrivateUse1?
+--------------------
+
+Prior to Pytorch 2.0, PyTorch provided three reserved dispatch keys (and their corresponding Autograd keys)
+for prototyping out-of-tree backend extensions, the three dispatch keys are as follows:
+
+* ``PrivateUse1/AutogradPrivateUse1``
+* ``PrivateUse2/AutogradPrivateUse2``
+* ``PrivateUse3/AutogradPrivateUse3``
+
+After the prototype verification is passed, you can apply for a private key for the new backend, such as CUDA, XLA, MPS, and so on.
+
+However, with the rapid development of PyTorch, more and more hardware manufacturers are trying to
+integrate their backends into PyTorch, which might cause the following problems:
+
+* Every new backend integration involves a lot of file modification
+* There is currently a hard limit on the number of Dispatch Keys (``DispatchKeySet`` 64-bit limit)
+
+.. note::
+
+   There is also a problem with integrating the new backend into PyTorch through the PrivateUse1 Key, as it is impossible
+   to integrate many backends at the same time. Fortunately, these out-of-tree backends are rarely used simultaneously.
+
+
+In view of the above reasons, the community began to recommend new backend to be integrated
+into the PyTorch via ``PrivateUse1``.
+
+However, the previous ``PrivateUse1`` mechanism is not fully capable of integrating with the new backend, because it
+lacks some related support in certain modules, such as Storage, AMP, Distributed, and so on.
+
+With the arrival of Pytorch 2.1.0, a series of optimizations and enhancements have been made
+for ``PrivateUse1`` in terms of new backend integration, and it is now possible to support the integration
+of new devices rapidly and efficiently.
+
+How to integrate new backend via PrivateUse1
+--------------------------------------------
+
+In this section, we will discuss the details of integrating the new backend into Pytorch via ``PrivateUse1``,
+which mainly consists of the following parts:
+
+1. Register kernels for the new backend.
+2. Register generator for the new backend.
+3. Register device guard for the new backend.
+4. Register serialization and deserialization functions for new backend metadata.
+5. Other Modules.
+
+Register kernels for the new backend
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The new backend may have some high-performance implementations of operator, which can be registered to the dispatcher
+by ``TORCH_LIBRARY_IMPL`` API described in `Registering a Dispatched Operator in C++ <dispatcher>`_. This involves
+several situations:
+
+1. Register all the forward operators supported by the new backend to the dispatcher, and register the fallback
+   at the same time, so that when the new backend does not support some operators, these operators can fall back
+   to the CPU for execution to ensure the availability of functions.
+
+.. code-block:: cpp
+
+  at::Tensor wrapper_Custom_Tensor_add(const at::Tensor & self, const at::Tensor & other, const at::Scalar & alpha) {
+    // Implementation of add kernel in new backend
+    ...
+  }
+
+  TORCH_LIBRARY_IMPL(aten, PrivateUse1, m) {
+    ...
+    m.impl("add.Tensor", TORCH_FN(wrapper_Custom_Tensor_add));
+    ...
+  }
+
+  void custom_cpu_fallback(const c10::OperatorHandle& op, torch::jit::Stack* stack) {
+    // Add some hints about new devices that do not support and need to fall back to cpu
+    at::native::cpu_fallback(op, stack);
+  }
+
+  TORCH_LIBRARY_IMPL(_, PrivateUse1, m) {
+    m.fallback(torch::CppFunction::makeFromBoxedFunction<&custom_cpu_fallback>());
+  }
+
+2. Register kernels from ``torch::autograd::Function`` to the dispatcher by ``AutogradPrivateUse1``, if it is necessary for
+   new backend to override ``PyTorch Autograd layer``, the dispatcher and autograd system will automatically call the forward and
+   backward implementations of these operators.
+
+.. code-block:: cpp
+
+  class CumtomSeluFunction : public torch::autograd::Function<CumtomSeluFunction> {
+    // Implementation of selu kernel in new backend
+  }
+
+  at::Tensor wrapper_AutogradCumstom__selu(const at::Tensor & self) {
+    return CumtomSeluFunction::apply(self);
+  }
+
+  TORCH_LIBRARY_IMPL(aten, AutogradPrivateUse1, m) {
+    ...
+    m.impl("selu", TORCH_FN(wrapper_AutogradCustom__selu));
+    ...
+  }
+
+3. Register kernels which want to support `automatic mixed precision (AMP) <https://pytorch.org/docs/stable/amp.html>`_ and
+   fallback mechanism to the dispatcher by ``AutocastPrivateUse1``, the autocast system will automatically call these kernels when needed.
+
+.. code-block:: cpp
+
+  TORCH_LIBRARY_IMPL(aten, AutocastPrivateUse1, m) {
+    ...
+    KERNEL_PRIVATEUSEONE(<operator>, <policy>)
+    ...
+  }
+
+  TORCH_LIBRARY_IMPL(_, AutocastPrivateUse1, m) {
+    m.fallback(torch::CppFunction::makeFallthrough());
+  }
+
+What needs to be added is that if you want to support AMP in a new backend, you need to register a new ``BackendModule`` by
+``torch._register_device_module("backend_name", BackendModule)``, and the ``BackendModule`` needs to have the following APIs:
+
+* ``get_amp_supported_dtype() -> List[torch.dtype]``
+    get the supported dtypes on the new backend in AMP, which might support one more ``dtype``.
+* ``is_autocast_enabled() -> bool``
+    check the AMP is enabled or not on the new backend.
+* ``get_autocast_dtype() -> torch.dtype``
+    get the supported ``dtype`` on the new backend in AMP, which is set by ``set_autocast_dtype`` or the
+    default ``dtype``, and the default ``dtype`` is ``torch.float16``.
+* ``set_autocast_enabled(bool) -> None``
+    enable or disable AMP on the new backend.
+* ``set_autocast_dtype(dtype) -> None``
+    set the supported ``dtype`` on the new backend in AMP, and the ``dtype`` be contained in the ``dtypes`` got
+    from ``get_amp_supported_dtype``.
+
+Register generator for the new backend
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+It is necessary to support generators corresponding to new devices. Currently, ``PrivateUse1`` can dynamically
+register custom generators, which are mainly divided into the following steps.
+
+1. Inherit the ``GeneratorImpl`` class to implement the generator class corresponding to the new backend,
+   and implement various general methods.
+2. Define a new backend ``builder`` with a single parameter: ``device index``.
+3. Call ``REGISTER_GENERATOR_PRIVATEUSE1`` macro to complete dynamic registration.
+
+.. code-block:: cpp
+
+  struct CustomGeneratorImpl : public c10::GeneratorImpl {
+    // Implementation of generator in new backend
+  }
+
+  at::Generator make_custom_generator(c10::DeviceIndex device_index) {
+    return at::make_generator<CustomGeneratorImpl>(device_index);
+  }
+
+  REGISTER_GENERATOR_PRIVATEUSE1(make_cumstom_generator)
+
+Register device guard for the new backend
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+PyTorch provides functionalities related to device, stream, and event switching via ``DeviceGuard``.
+This function is also applicable to ``PrivateUse1`` Key.
+
+1. Inherit the ``DeviceGuardImplInterface`` class to implement the various general methods corresponding to the new backend.
+2. Call ``C10_REGISTER_GUARD_IMPL`` macro to complete dynamic registration.
+
+.. code-block:: cpp
+
+  struct CustomGuardImpl final : public c10::impl::DeviceGuardImplInterface {
+    // Implementation of guard in new backend
+  }
+
+  C10_REGISTER_GUARD_IMPL(PrivateUse1, CustomGuardImpl);
+
+Register serialization and deserialization functions for new backend metadata
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+PyTorch is currently able to dynamically register serialization/deserialization functions to support the serialization and deserialization
+of new backend additional metadata named ``backend_meta_`` in class ``TensorImpl.ExtraMeta``. You can refer to the following steps:
+
+1. Inherit the ``BackendMeta`` class to implement ``CustomBackendMetadata`` corresponding to the new backend and
+   various fields of the new backend can be customized in the class.
+2. Implement the serialization and deserialization functions of the new backend, the function signatures are 
+   ``void(const at::Tensor&, std::unordered_map<std::string, bool>&)``.
+3. Call the ``TensorBackendMetaRegistry`` macro to complete dynamic registration.
+
+.. code-block:: cpp
+
+  struct CustomBackendMetadata : public c10::BackendMeta {
+    // Implementation of backend metadata in new backend
+  }
+
+  void for_serialization(const at::Tensor& t, std::unordered_map<std::string, bool>& m) {
+    // Implementation of serialization
+  }
+
+  void for_deserialization(const at::Tensor& t, std::unordered_map<std::string, bool>& m) {
+    // Implementation of deserialization
+  }
+
+  TensorBackendMetaRegistry(c10::DeviceType::PrivateUse1, &for_serialization, &for_deserialization);
+
+Other Modules
+^^^^^^^^^^^^^
+
+In addition to the above-mentioned parts, there are some other modules that can be expanded through ``PrivateUse1``,
+such as ``distributed collective communication``, ``benchmark timer``, and others, which will be added in the future.
+One example about ``PrivateUse1`` integration is `Ascend NPU <https://github.com/ascend/pytorch>`_.
+
+
+How to Improve User Experience with Privateuse1
+-----------------------------------------------
+
+The primary goal of integrating new devices through ``PrivateUse1`` is to meet the basic functional requirements,
+and the next thing to do is to improve usability, which mainly involves the following aspects.
+
+1. Register new backend module to Pytorch.
+2. Rename PrivateUse1 to a custom name for the new backend.
+3. Generate methods and properties related to the new backend.
+
+Register new backend module to Pytorch
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Some CUDA-related interfaces in PyTorch can be called through the following form: ``torch.cuda.xxx``. Therefore, in order to
+comply with user habits, the new backend implemented through the ``PrivateUse1`` mechanism should also provide similar interfaces.
+
+For example, using ``Ascend NPU``:
+
+.. code-block:: python
+
+  torch._register_device_module('npu', torch_npu.npu)
+
+After doing the above operations, users can call some exclusive APIs of ``Ascend NPU`` through ``torch.npu.xxx``
+
+Rename PrivateUse1 to a custom name for the new backend
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+``PrivateUse1`` Key is the internal mechanism of the new backend integrated into PyTorch. For users, compared with ``PrivateUse1``,
+the custom name strongly related to the new backend should be more friendly.
+
+Taking the ``Ascend NPU`` as an example, the first usage will be more user-friendly.
+
+.. code-block:: python
+
+  torch.rand((2,2),device='npu:0')
+  torch.rand((2,2),device='privateuse1:0')
+
+Now, PyTorch provides a new C++/Python API for the self-named ``PrivateUse1`` backend, which is very simple to use.
+
+.. tab-set-code::
+
+  .. code-block:: python
+
+      torch.rename_privateuse1_backend("npu")
+
+  .. code-block:: C++
+
+      c10::register_privateuse1_backend("npu")
+
+Generate methods and properties related to the new backend
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+After renaming ``PrivateUse1`` to a custome name, automatically generate properties and methods related to the new backend name
+in the ``Tensor, nn, Storage`` modules for the new backend.
+
+Here is an example for ``Ascend NPU``:
+
+.. code-block:: python
+
+  torch.rename_privateuse1_backend("npu")
+  unsupported_dtype = [torch.quint8]
+  torch.utils.generate_methods_for_privateuse1_backend(for_tensor=True, for_module=True, for_storage=True, unsupported_dtype=unsupported_dtype)
+
+Then, you can use the following methods and properties:
+
+.. code-block:: python
+
+  torch.Tensor.npu()
+  torch.Tensor.is_npu
+  torch.Storage.npu()
+  torch.Storage.is_npu
+  ...
+
+Future Work
+-----------
+
+The improvement of the ``PrivateUse1`` mechanism is still in progress, so the integration method of ``PrivateUse1``
+of the new module will be added in turn. Here are a few items that we are actively working on:
+
+* Add the integration method of ``distributed collective communication``.
+* Add the integration method of ``benchmark timer``.
+
+Conclusion
+----------
+
+This tutorial walked you through the process of integrating new backends into PyTorch via ``PrivateUse1``, including but not limited to
+operator registration, generator registration, device guard registration, and so on. At the same time, some methods are introduced
+to improve the user experience.
diff --git a/advanced_source/python_custom_ops.py b/advanced_source/python_custom_ops.py
new file mode 100644
index 00000000000..1f20125f785
--- /dev/null
+++ b/advanced_source/python_custom_ops.py
@@ -0,0 +1,278 @@
+# -*- coding: utf-8 -*-
+
+"""
+.. _python-custom-ops-tutorial:
+
+Custom Python Operators
+=======================
+
+.. grid:: 2
+
+    .. grid-item-card:: :octicon:`mortar-board;1em;` What you will learn
+       :class-card: card-prerequisites
+
+       * How to integrate custom operators written in Python with PyTorch
+       * How to test custom operators using ``torch.library.opcheck``
+
+    .. grid-item-card:: :octicon:`list-unordered;1em;` Prerequisites
+       :class-card: card-prerequisites
+
+       * PyTorch 2.4 or later
+
+PyTorch offers a large library of operators that work on Tensors (e.g.
+``torch.add``, ``torch.sum``, etc). However, you might wish to use a new customized
+operator with PyTorch, perhaps written by a third-party library. This tutorial
+shows how to wrap Python functions so that they behave like PyTorch native
+operators. Reasons why you may wish to create a custom operator in PyTorch include:
+
+- Treating an arbitrary Python function as an opaque callable with respect
+  to ``torch.compile`` (that is, prevent ``torch.compile`` from tracing
+  into the function).
+- Adding training support to an arbitrary Python function
+
+Use :func:`torch.library.custom_op` to create Python custom operators.
+Use the C++ ``TORCH_LIBRARY`` APIs to create C++ custom operators (these
+work in Python-less environments).
+See the `Custom Operators Landing Page <https://pytorch.org/tutorials/advanced/custom_ops_landing_page.html>`_
+for more details.
+
+Please note that if your operation can be expressed as a composition of
+existing PyTorch operators, then there is usually no need to use the custom operator
+API -- everything (for example ``torch.compile``, training support) should
+just work.
+"""
+######################################################################
+# Example: Wrapping PIL's crop into a custom operator
+# ------------------------------------
+# Let's say that we are using PIL's ``crop`` operation.
+
+import torch
+from torchvision.transforms.functional import to_pil_image, pil_to_tensor
+import PIL
+import IPython
+import matplotlib.pyplot as plt
+
+def crop(pic, box):
+    img = to_pil_image(pic.cpu())
+    cropped_img = img.crop(box)
+    return pil_to_tensor(cropped_img).to(pic.device) / 255.
+
+def display(img):
+    plt.imshow(img.numpy().transpose((1, 2, 0)))
+
+img = torch.ones(3, 64, 64)
+img *= torch.linspace(0, 1, steps=64) * torch.linspace(0, 1, steps=64).unsqueeze(-1)
+display(img)
+
+######################################################################
+
+cropped_img = crop(img, (10, 10, 50, 50))
+display(cropped_img)
+
+######################################################################
+# ``crop`` is not handled effectively out-of-the-box by
+# ``torch.compile``: ``torch.compile`` induces a
+# `"graph break" <https://pytorch.org/docs/stable/torch.compiler_faq.html#graph-breaks>`_
+# on functions it is unable to handle and graph breaks are bad for performance.
+# The following code demonstrates this by raising an error
+# (``torch.compile`` with ``fullgraph=True`` raises an error if a
+# graph break occurs).
+
+@torch.compile(fullgraph=True)
+def f(img):
+    return crop(img, (10, 10, 50, 50))
+
+# The following raises an error. Uncomment the line to see it.
+# cropped_img = f(img)
+
+######################################################################
+# In order to black-box ``crop`` for use with ``torch.compile``, we need to
+# do two things:
+#
+# 1. wrap the function into a PyTorch custom operator.
+# 2. add a "``FakeTensor`` kernel" (aka "meta kernel") to the operator.
+#    Given some ``FakeTensors`` inputs (dummy Tensors that don't have storage),
+#    this function should return dummy Tensors of your choice with the correct
+#    Tensor metadata (shape/strides/``dtype``/device).
+
+
+from typing import Sequence
+
+# Use torch.library.custom_op to define a new custom operator.
+# If your operator mutates any input Tensors, their names must be specified
+# in the ``mutates_args`` argument.
+@torch.library.custom_op("mylib::crop", mutates_args=())
+def crop(pic: torch.Tensor, box: Sequence[int]) -> torch.Tensor:
+    img = to_pil_image(pic.cpu())
+    cropped_img = img.crop(box)
+    return (pil_to_tensor(cropped_img) / 255.).to(pic.device, pic.dtype)
+
+# Use register_fake to add a ``FakeTensor`` kernel for the operator
+@crop.register_fake
+def _(pic, box):
+    channels = pic.shape[0]
+    x0, y0, x1, y1 = box
+    result = pic.new_empty(y1 - y0, x1 - x0, channels).permute(2, 0, 1)
+    # The result should have the same metadata (shape/strides/``dtype``/device)
+    # as running the ``crop`` function above.
+    return result
+
+######################################################################
+# After this, ``crop`` now works without graph breaks:
+
+@torch.compile(fullgraph=True)
+def f(img):
+    return crop(img, (10, 10, 50, 50))
+
+cropped_img = f(img)
+display(img)
+
+######################################################################
+
+display(cropped_img)
+
+######################################################################
+# Adding training support for crop
+# --------------------------------
+# Use ``torch.library.register_autograd`` to add training support for an operator.
+# Prefer this over directly using ``torch.autograd.Function``; some compositions of
+# ``autograd.Function`` with PyTorch operator registration APIs can lead to (and
+# has led to) silent incorrectness when composed with ``torch.compile``.
+#
+# If you don't need training support, there is no need to use
+# ``torch.library.register_autograd``.
+# If you end up training with a ``custom_op`` that doesn't have an autograd
+# registration, we'll raise an error message.
+#
+# The gradient formula for ``crop`` is essentially ``PIL.paste`` (we'll leave the
+# derivation as an exercise to the reader). Let's first wrap ``paste`` into a
+# custom operator:
+
+@torch.library.custom_op("mylib::paste", mutates_args=())
+def paste(im1: torch.Tensor, im2: torch.Tensor, coord: Sequence[int]) -> torch.Tensor:
+    assert im1.device == im2.device
+    assert im1.dtype == im2.dtype
+    im1_pil = to_pil_image(im1.cpu())
+    im2_pil = to_pil_image(im2.cpu())
+    PIL.Image.Image.paste(im1_pil, im2_pil, coord)
+    return (pil_to_tensor(im1_pil) / 255.).to(im1.device, im1.dtype)
+
+@paste.register_fake
+def _(im1, im2, coord):
+    assert im1.device == im2.device
+    assert im1.dtype == im2.dtype
+    return torch.empty_like(im1)
+
+######################################################################
+# And now let's use ``register_autograd`` to specify the gradient formula for ``crop``:
+
+def backward(ctx, grad_output):
+    grad_input = grad_output.new_zeros(ctx.pic_shape)
+    grad_input = paste(grad_input, grad_output, ctx.coords)
+    return grad_input, None
+
+def setup_context(ctx, inputs, output):
+    pic, box = inputs
+    ctx.coords = box[:2]
+    ctx.pic_shape = pic.shape
+
+crop.register_autograd(backward, setup_context=setup_context)
+
+######################################################################
+# Note that the backward must be a composition of PyTorch-understood operators,
+# which is why we wrapped paste into a custom operator instead of directly using
+# PIL's paste.
+
+img = img.requires_grad_()
+result = crop(img, (10, 10, 50, 50))
+result.sum().backward()
+display(img.grad)
+
+######################################################################
+# This is the correct gradient, with 1s (white) in the cropped region and 0s
+# (black) in the unused region.
+
+######################################################################
+# Testing Python Custom operators
+# -------------------------------
+# Use ``torch.library.opcheck`` to test that the custom operator was registered
+# correctly. This does not test that the gradients are mathematically correct;
+# please write separate tests for that (either manual ones or ``torch.autograd.gradcheck``).
+#
+# To use ``opcheck``, pass it a set of example inputs to test against. If your
+# operator supports training, then the examples should include Tensors that
+# require grad. If your operator supports multiple devices, then the examples
+# should include Tensors from each device.
+
+examples = [
+    [torch.randn(3, 64, 64), [0, 0, 10, 10]],
+    [torch.randn(3, 91, 91, requires_grad=True), [10, 0, 20, 10]],
+    [torch.randn(3, 60, 60, dtype=torch.double), [3, 4, 32, 20]],
+    [torch.randn(3, 512, 512, requires_grad=True, dtype=torch.double), [3, 4, 32, 45]],
+]
+
+for example in examples:
+    torch.library.opcheck(crop, example)
+
+######################################################################
+# Mutable Python Custom operators
+# -------------------------------
+# You can also wrap a Python function that mutates its inputs into a custom
+# operator.
+# Functions that mutate inputs are common because that is how many low-level
+# kernels are written; for example, a kernel that computes ``sin`` may take in
+# the input and an output tensor and write ``input.sin()`` to the output tensor.
+#
+# We'll use ``numpy.sin`` to demonstrate an example of a mutable Python
+# custom operator.
+
+import numpy as np
+
+@torch.library.custom_op("mylib::numpy_sin", mutates_args={"output"}, device_types="cpu")
+def numpy_sin(input: torch.Tensor, output: torch.Tensor) -> None:
+    assert input.device == output.device
+    assert input.device.type == "cpu"
+    input_np = input.numpy()
+    output_np = output.numpy()
+    np.sin(input_np, out=output_np)
+
+######################################################################
+# Because the operator doesn't return anything, there is no need to register
+# a ``FakeTensor`` kernel (meta kernel) to get it to work with ``torch.compile``.
+
+@torch.compile(fullgraph=True)
+def f(x):
+    out = torch.empty(3)
+    numpy_sin(x, out)
+    return out
+
+x = torch.randn(3)
+y = f(x)
+assert torch.allclose(y, x.sin())
+
+######################################################################
+# And here's an ``opcheck`` run telling us that we did indeed register the operator correctly.
+# ``opcheck`` would error out if we forgot to add the output to ``mutates_args``, for example.
+
+example_inputs = [
+    [torch.randn(3), torch.empty(3)],
+    [torch.randn(0, 3), torch.empty(0, 3)],
+    [torch.randn(1, 2, 3, 4, dtype=torch.double), torch.empty(1, 2, 3, 4, dtype=torch.double)],
+]
+
+for example in example_inputs:
+    torch.library.opcheck(numpy_sin, example)
+
+######################################################################
+# Conclusion
+# ----------
+# In this tutorial, we learned how to use ``torch.library.custom_op`` to
+# create a custom operator in Python that works with PyTorch subsystems
+# such as ``torch.compile`` and autograd.
+#
+# This tutorial provides a basic introduction to custom operators.
+# For more detailed information, see:
+#
+# - `the torch.library documentation <https://pytorch.org/docs/stable/library.html>`_
+# - `the Custom Operators Manual <https://pytorch.org/tutorials/advanced/custom_ops_landing_page.html#the-custom-operators-manual>`_
+#
diff --git a/advanced_source/rpc_ddp_tutorial.rst b/advanced_source/rpc_ddp_tutorial.rst
new file mode 100644
index 00000000000..5c7aeffb2f9
--- /dev/null
+++ b/advanced_source/rpc_ddp_tutorial.rst
@@ -0,0 +1,162 @@
+Combining Distributed DataParallel with Distributed RPC Framework
+=================================================================
+**Authors**: `Pritam Damania <https://github.com/pritamdamania87>`_ and `Yi Wang <https://github.com/wayi1>`_
+
+.. note::
+   |edit| View and edit this tutorial in `github <https://github.com/pytorch/tutorials/blob/main/advanced_source/rpc_ddp_tutorial.rst>`__.
+
+This tutorial uses a simple example to demonstrate how you can combine
+`DistributedDataParallel <https://pytorch.org/docs/stable/nn.html#torch.nn.parallel.DistributedDataParallel>`__ (DDP)
+with the `Distributed RPC framework <https://pytorch.org/docs/master/rpc.html>`__
+to combine distributed data parallelism with distributed model parallelism to
+train a simple model. Source code of the example can be found `here <https://github.com/pytorch/examples/tree/master/distributed/rpc/ddp_rpc>`__.
+
+Previous tutorials,
+`Getting Started With Distributed Data Parallel <https://pytorch.org/tutorials/intermediate/ddp_tutorial.html>`__
+and `Getting Started with Distributed RPC Framework <https://pytorch.org/tutorials/intermediate/rpc_tutorial.html>`__,
+described how to perform distributed data parallel and distributed model
+parallel training respectively. Although, there are several training paradigms
+where you might want to combine these two techniques. For example:
+
+1) If we have a model with a sparse part (large embedding table) and a dense
+   part (FC layers), we might want to put the embedding table on a parameter
+   server and replicate the FC layer across multiple trainers using `DistributedDataParallel <https://pytorch.org/docs/stable/nn.html#torch.nn.parallel.DistributedDataParallel>`__.
+   The `Distributed RPC framework <https://pytorch.org/docs/master/rpc.html>`__
+   can be used to perform embedding lookups on the parameter server.
+2) Enable hybrid parallelism as described in the `PipeDream <https://arxiv.org/abs/1806.03377>`__ paper.
+   We can use the `Distributed RPC framework <https://pytorch.org/docs/master/rpc.html>`__
+   to pipeline stages of the model across multiple workers and replicate each
+   stage (if needed) using `DistributedDataParallel <https://pytorch.org/docs/stable/nn.html#torch.nn.parallel.DistributedDataParallel>`__.
+
+|
+In this tutorial we will cover case 1 mentioned above. We have a total of 4
+workers in our setup as follows:
+
+
+1) 1 Master, which is responsible for creating an embedding table
+   (nn.EmbeddingBag) on the parameter server. The master also drives the
+   training loop on the two trainers.
+2) 1 Parameter Server, which basically holds the embedding table in memory and
+   responds to RPCs from the Master and Trainers.
+3) 2 Trainers, which store an FC layer (nn.Linear) which is replicated amongst
+   themselves using `DistributedDataParallel <https://pytorch.org/docs/stable/nn.html#torch.nn.parallel.DistributedDataParallel>`__.
+   The trainers are also responsible for executing the forward pass, backward
+   pass and optimizer step.
+
+|
+The entire training process is executed as follows:
+
+1) The master creates a `RemoteModule <https://pytorch.org/docs/master/rpc.html#remotemodule>`__
+   that holds an embedding table on the Parameter Server.
+2) The master, then kicks off the training loop on the trainers and passes the
+   remote module to the trainers.
+3) The trainers create a ``HybridModel`` which first performs an embedding lookup
+   using the remote module provided by the master and then executes the
+   FC layer which is wrapped inside DDP.
+4) The trainer executes the forward pass of the model and uses the loss to
+   execute the backward pass using `Distributed Autograd <https://pytorch.org/docs/master/rpc.html#distributed-autograd-framework>`__.
+5) As part of the backward pass, the gradients for the FC layer are computed
+   first and synced to all trainers via allreduce in DDP.
+6) Next, Distributed Autograd propagates the gradients to the parameter server,
+   where the gradients for the embedding table are updated.
+7) Finally, the `Distributed Optimizer <https://pytorch.org/docs/master/rpc.html#module-torch.distributed.optim>`__ is used to update all the parameters.
+
+
+.. attention::
+
+  You should always use `Distributed Autograd <https://pytorch.org/docs/master/rpc.html#distributed-autograd-framework>`__
+  for the backward pass if you're combining DDP and RPC.
+
+
+Now, let's go through each part in detail. Firstly, we need to setup all of our
+workers before we can perform any training. We create 4 processes such that
+ranks 0 and 1 are our trainers, rank 2 is the master and rank 3 is the
+parameter server.
+
+We initialize the RPC framework on all 4 workers using the TCP init_method.
+Once RPC initialization is done, the master creates a remote module that holds an `EmbeddingBag <https://pytorch.org/docs/master/generated/torch.nn.EmbeddingBag.html>`__
+layer on the Parameter Server using `RemoteModule <https://pytorch.org/docs/master/rpc.html#torch.distributed.nn.api.remote_module.RemoteModule>`__.
+The master then loops through each trainer and kicks off the training loop by
+calling ``_run_trainer`` on each trainer using `rpc_async <https://pytorch.org/docs/master/rpc.html#torch.distributed.rpc.rpc_async>`__.
+Finally, the master waits for all training to finish before exiting.
+
+The trainers first initialize a ``ProcessGroup`` for DDP with world_size=2
+(for two trainers) using `init_process_group <https://pytorch.org/docs/stable/distributed.html#torch.distributed.init_process_group>`__.
+Next, they initialize the RPC framework using the TCP init_method. Note that
+the ports are different in RPC initialization and ProcessGroup initialization.
+This is to avoid port conflicts between initialization of both frameworks.
+Once the initialization is done, the trainers just wait for the ``_run_trainer``
+RPC from the master.
+
+The parameter server just initializes the RPC framework and waits for RPCs from
+the trainers and master.
+
+
+.. literalinclude:: ../advanced_source/rpc_ddp_tutorial/main.py
+  :language: py
+  :start-after: BEGIN run_worker
+  :end-before: END run_worker
+
+Before we discuss details of the Trainer, let's introduce the ``HybridModel`` that
+the trainer uses. As described below, the ``HybridModel`` is initialized using a
+remote module that holds an embedding table (``remote_emb_module``) on the parameter server and the ``device``
+to use for DDP. The initialization of the model wraps an
+`nn.Linear <https://pytorch.org/docs/master/generated/torch.nn.Linear.html>`__
+layer inside DDP to replicate and synchronize this layer across all trainers.
+
+The forward method of the model is pretty straightforward. It performs an
+embedding lookup on the parameter server using RemoteModule's ``forward``
+and passes its output onto the FC layer.
+
+
+.. literalinclude:: ../advanced_source/rpc_ddp_tutorial/main.py
+  :language: py
+  :start-after: BEGIN hybrid_model
+  :end-before: END hybrid_model
+
+Next, let's look at the setup on the Trainer. The trainer first creates the
+``HybridModel`` described above using a remote module that holds the embedding table on the
+parameter server and its own rank.
+
+Now, we need to retrieve a list of RRefs to all the parameters that we would
+like to optimize with `DistributedOptimizer <https://pytorch.org/docs/master/rpc.html#module-torch.distributed.optim>`__.
+To retrieve the parameters for the embedding table from the parameter server,
+we can call RemoteModule's `remote_parameters <https://pytorch.org/docs/master/rpc.html#torch.distributed.nn.api.remote_module.RemoteModule.remote_parameters>`__,
+which basically walks through all the parameters for the embedding table and returns
+a list of RRefs. The trainer calls this method on the parameter server via RPC
+to receive a list of RRefs to the desired parameters. Since the
+DistributedOptimizer always takes a list of RRefs to parameters that need to
+be optimized, we need to create RRefs even for the local parameters for our
+FC layers. This is done by walking ``model.fc.parameters()``, creating an RRef for
+each parameter and appending it to the list returned from ``remote_parameters()``.
+Note that we cannnot use ``model.parameters()``,
+because it will recursively call ``model.remote_emb_module.parameters()``,
+which is not supported by ``RemoteModule``.
+
+Finally, we create our DistributedOptimizer using all the RRefs and define a
+CrossEntropyLoss function.
+
+.. literalinclude:: ../advanced_source/rpc_ddp_tutorial/main.py
+  :language: py
+  :start-after: BEGIN setup_trainer
+  :end-before: END setup_trainer
+
+Now we're ready to introduce the main training loop that is run on each trainer.
+``get_next_batch`` is just a helper function to generate random inputs and
+targets for training. We run the training loop for multiple epochs and for each
+batch:
+
+1) Setup a `Distributed Autograd Context <https://pytorch.org/docs/master/rpc.html#torch.distributed.autograd.context>`__
+   for Distributed Autograd.
+2) Run the forward pass of the model and retrieve its output.
+3) Compute the loss based on our outputs and targets using the loss function.
+4) Use Distributed Autograd to execute a distributed backward pass using the loss.
+5) Finally, run a Distributed Optimizer step to optimize all the parameters.
+
+.. literalinclude:: ../advanced_source/rpc_ddp_tutorial/main.py
+  :language: py
+  :start-after: BEGIN run_trainer
+  :end-before: END run_trainer
+.. code:: python
+
+Source code for the entire example can be found `here <https://github.com/pytorch/examples/tree/master/distributed/rpc/ddp_rpc>`__.
diff --git a/advanced_source/rpc_ddp_tutorial/main.py b/advanced_source/rpc_ddp_tutorial/main.py
new file mode 100644
index 00000000000..459741ff0f4
--- /dev/null
+++ b/advanced_source/rpc_ddp_tutorial/main.py
@@ -0,0 +1,185 @@
+import random
+
+import torch
+import torch.distributed as dist
+import torch.distributed.autograd as dist_autograd
+import torch.distributed.rpc as rpc
+import torch.multiprocessing as mp
+import torch.optim as optim
+from torch.distributed.nn import RemoteModule
+from torch.distributed.optim import DistributedOptimizer
+from torch.distributed.rpc import RRef
+from torch.distributed.rpc import TensorPipeRpcBackendOptions
+from torch.nn.parallel import DistributedDataParallel as DDP
+
+NUM_EMBEDDINGS = 100
+EMBEDDING_DIM = 16
+
+# BEGIN hybrid_model
+class HybridModel(torch.nn.Module):
+    r"""
+    The model consists of a sparse part and a dense part.
+    1) The dense part is an nn.Linear module that is replicated across all trainers using DistributedDataParallel.
+    2) The sparse part is a Remote Module that holds an nn.EmbeddingBag on the parameter server.
+    This remote model can get a Remote Reference to the embedding table on the parameter server.
+    """
+
+    def __init__(self, remote_emb_module, device):
+        super(HybridModel, self).__init__()
+        self.remote_emb_module = remote_emb_module
+        self.fc = DDP(torch.nn.Linear(16, 8).cuda(device), device_ids=[device])
+        self.device = device
+
+    def forward(self, indices, offsets):
+        emb_lookup = self.remote_emb_module.forward(indices, offsets)
+        return self.fc(emb_lookup.cuda(self.device))
+# END hybrid_model
+
+# BEGIN setup_trainer
+def _run_trainer(remote_emb_module, rank):
+    r"""
+    Each trainer runs a forward pass which involves an embedding lookup on the
+    parameter server and running nn.Linear locally. During the backward pass,
+    DDP is responsible for aggregating the gradients for the dense part
+    (nn.Linear) and distributed autograd ensures gradients updates are
+    propagated to the parameter server.
+    """
+
+    # Setup the model.
+    model = HybridModel(remote_emb_module, rank)
+
+    # Retrieve all model parameters as rrefs for DistributedOptimizer.
+
+    # Retrieve parameters for embedding table.
+    model_parameter_rrefs = model.remote_emb_module.remote_parameters()
+
+    # model.fc.parameters() only includes local parameters.
+    # NOTE: Cannot call model.parameters() here,
+    # because this will call remote_emb_module.parameters(),
+    # which supports remote_parameters() but not parameters().
+    for param in model.fc.parameters():
+        model_parameter_rrefs.append(RRef(param))
+
+    # Setup distributed optimizer
+    opt = DistributedOptimizer(
+        optim.SGD,
+        model_parameter_rrefs,
+        lr=0.05,
+    )
+
+    criterion = torch.nn.CrossEntropyLoss()
+    # END setup_trainer
+
+    # BEGIN run_trainer
+    def get_next_batch(rank):
+        for _ in range(10):
+            num_indices = random.randint(20, 50)
+            indices = torch.LongTensor(num_indices).random_(0, NUM_EMBEDDINGS)
+
+            # Generate offsets.
+            offsets = []
+            start = 0
+            batch_size = 0
+            while start < num_indices:
+                offsets.append(start)
+                start += random.randint(1, 10)
+                batch_size += 1
+
+            offsets_tensor = torch.LongTensor(offsets)
+            target = torch.LongTensor(batch_size).random_(8).cuda(rank)
+            yield indices, offsets_tensor, target
+
+    # Train for 100 epochs
+    for epoch in range(100):
+        # create distributed autograd context
+        for indices, offsets, target in get_next_batch(rank):
+            with dist_autograd.context() as context_id:
+                output = model(indices, offsets)
+                loss = criterion(output, target)
+
+                # Run distributed backward pass
+                dist_autograd.backward(context_id, [loss])
+
+                # Tun distributed optimizer
+                opt.step(context_id)
+
+                # Not necessary to zero grads as each iteration creates a different
+                # distributed autograd context which hosts different grads
+        print("Training done for epoch {}".format(epoch))
+        # END run_trainer
+
+# BEGIN run_worker
+def run_worker(rank, world_size):
+    r"""
+    A wrapper function that initializes RPC, calls the function, and shuts down
+    RPC.
+    """
+
+    # We need to use different port numbers in TCP init_method for init_rpc and
+    # init_process_group to avoid port conflicts.
+    rpc_backend_options = TensorPipeRpcBackendOptions()
+    rpc_backend_options.init_method = "tcp://localhost:29501"
+
+    # Rank 2 is master, 3 is ps and 0 and 1 are trainers.
+    if rank == 2:
+        rpc.init_rpc(
+            "master",
+            rank=rank,
+            world_size=world_size,
+            rpc_backend_options=rpc_backend_options,
+        )
+
+        remote_emb_module = RemoteModule(
+            "ps",
+            torch.nn.EmbeddingBag,
+            args=(NUM_EMBEDDINGS, EMBEDDING_DIM),
+            kwargs={"mode": "sum"},
+        )
+
+        # Run the training loop on trainers.
+        futs = []
+        for trainer_rank in [0, 1]:
+            trainer_name = "trainer{}".format(trainer_rank)
+            fut = rpc.rpc_async(
+                trainer_name, _run_trainer, args=(remote_emb_module, trainer_rank)
+            )
+            futs.append(fut)
+
+        # Wait for all training to finish.
+        for fut in futs:
+            fut.wait()
+    elif rank <= 1:
+        # Initialize process group for Distributed DataParallel on trainers.
+        dist.init_process_group(
+            backend="gloo", rank=rank, world_size=2, init_method="tcp://localhost:29500"
+        )
+
+        # Initialize RPC.
+        trainer_name = "trainer{}".format(rank)
+        rpc.init_rpc(
+            trainer_name,
+            rank=rank,
+            world_size=world_size,
+            rpc_backend_options=rpc_backend_options,
+        )
+
+        # Trainer just waits for RPCs from master.
+    else:
+        rpc.init_rpc(
+            "ps",
+            rank=rank,
+            world_size=world_size,
+            rpc_backend_options=rpc_backend_options,
+        )
+        # parameter server do nothing
+        pass
+
+    # block until all rpcs finish
+    rpc.shutdown()
+
+
+if __name__ == "__main__":
+    # 2 trainers, 1 parameter server, 1 master.
+    world_size = 4
+    mp.spawn(run_worker, args=(world_size,), nprocs=world_size, join=True)
+# END run_worker
diff --git a/advanced_source/semi_structured_sparse.py b/advanced_source/semi_structured_sparse.py
new file mode 100644
index 00000000000..e4bca79b9af
--- /dev/null
+++ b/advanced_source/semi_structured_sparse.py
@@ -0,0 +1,653 @@
+# -*- coding: utf-8 -*-
+"""
+(beta) Accelerating BERT with semi-structured (2:4) sparsity
+=====================================================
+**Author**: `Jesse Cai <https://github.com/jcaip>`_
+
+"""
+
+####################################################################
+# Overview
+# --------
+#
+# Like other forms of sparsity, **semi-structured sparsity** is a model
+# optimization technique that seeks to reduce the memory overhead and
+# latency of a neural network at the expense of some model accuracy. It is
+# also known as **fine-grained structured sparsity** or **2:4 structured
+# sparsity**.
+#
+# Semi-structured sparsity derives its name from its unique sparsity
+# pattern, where n out of every 2n elements are pruned. We most often see
+# n=2, hence 2:4 sparsity Semi-structured sparsity is particularly
+# interesting because it can be efficiently accelerated on GPUs and
+# doesn’t degrade model accuracy as much as other sparsity patterns.
+# 
+# With the introduction of
+# `semi-structured sparsity support <https://pytorch.org/docs/2.1/sparse.html#sparse-semi-structured-tensors>`_,
+# it is possible to prune and accelerate a semi-structured sparse model
+# without leaving PyTorch. We will explain this process in this tutorial.
+#
+# .. image:: ../../_static/img/pruning_flow.jpg
+# 
+# By the end of this tutorial, we will have sparsified a BERT
+# question-answering model to be 2:4 sparse, fine-tuning it to recover
+# nearly all F1 loss (86.92 dense vs 86.48 sparse). Finally, we will
+# accelerate this 2:4 sparse model for inference, yielding a 1.3x speedup.
+# 
+
+#####################################################
+# Requirements
+# ------------
+#
+# -  PyTorch >= 2.1.
+# -  A NVIDIA GPU with semi-structured sparsity support (Compute
+#    Capability 8.0+).
+#
+#  .. note:: This tutorial is tested on an NVIDIA A100 80GB GPU. You may not see similar speedups on newer GPU architectures, For the latest information on semi-structured sparsity support, please refer to the README `here <https://github.com/pytorch/ao/tree/main/torchao/sparsity#torchao-sparsity>
+#
+# This tutorial is designed for beginners to semi-structured sparsity and
+# sparsity in general. For users with existing 2:4 sparse models,
+# accelerating ``nn.Linear`` layers for inference with
+# ``to_sparse_semi_structured`` is quite straightforward. Here is an example: 
+# 
+
+import torch
+from torch.sparse import to_sparse_semi_structured, SparseSemiStructuredTensor
+from torch.utils.benchmark import Timer
+
+# mask Linear weight to be 2:4 sparse
+mask = torch.Tensor([0, 0, 1, 1]).tile((3072, 2560)).cuda().bool()
+linear = torch.nn.Linear(10240, 3072).half().cuda().eval()
+linear.weight = torch.nn.Parameter(mask * linear.weight)
+
+x = torch.rand(3072, 10240).half().cuda()
+
+with torch.inference_mode():
+    dense_output = linear(x)
+    dense_t = Timer(stmt="linear(x)",
+                    globals={"linear": linear,
+                             "x": x}).blocked_autorange().median * 1e3
+
+    # accelerate via SparseSemiStructuredTensor
+    linear.weight = torch.nn.Parameter(to_sparse_semi_structured(linear.weight))
+
+    sparse_output = linear(x)
+    sparse_t = Timer(stmt="linear(x)",
+                    globals={"linear": linear,
+                             "x": x}).blocked_autorange().median * 1e3
+
+    # sparse and dense matmul are numerically equivalent
+    # On an A100 80GB, we see: `Dense: 0.870ms Sparse: 0.630ms | Speedup: 1.382x`
+    assert torch.allclose(sparse_output, dense_output, atol=1e-3)
+    print(f"Dense: {dense_t:.3f}ms Sparse: {sparse_t:.3f}ms | Speedup: {(dense_t / sparse_t):.3f}x")
+
+
+######################################################################
+# What problem does semi-structured sparsity solve?
+# -------------------------------------------------
+# 
+# The general motivation behind sparsity is simple: if there are zeros in
+# your network, you can optimize efficiency by not storing or computing those
+# parameters. However, the specifics of sparsity are tricky. Zeroing out
+# parameters doesn’t affect the latency / memory overhead of our model out
+# of the box.
+# 
+# This is because the dense tensor still contains the pruned (zero)
+# elements, which the dense matrix multiplication kernel will still
+# operate on this elements. In order to realize performance gains, we need
+# to swap out dense kernels for sparse kernels, which skip calculation
+# involving pruned elements.
+# 
+# To do this, these kernels work on sparse matrices, which do not store
+# the pruned elements and store the specified elements in a compressed
+# format.
+# 
+# For semi-structured sparsity, we store exactly half of the original
+# parameters along with some compressed metadata about how the elements
+# were arranged.
+# 
+# .. image:: https://developer-blogs.nvidia.com/wp-content/uploads/2023/06/2-4-structured-sparsity-pattern.png
+#    :align: center :width: 80%
+# 
+#    Image sourced from `NVIDIA blog post <https://developer.nvidia.com/blog/structured-sparsity-in-the-nvidia-ampere-architecture-and-applications-in-search-engines/>`_ on semi-structured sparsity.
+# 
+# There are many different sparse layouts, each with their own benefits
+# and drawbacks. The 2:4 semi-structured sparse layout is particularly
+# interesting for two reasons:
+# 
+# * Unlike previous sparse formats,
+#   semi-structured sparsity was designed to be efficiently accelerated on
+#   GPUs. In 2020, NVIDIA introduced hardware support for semi-structured
+#   sparsity with their Ampere architecture, and have also released fast
+#   sparse kernels via
+#   CUTLASS `cuSPARSELt <https://docs.nvidia.com/cuda/cusparselt/index.html>`__.
+# 
+# * At the same time, semi-structured sparsity tends to have a milder
+#   impact on model accuracy compared to other sparse formats, especially
+#   when accounting for more advanced pruning / fine-tuning methods. NVIDIA
+#   has shown in their `white paper <https://arxiv.org/abs/2104.08378>`_
+#   that a simple paradigm of magnitude pruning once to be 2:4 sparse and
+#   then retraining the model yields nearly identical model accuracies.
+# 
+# Semi-structured exists in a sweet spot, providing a 2x (theoretical)
+# speedup at a much lower sparsity level (50%), while still being granular
+# enough to preserve model accuracy.
+# 
+# +---------------------+-------------+--------+------------+-------------+
+# | Network             | Data Set    | Metric | Dense FP16 | Sparse FP16 |
+# +=====================+=============+========+============+=============+
+# | ResNet-50           | ImageNet    | Top-1  | 76.1       | 76.2        |
+# +---------------------+-------------+--------+------------+-------------+
+# | ResNeXt-101_32x8d   | ImageNet    | Top-1  | 79.3       | 79.3        |
+# +---------------------+-------------+--------+------------+-------------+
+# | Xception            | ImageNet    | Top-1  | 79.2       | 79.2        |
+# +---------------------+-------------+--------+------------+-------------+
+# | SSD-RN50            | COCO2017    | bbAP   | 24.8       | 24.8        |
+# +---------------------+-------------+--------+------------+-------------+
+# | MaskRCNN-RN50       | COCO2017    | bbAP   | 37.9       | 37.9        |
+# +---------------------+-------------+--------+------------+-------------+
+# | FairSeq Transformer | EN-DE WMT14 | BLEU   | 28.2       | 28.5        |
+# +---------------------+-------------+--------+------------+-------------+
+# | BERT-Large          | SQuAD v1.1  | F1     | 91.9       | 91.9        |
+# +---------------------+-------------+--------+------------+-------------+
+# 
+# Semi-structured sparsity has an additional advantage from a workflow
+# perspective. Because the sparsity level is fixed at 50%, it is easier to
+# decompose the problem of sparsifying a model into two distinct
+# subproblems:
+# 
+# - Accuracy - How can we find a set of 2:4 sparse weights that minimize
+#   the accuracy degradation of our model?
+#
+# - Performance - How can we accelerate our 2:4 sparse weights for
+#   inference and reduced memory overhead?
+#
+
+##################################################################### 
+# .. math::
+# 
+#    \begin{bmatrix}
+#       1 & 1 & 0 & 0 \\
+#       0 & 0 & 1 & 1 \\
+#       1 & 0 & 0 & 0 \\
+#       0 & 0 & 1 & 1 \\
+#       \end{bmatrix}
+# 
+# The natural handoff point between these two problems are zeroed-out
+# dense tensors. Our inference solution is designed to compress and
+# accelerate tensors in this format. We anticipate many users coming up
+# with custom masking solution, as this is an active area of research.
+# 
+# Now that we’ve learned a little more about semi-structured sparsity,
+# let’s apply it to a BERT model trained on a question answering task,
+# SQuAD.
+# 
+# Intro & Setup
+# -------------
+# 
+# Let’s start by importing all the packages we need.
+# 
+
+# If you are running this in Google Colab, run:
+# .. code-block: python
+# 
+#    !pip install datasets transformers evaluate accelerate pandas
+#
+import os
+os.environ["WANDB_DISABLED"] = "true"
+
+import collections
+import datasets
+import evaluate
+import numpy as np
+import torch
+import torch.utils.benchmark as benchmark
+from torch import nn
+from torch.sparse import to_sparse_semi_structured, SparseSemiStructuredTensor
+from torch.ao.pruning import WeightNormSparsifier
+import transformers
+
+# force CUTLASS use if ``cuSPARSELt`` is not available
+torch.manual_seed(100)
+
+# Set default device to "cuda:0"
+torch.set_default_device(torch.device("cuda:0" if torch.cuda.is_available() else "cpu"))
+
+######################################################################
+# We’ll also need to define some helper functions that are specific to the
+# dataset / task at hand. These were adapted from
+# `this <https://huggingface.co/learn/nlp-course/chapter7/7?fw=pt>`__
+# Hugging Face course as a reference.
+# 
+
+def preprocess_validation_function(examples, tokenizer):
+    inputs = tokenizer(
+        [q.strip() for q in examples["question"]],
+        examples["context"],
+        max_length=384,
+        truncation="only_second",
+        return_overflowing_tokens=True,
+        return_offsets_mapping=True,
+        padding="max_length",
+    )
+    sample_map = inputs.pop("overflow_to_sample_mapping")
+    example_ids = []
+
+    for i in range(len(inputs["input_ids"])):
+        sample_idx = sample_map[i]
+        example_ids.append(examples["id"][sample_idx])
+        sequence_ids = inputs.sequence_ids(i)
+        offset = inputs["offset_mapping"][i]
+        inputs["offset_mapping"][i] = [
+            o if sequence_ids[k] == 1 else None for k, o in enumerate(offset)
+        ]
+
+    inputs["example_id"] = example_ids
+    return inputs
+
+
+def preprocess_train_function(examples, tokenizer):
+    inputs = tokenizer(
+        [q.strip() for q in examples["question"]],
+        examples["context"],
+        max_length=384,
+        truncation="only_second",
+        return_offsets_mapping=True,
+        padding="max_length",
+    )
+
+    offset_mapping = inputs["offset_mapping"]
+    answers = examples["answers"]
+    start_positions = []
+    end_positions = []
+
+    for i, (offset, answer) in enumerate(zip(offset_mapping, answers)):
+        start_char = answer["answer_start"][0]
+        end_char = start_char + len(answer["text"][0])
+        sequence_ids = inputs.sequence_ids(i)
+
+        # Find the start and end of the context
+        idx = 0
+        while sequence_ids[idx] != 1:
+            idx += 1
+        context_start = idx
+        while sequence_ids[idx] == 1:
+            idx += 1
+        context_end = idx - 1
+
+        # If the answer is not fully inside the context, label it (0, 0)
+        if offset[context_start][0] > end_char or offset[context_end][1] < start_char:
+            start_positions.append(0)
+            end_positions.append(0)
+        else:
+            # Otherwise it's the start and end token positions
+            idx = context_start
+            while idx <= context_end and offset[idx][0] <= start_char:
+                idx += 1
+            start_positions.append(idx - 1)
+
+            idx = context_end
+            while idx >= context_start and offset[idx][1] >= end_char:
+                idx -= 1
+            end_positions.append(idx + 1)
+
+    inputs["start_positions"] = start_positions
+    inputs["end_positions"] = end_positions
+    return inputs
+
+
+def compute_metrics(start_logits, end_logits, features, examples):
+    n_best = 20
+    max_answer_length = 30
+    metric = evaluate.load("squad")
+
+    example_to_features = collections.defaultdict(list)
+    for idx, feature in enumerate(features):
+        example_to_features[feature["example_id"]].append(idx)
+
+    predicted_answers = []
+    # for example in ``tqdm`` (examples):
+    for example in examples:
+        example_id = example["id"]
+        context = example["context"]
+        answers = []
+
+        # Loop through all features associated with that example
+        for feature_index in example_to_features[example_id]:
+            start_logit = start_logits[feature_index]
+            end_logit = end_logits[feature_index]
+            offsets = features[feature_index]["offset_mapping"]
+
+            start_indexes = np.argsort(start_logit)[-1 : -n_best - 1 : -1].tolist()
+            end_indexes = np.argsort(end_logit)[-1 : -n_best - 1 : -1].tolist()
+            for start_index in start_indexes:
+                for end_index in end_indexes:
+                    # Skip answers that are not fully in the context
+                    if offsets[start_index] is None or offsets[end_index] is None:
+                        continue
+                    # Skip answers with a length that is either < 0
+                    # or > max_answer_length
+                    if (
+                        end_index < start_index
+                        or end_index - start_index + 1 > max_answer_length
+                    ):
+                        continue
+
+                    answer = {
+                        "text": context[
+                            offsets[start_index][0] : offsets[end_index][1]
+                        ],
+                        "logit_score": start_logit[start_index] + end_logit[end_index],
+                    }
+                    answers.append(answer)
+
+        # Select the answer with the best score
+        if len(answers) > 0:
+            best_answer = max(answers, key=lambda x: x["logit_score"])
+            predicted_answers.append(
+                {"id": example_id, "prediction_text": best_answer["text"]}
+            )
+        else:
+            predicted_answers.append({"id": example_id, "prediction_text": ""})
+
+    theoretical_answers = [
+        {"id": ex["id"], "answers": ex["answers"]} for ex in examples
+    ]
+    return metric.compute(predictions=predicted_answers, references=theoretical_answers)
+
+
+######################################################################
+# Now that those are defined, we just need one additional helper function,
+# which will help us benchmark our model.
+# 
+
+def measure_execution_time(model, batch_sizes, dataset):
+    dataset_for_model = dataset.remove_columns(["example_id", "offset_mapping"])
+    dataset_for_model.set_format("torch")
+    batch_size_to_time_sec = {}
+    for batch_size in batch_sizes:
+        batch = {
+            k: dataset_for_model[k][:batch_size].cuda()
+            for k in dataset_for_model.column_names
+        }
+
+        with torch.no_grad():
+            baseline_predictions = model(**batch)
+            timer = benchmark.Timer(
+                stmt="model(**batch)", globals={"model": model, "batch": batch}
+            )
+            p50 = timer.blocked_autorange().median * 1000
+            batch_size_to_time_sec[batch_size] = p50
+
+            model_c = torch.compile(model, fullgraph=True)
+            timer = benchmark.Timer(
+                stmt="model(**batch)", globals={"model": model_c, "batch": batch}
+            )
+            p50 = timer.blocked_autorange().median * 1000
+            batch_size_to_time_sec[f"{batch_size}_compile"] = p50
+            new_predictions = model_c(**batch)
+
+    return batch_size_to_time_sec
+
+
+
+######################################################################
+# We will get started by loading our model and tokenizer, and then setting
+# up our dataset.
+# 
+
+# load model
+model_name = "bert-base-cased"
+tokenizer = transformers.AutoTokenizer.from_pretrained(model_name)
+model = transformers.AutoModelForQuestionAnswering.from_pretrained(model_name)
+print(f"Loading tokenizer: {model_name}")
+print(f"Loading model: {model_name}")
+
+# set up train and val dataset
+squad_dataset = datasets.load_dataset("squad")
+tokenized_squad_dataset = {}
+tokenized_squad_dataset["train"] = squad_dataset["train"].map(
+    lambda x: preprocess_train_function(x, tokenizer), batched=True
+)
+tokenized_squad_dataset["validation"] = squad_dataset["validation"].map(
+    lambda x: preprocess_validation_function(x, tokenizer),
+    batched=True,
+    remove_columns=squad_dataset["train"].column_names,
+)
+data_collator = transformers.DataCollatorWithPadding(tokenizer=tokenizer)
+
+
+######################################################################
+# Establishing a baseline
+# =======================
+# 
+# Next, we’ll train a quick baseline of our model on SQuAD. This task asks
+# our model to identify spans, or segments of text, in a given context
+# (Wikipedia articles) that answer a given question. Running the following
+# code gives me an F1 score of 86.9. This is quite close to the reported
+# NVIDIA score and the difference is likely due to BERT-base
+# vs. BERT-large or fine-tuning hyperparameters.
+# 
+
+training_args = transformers.TrainingArguments(
+    "trainer",
+    num_train_epochs=1,
+    lr_scheduler_type="constant",
+    per_device_train_batch_size=32,
+    per_device_eval_batch_size=256,
+    logging_steps=50, 
+    # Limit max steps for tutorial runners. Delete the below line to see the reported accuracy numbers. 
+    max_steps=500,
+    report_to=None,
+)
+
+trainer = transformers.Trainer(
+    model,
+    training_args,
+    train_dataset=tokenized_squad_dataset["train"],
+    eval_dataset=tokenized_squad_dataset["validation"],
+    data_collator=data_collator,
+    tokenizer=tokenizer,
+)
+
+trainer.train()
+
+# batch sizes to compare for eval
+batch_sizes = [4, 16, 64, 256]
+# 2:4 sparsity require fp16, so we cast here for a fair comparison
+with torch.autocast("cuda"):
+    with torch.no_grad():
+        predictions = trainer.predict(tokenized_squad_dataset["validation"])
+        start_logits, end_logits = predictions.predictions
+        fp16_baseline = compute_metrics(
+            start_logits,
+            end_logits,
+            tokenized_squad_dataset["validation"],
+            squad_dataset["validation"],
+        )
+        fp16_time = measure_execution_time(
+            model,
+            batch_sizes,
+            tokenized_squad_dataset["validation"],
+        )
+
+print("fp16", fp16_baseline)
+print("cuda_fp16 time", fp16_time)
+
+import pandas as pd
+df = pd.DataFrame(trainer.state.log_history)
+df.plot.line(x='step', y='loss', title="Loss vs. # steps", ylabel="loss")
+
+
+######################################################################
+# Pruning BERT to be 2:4 sparse
+# -----------------------------
+# 
+# Now that we have our baseline, it’s time we prune BERT. There are many
+# different pruning strategies, but one of the most common is **magnitude
+# pruning**, which seeks to remove the weights with the lowest L1 norm.
+# Magnitude pruning was used by NVIDIA in all their results and is a
+# common baseline.
+# 
+# To do this, we will use the ``torch.ao.pruning`` package, which contains
+# a weight-norm (magnitude) sparsifier. These sparsifiers work by applying
+# mask parametrizations to the weight tensors in a model. This lets them
+# simulate sparsity by masking out the pruned weights.
+# 
+# We’ll also have to decide what layers of the model to apply sparsity to,
+# which in this case is all of the ``nn.Linear`` layers, except for the
+# task-specific head outputs. That’s because semi-structured sparsity has
+# `shape constraints <https://pytorch.org/docs/2.1/sparse.html#constructing-sparse-semi-structured-tensors>`_,
+# and the task-specific ``nn.Linear`` layers do not satisfy them.
+# 
+
+sparsifier = WeightNormSparsifier(
+    # apply sparsity to all blocks
+    sparsity_level=1.0,
+    # shape of 4 elements is a block
+    sparse_block_shape=(1, 4),
+    # two zeros for every block of 4
+    zeros_per_block=2
+)
+
+# add to config if ``nn.Linear`` and in the BERT model.
+sparse_config = [
+    {"tensor_fqn": f"{fqn}.weight"}
+    for fqn, module in model.named_modules()
+    if isinstance(module, nn.Linear) and "layer" in fqn
+]
+
+
+######################################################################
+# The first step for pruning the model is to insert parametrizations for
+# masking the weights of the model. This is done by the prepare step.
+# Anytime we try to access the ``.weight`` we will get ``mask * weight``
+# instead.
+# 
+
+# Prepare the model, insert fake-sparsity parametrizations for training
+sparsifier.prepare(model, sparse_config)
+print(model.bert.encoder.layer[0].output)
+
+
+######################################################################
+# Then, we’ll take a single pruning step. All pruners implement a
+# ``update_mask()`` method that updates the mask with the logic being
+# determined by the pruner implementation. The step method calls this
+# ``update_mask`` functions for the weights specified in the sparse
+# config.
+# 
+# We will also evaluate the model to show the accuracy degradation of
+# zero-shot pruning, or pruning without fine-tuning / retraining.
+# 
+
+sparsifier.step()
+with torch.autocast("cuda"):
+    with torch.no_grad():
+        predictions = trainer.predict(tokenized_squad_dataset["validation"])
+    pruned = compute_metrics(
+        *predictions.predictions,
+        tokenized_squad_dataset["validation"],
+        squad_dataset["validation"],
+    )
+print("pruned eval metrics:", pruned)
+
+
+######################################################################
+# In this state, we can start fine-tuning the model, updating the elements
+# that wouldn’t be pruned to better account for the accuracy loss. Once
+# we’ve reached a satisfied state, we can call ``squash_mask`` to fuse the
+# mask and the weight together. This will remove the parametrizations and
+# we are left with a zeroed-out 2:4 dense model.
+# 
+
+trainer.train()
+sparsifier.squash_mask()
+torch.set_printoptions(edgeitems=4)
+print(model.bert.encoder.layer[0].intermediate.dense.weight[:8, :8])
+
+df["sparse_loss"] = pd.DataFrame(trainer.state.log_history)["loss"]
+df.plot.line(x='step', y=["loss", "sparse_loss"], title="Loss vs. # steps", ylabel="loss")
+
+
+######################################################################
+# Accelerating 2:4 sparse models for inference
+# --------------------------------------------
+# 
+# Now that we have a model in this format, we can accelerate it for
+# inference just like in the QuickStart Guide.
+# 
+
+model = model.cuda().half()
+# accelerate for sparsity
+for fqn, module in model.named_modules():
+    if isinstance(module, nn.Linear) and "layer" in fqn:
+        module.weight = nn.Parameter(to_sparse_semi_structured(module.weight))
+
+with torch.no_grad():
+    predictions = trainer.predict(tokenized_squad_dataset["validation"])
+start_logits, end_logits = predictions.predictions
+metrics_sparse = compute_metrics(
+    start_logits,
+    end_logits,
+    tokenized_squad_dataset["validation"],
+    squad_dataset["validation"],
+)
+print("sparse eval metrics: ", metrics_sparse)
+sparse_perf = measure_execution_time(
+    model,
+    batch_sizes,
+    tokenized_squad_dataset["validation"],
+)
+print("sparse perf metrics: ", sparse_perf)
+
+
+######################################################################
+# Retraining our model after magnitude pruning has recovered nearly all of
+# the F1 that has been lost when the model was pruned. At the same time we
+# have achieved a 1.28x speedup for ``bs=16``. Note that not all shapes are
+# amenable to performance improvements. When batch sizes are small and
+# limited time is spent in compute sparse kernels may be slower than their
+# dense counterparts.
+# 
+# Because semi-structured sparsity is implemented as a tensor subclass, it
+# is compatible with ``torch.compile``. When composed with
+# ``to_sparse_semi_structured``, we are able to achieve a total 2x speedup
+# on BERT.
+#
+# .. table::
+#
+#     +--------------------+--------+--------------+-----------------+-----------+
+#     | Metrics            | fp16   | 2:4 sparse   | delta / speedup | compiled  |
+#     +====================+========+==============+=================+===========+
+#     | Exact Match (%)    | 78.53  | 78.44        | -0.09           |           |
+#     +--------------------+--------+--------------+-----------------+-----------+
+#     | F1 (%)             | 86.93  | 86.49        | -0.44           |           |
+#     +--------------------+--------+--------------+-----------------+-----------+
+#     | Time (bs=4)        | 11.10  | 15.54        | 0.71x           | no        |
+#     +--------------------+--------+--------------+-----------------+-----------+
+#     | Time (bs=16)       | 19.35  | 15.74        | 1.23x           | no        |
+#     +--------------------+--------+--------------+-----------------+-----------+
+#     | Time (bs=64)       | 72.71  | 59.41        | 1.22x           | no        |
+#     +--------------------+--------+--------------+-----------------+-----------+
+#     | Time (bs=256)      | 286.65 | 247.63       | 1.14x           | no        |
+#     +--------------------+--------+--------------+-----------------+-----------+
+#     | Time (bs=4)        | 7.59   | 7.46         | 1.02x           | yes       |
+#     +--------------------+--------+--------------+-----------------+-----------+
+#     | Time (bs=16)       | 11.47  | 9.68         | 1.18x           | yes       |
+#     +--------------------+--------+--------------+-----------------+-----------+
+#     | Time (bs=64)       | 41.57  | 36.92        | 1.13x           | yes       |
+#     +--------------------+--------+--------------+-----------------+-----------+
+#     | Time (bs=256)      | 159.22 | 142.23       | 1.12x           | yes       |
+#     +--------------------+--------+--------------+-----------------+-----------+
+# 
+# Conclusion
+# ==========
+# 
+# In this tutorial, we have shown how to prune BERT to be 2:4 sparse and
+# how to accelerate a 2:4 sparse model for inference. By taking advantage
+# of our ``SparseSemiStructuredTensor`` subclass, we were able to achieve a
+# 1.3x speedup over the fp16 baseline, and up to 2x with
+# ``torch.compile``. We also demonstrated the benefits of 2:4 sparsity by
+# fine-tuning BERT to recover any lost F1 (86.92 dense vs 86.48 sparse).
+# 
diff --git a/advanced_source/sharding.rst b/advanced_source/sharding.rst
new file mode 100644
index 00000000000..7dfeeb88bf1
--- /dev/null
+++ b/advanced_source/sharding.rst
@@ -0,0 +1,336 @@
+Exploring TorchRec sharding
+===========================
+
+This tutorial will mainly cover the sharding schemes of embedding tables
+via ``EmbeddingPlanner`` and ``DistributedModelParallel`` API and
+explore the benefits of different sharding schemes for the embedding
+tables by explicitly configuring them.
+
+Installation
+------------
+
+Requirements: - python >= 3.7
+
+We highly recommend CUDA when using torchRec. If using CUDA: - cuda >=
+11.0
+
+.. code:: python
+
+    # install conda to make installying pytorch with cudatoolkit 11.3 easier. 
+    !sudo rm Miniconda3-py37_4.9.2-Linux-x86_64.sh Miniconda3-py37_4.9.2-Linux-x86_64.sh.*
+    !sudo wget https://repo.anaconda.com/miniconda/Miniconda3-py37_4.9.2-Linux-x86_64.sh
+    !sudo chmod +x Miniconda3-py37_4.9.2-Linux-x86_64.sh
+    !sudo bash ./Miniconda3-py37_4.9.2-Linux-x86_64.sh -b -f -p /usr/local
+
+.. code:: python
+
+    # install pytorch with cudatoolkit 11.3
+    !sudo conda install pytorch cudatoolkit=11.3 -c pytorch-nightly -y
+
+Installing torchRec will also install
+`FBGEMM <https://github.com/pytorch/fbgemm>`__, a collection of CUDA
+kernels and GPU enabled operations to run
+
+.. code:: python
+
+    # install torchrec
+    !pip3 install torchrec-nightly
+
+Install multiprocess which works with ipython to for multi-processing
+programming within colab
+
+.. code:: python
+
+    !pip3 install multiprocess
+
+The following steps are needed for the Colab runtime to detect the added
+shared libraries. The runtime searches for shared libraries in /usr/lib,
+so we copy over the libraries which were installed in /usr/local/lib/.
+**This is a very necessary step, only in the colab runtime**.
+
+.. code:: python
+
+    !sudo cp /usr/local/lib/lib* /usr/lib/
+
+**Restart your runtime at this point for the newly installed packages
+to be seen.** Run the step below immediately after restarting so that
+python knows where to look for packages. **Always run this step after
+restarting the runtime.**
+
+.. code:: python
+
+    import sys
+    sys.path = ['', '/env/python', '/usr/local/lib/python37.zip', '/usr/local/lib/python3.7', '/usr/local/lib/python3.7/lib-dynload', '/usr/local/lib/python3.7/site-packages', './.local/lib/python3.7/site-packages']
+
+
+Distributed Setup
+-----------------
+
+Due to the notebook enviroment, we cannot run
+`SPMD <https://en.wikipedia.org/wiki/SPMD>`_ program here but we
+can do multiprocessing inside the notebook to mimic the setup. Users
+should be responsible for setting up their own
+`SPMD <https://en.wikipedia.org/wiki/SPMD>`_ launcher when using
+Torchrec. We setup our environment so that torch distributed based
+communication backend can work.
+
+.. code:: python
+
+    import os
+    import torch
+    import torchrec
+
+    os.environ["MASTER_ADDR"] = "localhost"
+    os.environ["MASTER_PORT"] = "29500"
+
+Constructing our embedding model
+--------------------------------
+
+Here we use TorchRec offering of
+`EmbeddingBagCollection <https://github.com/facebookresearch/torchrec/blob/main/torchrec/modules/embedding_modules.py#L59>`_
+to construct our embedding bag model with embedding tables.
+
+Here, we create an EmbeddingBagCollection (EBC) with four embedding
+bags. We have two types of tables: large tables and small tables
+differentiated by their row size difference: 4096 vs 1024. Each table is
+still represented by 64 dimension embedding.
+
+We configure the ``ParameterConstraints`` data structure for the tables,
+which provides hints for the model parallel API to help decide the
+sharding and placement strategy for the tables. In TorchRec, we support
+\* ``table-wise``: place the entire table on one device; \*
+``row-wise``: shard the table evenly by row dimension and place one
+shard on each device of the communication world; \* ``column-wise``:
+shard the table evenly by embedding dimension, and place one shard on
+each device of the communication world; \* ``table-row-wise``: special
+sharding optimized for intra-host communication for available fast
+intra-machine device interconnect, e.g. NVLink; \* ``data_parallel``:
+replicate the tables for every device;
+
+Note how we initially allocate the EBC on device "meta". This will tell
+EBC to not allocate memory yet.
+
+.. code:: python
+
+    from torchrec.distributed.planner.types import ParameterConstraints
+    from torchrec.distributed.embedding_types import EmbeddingComputeKernel
+    from torchrec.distributed.types import ShardingType
+    from typing import Dict
+
+    large_table_cnt = 2
+    small_table_cnt = 2
+    large_tables=[
+      torchrec.EmbeddingBagConfig(
+        name="large_table_" + str(i),
+        embedding_dim=64,
+        num_embeddings=4096,
+        feature_names=["large_table_feature_" + str(i)],
+        pooling=torchrec.PoolingType.SUM,
+      ) for i in range(large_table_cnt)
+    ]
+    small_tables=[
+      torchrec.EmbeddingBagConfig(
+        name="small_table_" + str(i),
+        embedding_dim=64,
+        num_embeddings=1024,
+        feature_names=["small_table_feature_" + str(i)],
+        pooling=torchrec.PoolingType.SUM,
+      ) for i in range(small_table_cnt)
+    ]
+
+    def gen_constraints(sharding_type: ShardingType = ShardingType.TABLE_WISE) -> Dict[str, ParameterConstraints]:
+      large_table_constraints = {
+        "large_table_" + str(i): ParameterConstraints(
+          sharding_types=[sharding_type.value],
+        ) for i in range(large_table_cnt)
+      }
+      small_table_constraints = {
+        "small_table_" + str(i): ParameterConstraints(
+          sharding_types=[sharding_type.value],
+        ) for i in range(small_table_cnt)
+      }
+      constraints = {**large_table_constraints, **small_table_constraints}
+      return constraints
+
+.. code:: python
+
+    ebc = torchrec.EmbeddingBagCollection(
+        device="cuda",
+        tables=large_tables + small_tables
+    )
+
+DistributedModelParallel in multiprocessing
+-------------------------------------------
+
+Now, we have a single process execution function for mimicking one
+rank's work during `SPMD <https://en.wikipedia.org/wiki/SPMD>`_
+execution.
+
+This code will shard the model collectively with other processes and
+allocate memories accordingly. It first sets up process groups and do
+embedding table placement using planner and generate sharded model using
+``DistributedModelParallel``.
+
+.. code:: python
+
+    def single_rank_execution(
+        rank: int,
+        world_size: int,
+        constraints: Dict[str, ParameterConstraints],
+        module: torch.nn.Module,
+        backend: str,
+    ) -> None:
+        import os
+        import torch
+        import torch.distributed as dist
+        from torchrec.distributed.embeddingbag import EmbeddingBagCollectionSharder
+        from torchrec.distributed.model_parallel import DistributedModelParallel
+        from torchrec.distributed.planner import EmbeddingShardingPlanner, Topology
+        from torchrec.distributed.types import ModuleSharder, ShardingEnv
+        from typing import cast
+
+        def init_distributed_single_host(
+            rank: int,
+            world_size: int,
+            backend: str,
+            # pyre-fixme[11]: Annotation `ProcessGroup` is not defined as a type.
+        ) -> dist.ProcessGroup:
+            os.environ["RANK"] = f"{rank}"
+            os.environ["WORLD_SIZE"] = f"{world_size}"
+            dist.init_process_group(rank=rank, world_size=world_size, backend=backend)
+            return dist.group.WORLD
+
+        if backend == "nccl":
+            device = torch.device(f"cuda:{rank}")
+            torch.cuda.set_device(device)
+        else:
+            device = torch.device("cpu")
+        topology = Topology(world_size=world_size, compute_device="cuda")
+        pg = init_distributed_single_host(rank, world_size, backend)
+        planner = EmbeddingShardingPlanner(
+            topology=topology,
+            constraints=constraints,
+        )
+        sharders = [cast(ModuleSharder[torch.nn.Module], EmbeddingBagCollectionSharder())]
+        plan: ShardingPlan = planner.collective_plan(module, sharders, pg)
+    
+        sharded_model = DistributedModelParallel(
+            module,
+            env=ShardingEnv.from_process_group(pg),
+            plan=plan,
+            sharders=sharders,
+            device=device,
+        )
+        print(f"rank:{rank},sharding plan: {plan}")
+        return sharded_model
+
+
+Multiprocessing Execution
+~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Now let's execute the code in multi-processes representing multiple GPU
+ranks.
+
+.. code:: python
+
+    import multiprocess
+       
+    def spmd_sharing_simulation(
+        sharding_type: ShardingType = ShardingType.TABLE_WISE,
+        world_size = 2,
+    ):
+      ctx = multiprocess.get_context("spawn")
+      processes = []
+      for rank in range(world_size):
+          p = ctx.Process(
+              target=single_rank_execution,
+              args=(
+                  rank,
+                  world_size,
+                  gen_constraints(sharding_type),
+                  ebc,
+                  "nccl"
+              ),
+          )
+          p.start()
+          processes.append(p)
+    
+      for p in processes:
+          p.join()
+          assert 0 == p.exitcode
+
+Table Wise Sharding
+~~~~~~~~~~~~~~~~~~~
+
+Now let's execute the code in two processes for 2 GPUs. We can see in
+the plan print that how our tables are sharded across GPUs. Each node
+will have one large table and one small which shows our planner tries
+for load balance for the embedding tables. Table-wise is the de-factor
+go-to sharding schemes for many small-medium size tables for load
+balancing over the devices.
+
+.. code:: python
+
+    spmd_sharing_simulation(ShardingType.TABLE_WISE)
+
+
+.. parsed-literal::
+
+    rank:1,sharding plan: {'': {'large_table_0': ParameterSharding(sharding_type='table_wise', compute_kernel='batched_fused', ranks=[0], sharding_spec=EnumerableShardingSpec(shards=[ShardMetadata(shard_offsets=[0, 0], shard_sizes=[4096, 64], placement=rank:0/cuda:0)])), 'large_table_1': ParameterSharding(sharding_type='table_wise', compute_kernel='batched_fused', ranks=[1], sharding_spec=EnumerableShardingSpec(shards=[ShardMetadata(shard_offsets=[0, 0], shard_sizes=[4096, 64], placement=rank:1/cuda:1)])), 'small_table_0': ParameterSharding(sharding_type='table_wise', compute_kernel='batched_fused', ranks=[0], sharding_spec=EnumerableShardingSpec(shards=[ShardMetadata(shard_offsets=[0, 0], shard_sizes=[1024, 64], placement=rank:0/cuda:0)])), 'small_table_1': ParameterSharding(sharding_type='table_wise', compute_kernel='batched_fused', ranks=[1], sharding_spec=EnumerableShardingSpec(shards=[ShardMetadata(shard_offsets=[0, 0], shard_sizes=[1024, 64], placement=rank:1/cuda:1)]))}}
+    rank:0,sharding plan: {'': {'large_table_0': ParameterSharding(sharding_type='table_wise', compute_kernel='batched_fused', ranks=[0], sharding_spec=EnumerableShardingSpec(shards=[ShardMetadata(shard_offsets=[0, 0], shard_sizes=[4096, 64], placement=rank:0/cuda:0)])), 'large_table_1': ParameterSharding(sharding_type='table_wise', compute_kernel='batched_fused', ranks=[1], sharding_spec=EnumerableShardingSpec(shards=[ShardMetadata(shard_offsets=[0, 0], shard_sizes=[4096, 64], placement=rank:1/cuda:1)])), 'small_table_0': ParameterSharding(sharding_type='table_wise', compute_kernel='batched_fused', ranks=[0], sharding_spec=EnumerableShardingSpec(shards=[ShardMetadata(shard_offsets=[0, 0], shard_sizes=[1024, 64], placement=rank:0/cuda:0)])), 'small_table_1': ParameterSharding(sharding_type='table_wise', compute_kernel='batched_fused', ranks=[1], sharding_spec=EnumerableShardingSpec(shards=[ShardMetadata(shard_offsets=[0, 0], shard_sizes=[1024, 64], placement=rank:1/cuda:1)]))}}
+
+Explore other sharding modes
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+We have initially explored what table-wise sharding would look like and
+how it balances the tables placement. Now we explore sharding modes with
+finer focus on load balance: row-wise. Row-wise is specifically
+addressing large tables which a single device cannot hold due to the
+memory size increase from large embedding row numbers. It can address
+the placement of the super large tables in your models. Users can see
+that in the ``shard_sizes`` section in the printed plan log, the tables
+are halved by row dimension to be distributed onto two GPUs.
+
+.. code:: python
+
+    spmd_sharing_simulation(ShardingType.ROW_WISE)
+
+
+.. parsed-literal::
+
+    rank:1,sharding plan: {'': {'large_table_0': ParameterSharding(sharding_type='row_wise', compute_kernel='batched_fused', ranks=[0, 1], sharding_spec=EnumerableShardingSpec(shards=[ShardMetadata(shard_offsets=[0, 0], shard_sizes=[2048, 64], placement=rank:0/cuda:0), ShardMetadata(shard_offsets=[2048, 0], shard_sizes=[2048, 64], placement=rank:1/cuda:1)])), 'large_table_1': ParameterSharding(sharding_type='row_wise', compute_kernel='batched_fused', ranks=[0, 1], sharding_spec=EnumerableShardingSpec(shards=[ShardMetadata(shard_offsets=[0, 0], shard_sizes=[2048, 64], placement=rank:0/cuda:0), ShardMetadata(shard_offsets=[2048, 0], shard_sizes=[2048, 64], placement=rank:1/cuda:1)])), 'small_table_0': ParameterSharding(sharding_type='row_wise', compute_kernel='batched_fused', ranks=[0, 1], sharding_spec=EnumerableShardingSpec(shards=[ShardMetadata(shard_offsets=[0, 0], shard_sizes=[512, 64], placement=rank:0/cuda:0), ShardMetadata(shard_offsets=[512, 0], shard_sizes=[512, 64], placement=rank:1/cuda:1)])), 'small_table_1': ParameterSharding(sharding_type='row_wise', compute_kernel='batched_fused', ranks=[0, 1], sharding_spec=EnumerableShardingSpec(shards=[ShardMetadata(shard_offsets=[0, 0], shard_sizes=[512, 64], placement=rank:0/cuda:0), ShardMetadata(shard_offsets=[512, 0], shard_sizes=[512, 64], placement=rank:1/cuda:1)]))}}
+    rank:0,sharding plan: {'': {'large_table_0': ParameterSharding(sharding_type='row_wise', compute_kernel='batched_fused', ranks=[0, 1], sharding_spec=EnumerableShardingSpec(shards=[ShardMetadata(shard_offsets=[0, 0], shard_sizes=[2048, 64], placement=rank:0/cuda:0), ShardMetadata(shard_offsets=[2048, 0], shard_sizes=[2048, 64], placement=rank:1/cuda:1)])), 'large_table_1': ParameterSharding(sharding_type='row_wise', compute_kernel='batched_fused', ranks=[0, 1], sharding_spec=EnumerableShardingSpec(shards=[ShardMetadata(shard_offsets=[0, 0], shard_sizes=[2048, 64], placement=rank:0/cuda:0), ShardMetadata(shard_offsets=[2048, 0], shard_sizes=[2048, 64], placement=rank:1/cuda:1)])), 'small_table_0': ParameterSharding(sharding_type='row_wise', compute_kernel='batched_fused', ranks=[0, 1], sharding_spec=EnumerableShardingSpec(shards=[ShardMetadata(shard_offsets=[0, 0], shard_sizes=[512, 64], placement=rank:0/cuda:0), ShardMetadata(shard_offsets=[512, 0], shard_sizes=[512, 64], placement=rank:1/cuda:1)])), 'small_table_1': ParameterSharding(sharding_type='row_wise', compute_kernel='batched_fused', ranks=[0, 1], sharding_spec=EnumerableShardingSpec(shards=[ShardMetadata(shard_offsets=[0, 0], shard_sizes=[512, 64], placement=rank:0/cuda:0), ShardMetadata(shard_offsets=[512, 0], shard_sizes=[512, 64], placement=rank:1/cuda:1)]))}}
+
+Column-wise on the other hand, address the load imbalance problems for
+tables with large embedding dimensions. We will split the table
+vertically. Users can see that in the ``shard_sizes`` section in the
+printed plan log, the tables are halved by embedding dimension to be
+distributed onto two GPUs.
+
+.. code:: python
+
+    spmd_sharing_simulation(ShardingType.COLUMN_WISE)
+
+
+.. parsed-literal::
+
+    rank:0,sharding plan: {'': {'large_table_0': ParameterSharding(sharding_type='column_wise', compute_kernel='batched_fused', ranks=[0, 1], sharding_spec=EnumerableShardingSpec(shards=[ShardMetadata(shard_offsets=[0, 0], shard_sizes=[4096, 32], placement=rank:0/cuda:0), ShardMetadata(shard_offsets=[0, 32], shard_sizes=[4096, 32], placement=rank:1/cuda:1)])), 'large_table_1': ParameterSharding(sharding_type='column_wise', compute_kernel='batched_fused', ranks=[0, 1], sharding_spec=EnumerableShardingSpec(shards=[ShardMetadata(shard_offsets=[0, 0], shard_sizes=[4096, 32], placement=rank:0/cuda:0), ShardMetadata(shard_offsets=[0, 32], shard_sizes=[4096, 32], placement=rank:1/cuda:1)])), 'small_table_0': ParameterSharding(sharding_type='column_wise', compute_kernel='batched_fused', ranks=[0, 1], sharding_spec=EnumerableShardingSpec(shards=[ShardMetadata(shard_offsets=[0, 0], shard_sizes=[1024, 32], placement=rank:0/cuda:0), ShardMetadata(shard_offsets=[0, 32], shard_sizes=[1024, 32], placement=rank:1/cuda:1)])), 'small_table_1': ParameterSharding(sharding_type='column_wise', compute_kernel='batched_fused', ranks=[0, 1], sharding_spec=EnumerableShardingSpec(shards=[ShardMetadata(shard_offsets=[0, 0], shard_sizes=[1024, 32], placement=rank:0/cuda:0), ShardMetadata(shard_offsets=[0, 32], shard_sizes=[1024, 32], placement=rank:1/cuda:1)]))}}
+    rank:1,sharding plan: {'': {'large_table_0': ParameterSharding(sharding_type='column_wise', compute_kernel='batched_fused', ranks=[0, 1], sharding_spec=EnumerableShardingSpec(shards=[ShardMetadata(shard_offsets=[0, 0], shard_sizes=[4096, 32], placement=rank:0/cuda:0), ShardMetadata(shard_offsets=[0, 32], shard_sizes=[4096, 32], placement=rank:1/cuda:1)])), 'large_table_1': ParameterSharding(sharding_type='column_wise', compute_kernel='batched_fused', ranks=[0, 1], sharding_spec=EnumerableShardingSpec(shards=[ShardMetadata(shard_offsets=[0, 0], shard_sizes=[4096, 32], placement=rank:0/cuda:0), ShardMetadata(shard_offsets=[0, 32], shard_sizes=[4096, 32], placement=rank:1/cuda:1)])), 'small_table_0': ParameterSharding(sharding_type='column_wise', compute_kernel='batched_fused', ranks=[0, 1], sharding_spec=EnumerableShardingSpec(shards=[ShardMetadata(shard_offsets=[0, 0], shard_sizes=[1024, 32], placement=rank:0/cuda:0), ShardMetadata(shard_offsets=[0, 32], shard_sizes=[1024, 32], placement=rank:1/cuda:1)])), 'small_table_1': ParameterSharding(sharding_type='column_wise', compute_kernel='batched_fused', ranks=[0, 1], sharding_spec=EnumerableShardingSpec(shards=[ShardMetadata(shard_offsets=[0, 0], shard_sizes=[1024, 32], placement=rank:0/cuda:0), ShardMetadata(shard_offsets=[0, 32], shard_sizes=[1024, 32], placement=rank:1/cuda:1)]))}}
+
+For ``table-row-wise``, unfortuately we cannot simulate it due to its
+nature of operating under multi-host setup. We will present a python
+`SPMD <https://en.wikipedia.org/wiki/SPMD>`_ example in the future
+to train models with ``table-row-wise``.
+
+With data parallel, we will repeat the tables for all devices.
+
+.. code:: python
+
+    spmd_sharing_simulation(ShardingType.DATA_PARALLEL)
+
+
+.. parsed-literal::
+
+    rank:0,sharding plan: {'': {'large_table_0': ParameterSharding(sharding_type='data_parallel', compute_kernel='batched_dense', ranks=[0, 1], sharding_spec=None), 'large_table_1': ParameterSharding(sharding_type='data_parallel', compute_kernel='batched_dense', ranks=[0, 1], sharding_spec=None), 'small_table_0': ParameterSharding(sharding_type='data_parallel', compute_kernel='batched_dense', ranks=[0, 1], sharding_spec=None), 'small_table_1': ParameterSharding(sharding_type='data_parallel', compute_kernel='batched_dense', ranks=[0, 1], sharding_spec=None)}}
+    rank:1,sharding plan: {'': {'large_table_0': ParameterSharding(sharding_type='data_parallel', compute_kernel='batched_dense', ranks=[0, 1], sharding_spec=None), 'large_table_1': ParameterSharding(sharding_type='data_parallel', compute_kernel='batched_dense', ranks=[0, 1], sharding_spec=None), 'small_table_0': ParameterSharding(sharding_type='data_parallel', compute_kernel='batched_dense', ranks=[0, 1], sharding_spec=None), 'small_table_1': ParameterSharding(sharding_type='data_parallel', compute_kernel='batched_dense', ranks=[0, 1], sharding_spec=None)}}
+
diff --git a/advanced_source/super_resolution_with_caffe2.py b/advanced_source/super_resolution_with_caffe2.py
deleted file mode 100644
index 866a5f06081..00000000000
--- a/advanced_source/super_resolution_with_caffe2.py
+++ /dev/null
@@ -1,407 +0,0 @@
-"""
-Transfering a Model from PyTorch to Caffe2 and Mobile using ONNX
-================================================================
-
-In this tutorial, we describe how to use ONNX to convert a model defined
-in PyTorch into the ONNX format and then load it into Caffe2. Once in
-Caffe2, we can run the model to double-check it was exported correctly,
-and we then show how to use Caffe2 features such as mobile exporter for
-executing the model on mobile devices.
-
-For this tutorial, you will need to install `onnx <https://github.com/onnx/onnx>`__
-and `Caffe2 <https://github.com/pytorch/pytorch>`__.
-You can get binary builds of onnx with
-``pip install onnx``.
-
-``NOTE``: This tutorial needs PyTorch master branch which can be installed by following
-the instructions `here <https://github.com/pytorch/pytorch#from-source>`__
-
-"""
-
-# Some standard imports
-import io
-import numpy as np
-
-from torch import nn
-import torch.utils.model_zoo as model_zoo
-import torch.onnx
-
-
-######################################################################
-# Super-resolution is a way of increasing the resolution of images, videos
-# and is widely used in image processing or video editing. For this
-# tutorial, we will first use a small super-resolution model with a dummy
-# input.
-#
-# First, let's create a SuperResolution model in PyTorch. `This
-# model <https://github.com/pytorch/examples/blob/master/super_resolution/model.py>`__
-# comes directly from PyTorch's examples without modification:
-#
-
-# Super Resolution model definition in PyTorch
-import torch.nn as nn
-import torch.nn.init as init
-
-
-class SuperResolutionNet(nn.Module):
-    def __init__(self, upscale_factor, inplace=False):
-        super(SuperResolutionNet, self).__init__()
-
-        self.relu = nn.ReLU(inplace=inplace)
-        self.conv1 = nn.Conv2d(1, 64, (5, 5), (1, 1), (2, 2))
-        self.conv2 = nn.Conv2d(64, 64, (3, 3), (1, 1), (1, 1))
-        self.conv3 = nn.Conv2d(64, 32, (3, 3), (1, 1), (1, 1))
-        self.conv4 = nn.Conv2d(32, upscale_factor ** 2, (3, 3), (1, 1), (1, 1))
-        self.pixel_shuffle = nn.PixelShuffle(upscale_factor)
-
-        self._initialize_weights()
-
-    def forward(self, x):
-        x = self.relu(self.conv1(x))
-        x = self.relu(self.conv2(x))
-        x = self.relu(self.conv3(x))
-        x = self.pixel_shuffle(self.conv4(x))
-        return x
-
-    def _initialize_weights(self):
-        init.orthogonal_(self.conv1.weight, init.calculate_gain('relu'))
-        init.orthogonal_(self.conv2.weight, init.calculate_gain('relu'))
-        init.orthogonal_(self.conv3.weight, init.calculate_gain('relu'))
-        init.orthogonal_(self.conv4.weight)
-
-# Create the super-resolution model by using the above model definition.
-torch_model = SuperResolutionNet(upscale_factor=3)
-
-
-######################################################################
-# Ordinarily, you would now train this model; however, for this tutorial,
-# we will instead download some pre-trained weights. Note that this model
-# was not trained fully for good accuracy and is used here for
-# demonstration purposes only.
-#
-
-# Load pretrained model weights
-model_url = 'https://s3.amazonaws.com/pytorch/test_data/export/superres_epoch100-44c6958e.pth'
-batch_size = 1    # just a random number
-
-# Initialize model with the pretrained weights
-map_location = lambda storage, loc: storage
-if torch.cuda.is_available():
-    map_location = None
-torch_model.load_state_dict(model_zoo.load_url(model_url, map_location=map_location))
-
-# set the train mode to false since we will only run the forward pass.
-torch_model.train(False)
-
-
-######################################################################
-# Exporting a model in PyTorch works via tracing. To export a model, you
-# call the ``torch.onnx._export()`` function. This will execute the model,
-# recording a trace of what operators are used to compute the outputs.
-# Because ``_export`` runs the model, we need provide an input tensor
-# ``x``. The values in this tensor are not important; it can be an image
-# or a random tensor as long as it is the right size.
-#
-# To learn more details about PyTorch's export interface, check out the
-# `torch.onnx documentation <https://pytorch.org/docs/master/onnx.html>`__.
-#
-
-# Input to the model
-x = torch.randn(batch_size, 1, 224, 224, requires_grad=True)
-
-# Export the model
-torch_out = torch.onnx._export(torch_model,             # model being run
-                               x,                       # model input (or a tuple for multiple inputs)
-                               "super_resolution.onnx", # where to save the model (can be a file or file-like object)
-                               export_params=True)      # store the trained parameter weights inside the model file
-
-
-######################################################################
-# ``torch_out`` is the output after executing the model. Normally you can
-# ignore this output, but here we will use it to verify that the model we
-# exported computes the same values when run in Caffe2.
-#
-# Now let's take the ONNX representation and use it in Caffe2. This part
-# can normally be done in a separate process or on another machine, but we
-# will continue in the same process so that we can verify that Caffe2 and
-# PyTorch are computing the same value for the network:
-#
-
-import onnx
-import caffe2.python.onnx.backend as onnx_caffe2_backend
-
-# Load the ONNX ModelProto object. model is a standard Python protobuf object
-model = onnx.load("super_resolution.onnx")
-
-# prepare the caffe2 backend for executing the model this converts the ONNX model into a
-# Caffe2 NetDef that can execute it. Other ONNX backends, like one for CNTK will be
-# availiable soon.
-prepared_backend = onnx_caffe2_backend.prepare(model)
-
-# run the model in Caffe2
-
-# Construct a map from input names to Tensor data.
-# The graph of the model itself contains inputs for all weight parameters, after the input image.
-# Since the weights are already embedded, we just need to pass the input image.
-# Set the first input.
-W = {model.graph.input[0].name: x.data.numpy()}
-
-# Run the Caffe2 net:
-c2_out = prepared_backend.run(W)[0]
-
-# Verify the numerical correctness upto 3 decimal places
-np.testing.assert_almost_equal(torch_out.data.cpu().numpy(), c2_out, decimal=3)
-
-print("Exported model has been executed on Caffe2 backend, and the result looks good!")
-
-######################################################################
-# We should see that the output of PyTorch and Caffe2 runs match
-# numerically up to 3 decimal places. As a side-note, if they do not match
-# then there is an issue that the operators in Caffe2 and PyTorch are
-# implemented differently and please contact us in that case.
-#
-
-
-######################################################################
-# Transfering SRResNet using ONNX
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-#
-
-
-######################################################################
-# Using the same process as above, we also transferred an interesting new
-# model "SRResNet" for super-resolution presented in `this
-# paper <https://arxiv.org/pdf/1609.04802.pdf>`__ (thanks to the authors
-# at Twitter for providing us code and pretrained parameters for the
-# purpose of this tutorial). The model definition and a pre-trained model
-# can be found
-# `here <https://gist.github.com/prigoyal/b245776903efbac00ee89699e001c9bd>`__.
-# Below is what SRResNet model input, output looks like. |SRResNet|
-#
-# .. |SRResNet| image:: /_static/img/SRResNet.png
-#
-
-
-######################################################################
-# Running the model on mobile devices
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-#
-
-
-######################################################################
-# So far we have exported a model from PyTorch and shown how to load it
-# and run it in Caffe2. Now that the model is loaded in Caffe2, we can
-# convert it into a format suitable for `running on mobile
-# devices <https://caffe2.ai/docs/mobile-integration.html>`__.
-#
-# We will use Caffe2's
-# `mobile\_exporter <https://github.com/pytorch/pytorch/blob/master/caffe2/python/predictor/mobile_exporter.py>`__
-# to generate the two model protobufs that can run on mobile. The first is
-# used to initialize the network with the correct weights, and the second
-# actual runs executes the model. We will continue to use the small
-# super-resolution model for the rest of this tutorial.
-#
-
-# extract the workspace and the model proto from the internal representation
-c2_workspace = prepared_backend.workspace
-c2_model = prepared_backend.predict_net
-
-# Now import the caffe2 mobile exporter
-from caffe2.python.predictor import mobile_exporter
-
-# call the Export to get the predict_net, init_net. These nets are needed for running things on mobile
-init_net, predict_net = mobile_exporter.Export(c2_workspace, c2_model, c2_model.external_input)
-
-# Let's also save the init_net and predict_net to a file that we will later use for running them on mobile
-with open('init_net.pb', "wb") as fopen:
-    fopen.write(init_net.SerializeToString())
-with open('predict_net.pb', "wb") as fopen:
-    fopen.write(predict_net.SerializeToString())
-
-
-######################################################################
-# ``init_net`` has the model parameters and the model input embedded in it
-# and ``predict_net`` will be used to guide the ``init_net`` execution at
-# run-time. In this tutorial, we will use the ``init_net`` and
-# ``predict_net`` generated above and run them in both normal Caffe2
-# backend and mobile and verify that the output high-resolution cat image
-# produced in both runs is the same.
-#
-# For this tutorial, we will use a famous cat image used widely which
-# looks like below
-#
-# .. figure:: /_static/img/cat_224x224.jpg
-#    :alt: cat
-#
-
-# Some standard imports
-from caffe2.proto import caffe2_pb2
-from caffe2.python import core, net_drawer, net_printer, visualize, workspace, utils
-
-import numpy as np
-import os
-import subprocess
-from PIL import Image
-from matplotlib import pyplot
-from skimage import io, transform
-
-
-######################################################################
-# First, let's load the image, pre-process it using standard skimage
-# python library. Note that this preprocessing is the standard practice of
-# processing data for training/testing neural networks.
-#
-
-# load the image
-img_in = io.imread("./_static/img/cat.jpg")
-
-# resize the image to dimensions 224x224
-img = transform.resize(img_in, [224, 224])
-
-# save this resized image to be used as input to the model
-io.imsave("./_static/img/cat_224x224.jpg", img)
-
-
-######################################################################
-# Now, as a next step, let's take the resized cat image and run the
-# super-resolution model in Caffe2 backend and save the output image. The
-# image processing steps below have been adopted from PyTorch
-# implementation of super-resolution model
-# `here <https://github.com/pytorch/examples/blob/master/super_resolution/super_resolve.py>`__
-#
-
-# load the resized image and convert it to Ybr format
-img = Image.open("./_static/img/cat_224x224.jpg")
-img_ycbcr = img.convert('YCbCr')
-img_y, img_cb, img_cr = img_ycbcr.split()
-
-# Let's run the mobile nets that we generated above so that caffe2 workspace is properly initialized
-workspace.RunNetOnce(init_net)
-workspace.RunNetOnce(predict_net)
-
-# Caffe2 has a nice net_printer to be able to inspect what the net looks like and identify
-# what our input and output blob names are.
-print(net_printer.to_string(predict_net))
-
-
-######################################################################
-# From the above output, we can see that input is named "9" and output is
-# named "27"(it is a little bit weird that we will have numbers as blob
-# names but this is because the tracing JIT produces numbered entries for
-# the models)
-#
-
-# Now, let's also pass in the resized cat image for processing by the model.
-workspace.FeedBlob("9", np.array(img_y)[np.newaxis, np.newaxis, :, :].astype(np.float32))
-
-# run the predict_net to get the model output
-workspace.RunNetOnce(predict_net)
-
-# Now let's get the model output blob
-img_out = workspace.FetchBlob("27")
-
-
-######################################################################
-# Now, we'll refer back to the post-processing steps in PyTorch
-# implementation of super-resolution model
-# `here <https://github.com/pytorch/examples/blob/master/super_resolution/super_resolve.py>`__
-# to construct back the final output image and save the image.
-#
-
-img_out_y = Image.fromarray(np.uint8((img_out[0, 0]).clip(0, 255)), mode='L')
-
-# get the output image follow post-processing step from PyTorch implementation
-final_img = Image.merge(
-    "YCbCr", [
-        img_out_y,
-        img_cb.resize(img_out_y.size, Image.BICUBIC),
-        img_cr.resize(img_out_y.size, Image.BICUBIC),
-    ]).convert("RGB")
-
-# Save the image, we will compare this with the output image from mobile device
-final_img.save("./_static/img/cat_superres.jpg")
-
-
-######################################################################
-# We have finished running our mobile nets in pure Caffe2 backend and now,
-# let's execute the model on an Android device and get the model output.
-#
-# ``NOTE``: for Android development, ``adb`` shell is needed otherwise the
-# following section of tutorial will not run.
-#
-# In our first step of runnig model on mobile, we will push a native speed
-# benchmark binary for mobile device to adb. This binary can execute the
-# model on mobile and also export the model output that we can retrieve
-# later. The binary is available
-# `here <https://github.com/caffe2/caffe2/blob/master/caffe2/binaries/speed_benchmark.cc>`__.
-# In order to build the binary, execute the ``build_android.sh`` script
-# following the instructions
-# `here <https://github.com/caffe2/caffe2/blob/master/scripts/build_android.sh>`__.
-#
-# ``NOTE``: You need to have ``ANDROID_NDK`` installed and set your env
-# variable ``ANDROID_NDK=path to ndk root``
-#
-
-# let's first push a bunch of stuff to adb, specify the path for the binary
-CAFFE2_MOBILE_BINARY = ('caffe2/binaries/speed_benchmark')
-
-# we had saved our init_net and proto_net in steps above, we use them now.
-# Push the binary and the model protos
-os.system('adb push ' + CAFFE2_MOBILE_BINARY + ' /data/local/tmp/')
-os.system('adb push init_net.pb /data/local/tmp')
-os.system('adb push predict_net.pb /data/local/tmp')
-
-# Let's serialize the input image blob to a blob proto and then send it to mobile for execution.
-with open("input.blobproto", "wb") as fid:
-    fid.write(workspace.SerializeBlob("9"))
-
-# push the input image blob to adb
-os.system('adb push input.blobproto /data/local/tmp/')
-
-# Now we run the net on mobile, look at the speed_benchmark --help for what various options mean
-os.system(
-    'adb shell /data/local/tmp/speed_benchmark '                     # binary to execute
-    '--init_net=/data/local/tmp/super_resolution_mobile_init.pb '    # mobile init_net
-    '--net=/data/local/tmp/super_resolution_mobile_predict.pb '      # mobile predict_net
-    '--input=9 '                                                     # name of our input image blob
-    '--input_file=/data/local/tmp/input.blobproto '                  # serialized input image
-    '--output_folder=/data/local/tmp '                               # destination folder for saving mobile output
-    '--output=27,9 '                                                 # output blobs we are interested in
-    '--iter=1 '                                                      # number of net iterations to execute
-    '--caffe2_log_level=0 '
-)
-
-# get the model output from adb and save to a file
-os.system('adb pull /data/local/tmp/27 ./output.blobproto')
-
-
-# We can recover the output content and post-process the model using same steps as we followed earlier
-blob_proto = caffe2_pb2.BlobProto()
-blob_proto.ParseFromString(open('./output.blobproto').read())
-img_out = utils.Caffe2TensorToNumpyArray(blob_proto.tensor)
-img_out_y = Image.fromarray(np.uint8((img_out[0,0]).clip(0, 255)), mode='L')
-final_img = Image.merge(
-    "YCbCr", [
-        img_out_y,
-        img_cb.resize(img_out_y.size, Image.BICUBIC),
-        img_cr.resize(img_out_y.size, Image.BICUBIC),
-    ]).convert("RGB")
-final_img.save("./_static/img/cat_superres_mobile.jpg")
-
-
-######################################################################
-# Now, you can compare the image ``cat_superres.jpg`` (model output from
-# pure caffe2 backend execution) and ``cat_superres_mobile.jpg`` (model
-# output from mobile execution) and see that both the images look same. If
-# they don't look same, something went wrong with execution on mobile and
-# in that case, please contact Caffe2 community. You should expect to see
-# the output image to look like following:
-#
-# .. figure:: /_static/img/cat_output1.png
-#    :alt: output\_cat
-#
-#
-# Using the above steps, you can deploy your models on mobile easily.
-# Also, for more information on caffe2 mobile backend, checkout
-# `caffe2-android-demo <https://caffe2.ai/docs/AI-Camera-demo-android.html>`__.
-#
diff --git a/advanced_source/torch-script-parallelism.rst b/advanced_source/torch-script-parallelism.rst
new file mode 100644
index 00000000000..56c4bcbaae7
--- /dev/null
+++ b/advanced_source/torch-script-parallelism.rst
@@ -0,0 +1,3 @@
+.. warning::
+    TorchScript is deprecated, please use 
+    `torch.export <https://docs.pytorch.org/tutorials/intermediate/torch_export_tutorial.html>`__ instead.
\ No newline at end of file
diff --git a/advanced_source/torch_script_custom_ops.rst b/advanced_source/torch_script_custom_ops.rst
index dd8dea4470d..01bc497d38e 100644
--- a/advanced_source/torch_script_custom_ops.rst
+++ b/advanced_source/torch_script_custom_ops.rst
@@ -1,1082 +1,6 @@
-Extending TorchScript with Custom C++ Operators
-===============================================
-
-The PyTorch 1.0 release introduced a new programming model to PyTorch called
-`TorchScript <https://pytorch.org/docs/master/jit.html>`_. TorchScript is a
-subset of the Python programming language which can be parsed, compiled and
-optimized by the TorchScript compiler. Further, compiled TorchScript models have
-the option of being serialized into an on-disk file format, which you can
-subsequently load and run from pure C++ (as well as Python) for inference.
-
-TorchScript supports a large subset of operations provided by the ``torch``
-package, allowing you to express many kinds of complex models purely as a series
-of tensor operations from PyTorch's "standard library". Nevertheless, there may
-be times where you find yourself in need of extending TorchScript with a custom
-C++ or CUDA function. While we recommend that you only resort to this option if
-your idea cannot be expressed (efficiently enough) as a simple Python function,
-we do provide a very friendly and simple interface for defining custom C++ and
-CUDA kernels using `ATen <https://pytorch.org/cppdocs/#aten>`_, PyTorch's high
-performance C++ tensor library. Once bound into TorchScript, you can embed these
-custom kernels (or "ops") into your TorchScript model and execute them both in
-Python and in their serialized form directly in C++.
-
-The following paragraphs give an example of writing a TorchScript custom op to
-call into `OpenCV <https://www.opencv.org>`_, a computer vision library written
-in C++. We will discuss how to work with tensors in C++, how to efficiently
-convert them to third party tensor formats (in this case, OpenCV ``Mat``s), how
-to register your operator with the TorchScript runtime and finally how to
-compile the operator and use it in Python and C++.
-
-Implementing the Custom Operator in C++
----------------------------------------
-
-For this tutorial, we'll be exposing the `warpPerspective
-<https://docs.opencv.org/2.4/modules/imgproc/doc/geometric_transformations.html#warpperspective>`_
-function, which applies a perspective transformation to an image, from OpenCV to
-TorchScript as a custom operator. The first step is to write the implementation
-of our custom operator in C++. Let's call the file for this implementation
-``op.cpp`` and make it look like this:
-
-.. code-block:: cpp
-
-  #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<float>());
-    cv::Mat warp_mat(/*rows=*/warp.size(0),
-                     /*cols=*/warp.size(1),
-                     /*type=*/CV_32FC1,
-                     /*data=*/warp.data<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();
-  }
-
-The code for this operator is quite short. At the top of the file, we include
-the OpenCV header file, ``opencv2/opencv.hpp``, alongside the ``torch/script.h``
-header which exposes all the necessary goodies from PyTorch's C++ API that we
-need to write custom TorchScript operators. Our function ``warp_perspective``
-takes two arguments: an input ``image`` and the ``warp`` transformation matrix
-we wish to apply to the image. The type of these inputs is ``torch::Tensor``,
-PyTorch's tensor type in C++ (which is also the underlying type of all tensors
-in Python). The return type of our ``warp_perspective`` function will also be a
-``torch::Tensor``.
-
-.. tip::
-
-  See `this note <https://pytorch.org/cppdocs/notes/tensor_basics.html>`_ for
-  more information about ATen, the library that provides the ``Tensor`` class to
-  PyTorch. Further, `this tutorial
-  <https://pytorch.org/cppdocs/notes/tensor_creation.html>`_ describes how to
-  allocate and initialize new tensor objects in C++ (not required for this
-  operator).
-
-.. attention::
-
-  The TorchScript compiler understands a fixed number of types. Only these types
-  can be used as arguments to your custom operator. Currently these types are:
-  ``torch::Tensor``, ``torch::Scalar``, ``double``, ``int64_t`` and
-  ``std::vector`` s of these types. Note that *only* ``double`` and *not*
-  ``float``, and *only* ``int64_t`` and *not* other integral types such as
-  ``int``, ``short`` or ``long`` are supported.
-
-Inside of our function, the first thing we need to do is convert our PyTorch
-tensors to OpenCV matrices, as OpenCV's ``warpPerspective`` expects ``cv::Mat``
-objects as inputs. Fortunately, there is a way to do this **without copying
-any** data. In the first few lines,
-
-.. code-block:: cpp
-
-  cv::Mat image_mat(/*rows=*/image.size(0),
-                    /*cols=*/image.size(1),
-                    /*type=*/CV_32FC1,
-                    /*data=*/image.data<float>());
-
-we are calling `this constructor
-<https://docs.opencv.org/trunk/d3/d63/classcv_1_1Mat.html#a922de793eabcec705b3579c5f95a643e>`_
-of the OpenCV ``Mat`` class to convert our tensor to a ``Mat`` object. We pass
-it the number of rows and columns of the original ``image`` tensor, the datatype
-(which we'll fix as ``float32`` for this example), and finally a raw pointer to
-the underlying data -- a ``float*``. What is special about this constructor of
-the ``Mat`` class is that it does not copy the input data. Instead, it will
-simply reference this memory for all operations performed on the ``Mat``. If an
-in-place operation is performed on the ``image_mat``, this will be reflected in
-the original ``image`` tensor (and vice-versa). This allows us to call
-subsequent OpenCV routines with the library's native matrix type, even though
-we're actually storing the data in a PyTorch tensor. We repeat this procedure to
-convert the ``warp`` PyTorch tensor to the ``warp_mat`` OpenCV matrix:
-
-.. code-block:: cpp
-
-  cv::Mat warp_mat(/*rows=*/warp.size(0),
-                   /*cols=*/warp.size(1),
-                   /*type=*/CV_32FC1,
-                   /*data=*/warp.data<float>());
-
-Next, we are ready to call the OpenCV function we were so eager to use in
-TorchScript: ``warpPerspective``. For this, we pass the OpenCV function the
-``image_mat`` and ``warp_mat`` matrices, as well as an empty output matrix
-called ``output_mat``. We also specify the size ``dsize`` we want the output
-matrix (image) to be. It is hardcoded to ``8 x 8`` for this example:
-
-.. code-block:: cpp
-
-  cv::Mat output_mat;
-  cv::warpPerspective(image_mat, output_mat, warp_mat, /*dsize=*/{8, 8});
-
-The final step in our custom operator implementation is to convert the
-``output_mat`` back into a PyTorch tensor, so that we can further use it in
-PyTorch. This is strikingly similar to what we did earlier to convert in the
-other direction. In this case, PyTorch provides a ``torch::from_blob`` method. A
-*blob* in this case is intended to mean some opaque, flat pointer to memory that
-we want to interpret as a PyTorch tensor. The call to ``torch::from_blob`` looks
-like this:
-
-.. code-block:: cpp
-
-  torch::from_blob(output_mat.ptr<float>(), /*sizes=*/{8, 8})
-
-We use the ``.ptr<float>()`` method on the OpenCV ``Mat`` class to get a raw
-pointer to the underlying data (just like ``.data<float>()`` for the PyTorch
-tensor earlier). We also specify the output shape of the tensor, which we
-hardcoded as ``8 x 8``. The output of ``torch::from_blob`` is then a
-``torch::Tensor``, pointing to the memory owned by the OpenCV matrix.
-
-Before returning this tensor from our operator implementation, we must call
-``.clone()`` on the tensor to perform a memory copy of the underlying data. The
-reason for this is that ``torch::from_blob`` returns a tensor that does not own
-its data. At that point, the data is still owned by the OpenCV matrix. However,
-this OpenCV matrix will go out of scope and be deallocated at the end of the
-function. If we returned the ``output`` tensor as-is, it would point to invalid
-memory by the time we use it outside the function. Calling ``.clone()`` returns
-a new tensor with a copy of the original data that the new tensor owns itself.
-It is thus safe to return to the outside world.
-
-Registering the Custom Operator with TorchScript
-------------------------------------------------
-
-Now that have implemented our custom operator in C++, we need to *register* it
-with the TorchScript runtime and compiler. This will allow the TorchScript
-compiler to resolve references to our custom operator in TorchScript code.
-Registration is very simple. For our case, we need to write:
-
-.. code-block:: cpp
-
-  static auto registry =
-    torch::jit::RegisterOperators("my_ops::warp_perspective", &warp_perspective);
-
-somewhere in the global scope of our ``op.cpp`` file. This creates a global
-variable ``registry``, which will register our operator with TorchScript in its
-constructor (i.e. exactly once per program). We specify the name of the
-operator, and a pointer to its implementation (the function we wrote earlier).
-The name consists of two parts: a *namespace* (``my_ops``) and a name for the
-particular operator we are registering (``warp_perspective``). The namespace and
-operator name are separated by two colons (``::``).
-
-.. tip::
-
-  If you want to register more than one operator, you can chain calls to
-  ``.op()`` after the constructor:
-
-  .. code-block:: cpp
-
-    static auto registry =
-      torch::jit::RegisterOperators("my_ops::warp_perspective", &warp_perspective)
-      .op("my_ops::another_op", &another_op)
-      .op("my_ops::and_another_op", &and_another_op);
-
-Behind the scenes, ``RegisterOperators`` will perform a number of fairly
-complicated C++ template metaprogramming magic tricks to infer the argument and
-return value types of the function pointer we pass it (``&warp_perspective``).
-This information is used to form a *function schema* for our operator. A
-function schema is a structured representation of an operator -- a kind of
-"signature" or "prototype" -- used by the TorchScript compiler to verify
-correctness in TorchScript programs.
-
-Building the Custom Operator
-----------------------------
-
-Now that we have implemented our custom operator in C++ and written its
-registration code, it is time to build the operator into a (shared) library that
-we can load into Python for research and experimentation, or into C++ for
-inference in a no-Python environment. There exist multiple ways to build our
-operator, using either pure CMake, or Python alternatives like ``setuptools``.
-For brevity, the paragraphs below only discuss the CMake approach. The appendix
-of this tutorial dives into the Python based alternatives.
-
-Building with CMake
-*******************
-
-To build our custom operator into a shared library using the `CMake
-<https://cmake.org>`_ build system, we need to write a short ``CMakeLists.txt``
-file and place it with our previous ``op.cpp`` file. For this, let's agree on a
-a directory structure that looks like this::
-
-  warp-perspective/
-    op.cpp
-    CMakeLists.txt
-
-Also, make sure to grab the latest version of the LibTorch distribution, which
-packages PyTorch's C++ libraries and CMake build files, from `pytorch.org
-<https://pytorch.org/get-started/locally>`_. Place the unzipped distribution
-somewhere accessible in your file system. The following paragraphs will refer to
-that location as ``/path/to/libtorch``. The contents of our ``CMakeLists.txt``
-file should then be the following:
-
-.. code-block:: cmake
-
-  cmake_minimum_required(VERSION 3.1 FATAL_ERROR)
-  project(warp_perspective)
-
-  find_package(Torch REQUIRED)
-  find_package(OpenCV REQUIRED)
-
-  # Define our library target
-  add_library(warp_perspective SHARED op.cpp)
-  # Enable C++11
-  target_compile_features(warp_perspective PRIVATE cxx_range_for)
-  # Link against LibTorch
-  target_link_libraries(warp_perspective "${TORCH_LIBRARIES}")
-  # Link against OpenCV
-  target_link_libraries(warp_perspective opencv_core opencv_imgproc)
+..
+  TODO(gmagogsfm): Replace/delete this document by 2.9 release. https://github.com/pytorch/tutorials/issues/3456
 
 .. warning::
-
-  This setup makes some assumptions about the build environment, particularly
-  what pertains to the installation of OpenCV. The above ``CMakeLists.txt`` file
-  was tested inside a Docker container running Ubuntu Xenial with
-  ``libopencv-dev`` installed via ``apt``. If it does not work for you and you
-  feel stuck, please use the ``Dockerfile`` in the `accompanying tutorial
-  repository <https://github.com/pytorch/extension-script>`_ to
-  build an isolated, reproducible environment in which to play around with the
-  code from this tutorial. If you run into further troubles, please file an
-  issue in the tutorial repository or post a question in `our forum
-  <https://discuss.pytorch.org/>`_.
-
-To now build our operator, we can run the following commands from our
-``warp_perspective`` folder:
-
-.. code-block:: shell
-
-  $ mkdir build
-  $ cd build
-  $ cmake -DCMAKE_PREFIX_PATH=/path/to/libtorch ..
-  -- The C compiler identification is GNU 5.4.0
-  -- The CXX compiler identification is GNU 5.4.0
-  -- Check for working C compiler: /usr/bin/cc
-  -- Check for working C compiler: /usr/bin/cc -- works
-  -- Detecting C compiler ABI info
-  -- Detecting C compiler ABI info - done
-  -- Detecting C compile features
-  -- Detecting C compile features - done
-  -- Check for working CXX compiler: /usr/bin/c++
-  -- Check for working CXX compiler: /usr/bin/c++ -- works
-  -- Detecting CXX compiler ABI info
-  -- Detecting CXX compiler ABI info - done
-  -- Detecting CXX compile features
-  -- Detecting CXX compile features - done
-  -- Looking for pthread.h
-  -- Looking for pthread.h - found
-  -- Looking for pthread_create
-  -- Looking for pthread_create - not found
-  -- Looking for pthread_create in pthreads
-  -- Looking for pthread_create in pthreads - not found
-  -- Looking for pthread_create in pthread
-  -- Looking for pthread_create in pthread - found
-  -- Found Threads: TRUE
-  -- Found torch: /libtorch/lib/libtorch.so
-  -- Configuring done
-  -- Generating done
-  -- Build files have been written to: /warp_perspective/build
-  $ make -j
-  Scanning dependencies of target warp_perspective
-  [ 50%] Building CXX object CMakeFiles/warp_perspective.dir/op.cpp.o
-  [100%] Linking CXX shared library libwarp_perspective.so
-  [100%] Built target warp_perspective
-
-which will place a ``libwarp_perspective.so`` shared library file in the
-``build`` folder. In the ``cmake`` command above, you should replace
-``/path/to/libtorch`` with the path to your unzipped LibTorch distribution.
-
-We will explore how to use and call our operator in detail further below, but to
-get an early sensation of success, we can try running the following code in
-Python:
-
-.. code-block:: python
-
-  >>> import torch
-  >>> torch.ops.load_library("/path/to/libwarp_perspective.so")
-  >>> print(torch.ops.my_ops.warp_perspective)
-
-Here, ``/path/to/libwarp_perspective.so`` should be a relative or absolute path
-to the ``libwarp_perspective.so`` shared library we just built. If all goes
-well, this should print something like
-
-.. code-block:: python
-
-  <built-in method my_ops::warp_perspective of PyCapsule object at 0x7f618fc6fa50>
-
-which is the Python function we will later use to invoke our custom operator.
-
-Using the TorchScript Custom Operator in Python
------------------------------------------------
-
-Once our custom operator is built into a shared library  we are ready to use
-this operator in our TorchScript models in Python. There are two parts to this:
-first loading the operator into Python, and second using the operator in
-TorchScript code.
-
-You already saw how to import your operator into Python:
-``torch.ops.load_library()``. This function takes the path to a shared library
-containing custom operators, and loads it into the current process. Loading the
-shared library will also execute the constructor of the global
-``RegisterOperators`` object we placed into our custom operator implementation
-file. This will register our custom operator with the TorchScript compiler and
-allow us to use that operator in TorchScript code.
-
-You can refer to your loaded operator as ``torch.ops.<namespace>.<function>``,
-where ``<namespace>`` is the namespace part of your operator name, and
-``<function>`` the function name of your operator. For the operator we wrote
-above, the namespace was ``my_ops`` and the function name ``warp_perspective``,
-which means our operator is available as ``torch.ops.my_ops.warp_perspective``.
-While this function can be used in scripted or traced TorchScript modules, we
-can also just use it in vanilla eager PyTorch and pass it regular PyTorch
-tensors:
-
-.. code-block:: python
-
-  >>> import torch
-  >>> torch.ops.load_library("libwarp_perspective.so")
-  >>> torch.ops.my_ops.warp_perspective(torch.randn(32, 32), torch.rand(3, 3))
-  tensor([[0.0000, 0.3218, 0.4611,  ..., 0.4636, 0.4636, 0.4636],
-        [0.3746, 0.0978, 0.5005,  ..., 0.4636, 0.4636, 0.4636],
-        [0.3245, 0.0169, 0.0000,  ..., 0.4458, 0.4458, 0.4458],
-        ...,
-        [0.1862, 0.1862, 0.1692,  ..., 0.0000, 0.0000, 0.0000],
-        [0.1862, 0.1862, 0.1692,  ..., 0.0000, 0.0000, 0.0000],
-        [0.1862, 0.1862, 0.1692,  ..., 0.0000, 0.0000, 0.0000]])
-
-
-.. note::
-
-	What happens behind the scenes is that the first time you access
-	``torch.ops.namespace.function`` in Python, the TorchScript compiler (in C++
-	land) will see if a function ``namespace::function`` has been registered, and
-	if so, return a Python handle to this function that we can subsequently use to
-	call into our C++ operator implementation from Python. This is one noteworthy
-	difference between TorchScript custom operators and C++ extensions: C++
-	extensions are bound manually using pybind11, while TorchScript custom ops are
-	bound on the fly by PyTorch itself. Pybind11 gives you more flexibility with
-	regards to what types and classes you can bind into Python and is thus
-	recommended for purely eager code, but it is not supported for TorchScript
-	ops.
-
-From here on, you can use your custom operator in scripted or traced code just
-as you would other functions from the ``torch`` package. In fact, "standard
-library" functions like ``torch.matmul`` go through largely the same
-registration path as custom operators, which makes custom operators really
-first-class citizens when it comes to how and where they can be used in
-TorchScript.
-
-Using the Custom Operator with Tracing
-**************************************
-
-Let's start by embedding our operator in a traced function. Recall that for
-tracing, we start with some vanilla Pytorch code:
-
-.. code-block:: python
-
-  def compute(x, y, z):
-      return x.matmul(y) + torch.relu(z)
-
-and then call ``torch.jit.trace`` on it. We further pass ``torch.jit.trace``
-some example inputs, which it will forward to our implementation to record the
-sequence of operations that occur as the inputs flow through it. The result of
-this is effectively a "frozen" version of the eager PyTorch program, which the
-TorchScript compiler can further analyze, optimize and serialize:
-
-.. code-block:: python
-
-  >>> inputs = [torch.randn(4, 8), torch.randn(8, 5), torch.randn(4, 5)]
-  >>> trace = torch.jit.trace(compute, inputs)
-  >>> print(trace.graph)
-  graph(%x : Float(4, 8)
-      %y : Float(8, 5)
-      %z : Float(4, 5)) {
-    %3 : Float(4, 5) = aten::matmul(%x, %y)
-    %4 : Float(4, 5) = aten::relu(%z)
-    %5 : int = prim::Constant[value=1]()
-    %6 : Float(4, 5) = aten::add(%3, %4, %5)
-    return (%6);
-  }
-
-Now, the exciting revelation is that we can simply drop our custom operator into
-our PyTorch trace as if it were ``torch.relu`` or any other ``torch`` function:
-
-.. code-block:: python
-
-  torch.ops.load_library("libwarp_perspective.so")
-
-  def compute(x, y, z):
-      x = torch.ops.my_ops.warp_perspective(x, torch.eye(3))
-      return x.matmul(y) + torch.relu(z)
-
-and then trace it as before:
-
-.. code-block:: python
-
-  >>> inputs = [torch.randn(4, 8), torch.randn(8, 5), torch.randn(8, 5)]
-  >>> trace = torch.jit.trace(compute, inputs)
-  >>> print(trace.graph)
-  graph(%x.1 : Float(4, 8)
-      %y : Float(8, 5)
-      %z : Float(8, 5)) {
-      %3 : int = prim::Constant[value=3]()
-      %4 : int = prim::Constant[value=6]()
-      %5 : int = prim::Constant[value=0]()
-      %6 : int[] = prim::Constant[value=[0, -1]]()
-      %7 : Float(3, 3) = aten::eye(%3, %4, %5, %6)
-      %x : Float(8, 8) = my_ops::warp_perspective(%x.1, %7)
-      %11 : Float(8, 5) = aten::matmul(%x, %y)
-      %12 : Float(8, 5) = aten::relu(%z)
-      %13 : int = prim::Constant[value=1]()
-      %14 : Float(8, 5) = aten::add(%11, %12, %13)
-      return (%14);
-    }
-
-Integrating TorchScript custom ops into traced PyTorch code is as easy as this!
-
-Using the Custom Operator with Script
-*************************************
-
-Besides tracing, another way to arrive at a TorchScript representation of a
-PyTorch program is to directly write your code *in* TorchScript. TorchScript is
-largely a subset of the Python language, with some restrictions that make it
-easier for the TorchScript compiler to reason about programs. You turn your
-regular PyTorch code into TorchScript by annotating it with
-``@torch.jit.script`` for free functions and ``@torch.jit.script_method`` for
-methods in a class (which must also derive from ``torch.jit.ScriptModule``). See
-`here <https://pytorch.org/docs/master/jit.html>`_ for more details on
-TorchScript annotations.
-
-One particular reason to use TorchScript instead of tracing is that tracing is
-unable to capture control flow in PyTorch code. As such, let us consider this
-function which does use control flow:
-
-.. code-block:: python
-
-  def compute(x, y):
-    if bool(x[0][0] == 42):
-        z = 5
-    else:
-        z = 10
-    return x.matmul(y) + z
-
-To convert this function from vanilla PyTorch to TorchScript, we annotate it
-with ``@torch.jit.script``:
-
-.. code-block:: python
-
-  @torch.jit.script
-  def compute(x, y):
-    if bool(x[0][0] == 42):
-        z = 5
-    else:
-        z = 10
-    return x.matmul(y) + z
-
-This will just-in-time compile the ``compute`` function into a graph
-representation, which we can inspect in the ``compute.graph`` property:
-
-.. code-block:: python
-
-  >>> compute.graph
-  graph(%x : Dynamic
-      %y : Dynamic) {
-    %14 : int = prim::Constant[value=1]()
-    %2 : int = prim::Constant[value=0]()
-    %7 : int = prim::Constant[value=42]()
-    %z.1 : int = prim::Constant[value=5]()
-    %z.2 : int = prim::Constant[value=10]()
-    %4 : Dynamic = aten::select(%x, %2, %2)
-    %6 : Dynamic = aten::select(%4, %2, %2)
-    %8 : Dynamic = aten::eq(%6, %7)
-    %9 : bool = prim::TensorToBool(%8)
-    %z : int = prim::If(%9)
-      block0() {
-        -> (%z.1)
-      }
-      block1() {
-        -> (%z.2)
-      }
-    %13 : Dynamic = aten::matmul(%x, %y)
-    %15 : Dynamic = aten::add(%13, %z, %14)
-    return (%15);
-  }
-
-And now, just like before, we can use our custom operator like any other
-function inside of our script code:
-
-.. code-block:: python
-
-  torch.ops.load_library("libwarp_perspective.so")
-
-  @torch.jit.script
-  def compute(x, y):
-    if bool(x[0] == 42):
-        z = 5
-    else:
-        z = 10
-    x = torch.ops.my_ops.warp_perspective(x, torch.eye(3))
-    return x.matmul(y) + z
-
-When the TorchScript compiler sees the reference to
-``torch.ops.my_ops.warp_perspective``, it will find the implementation we
-registered via the ``RegisterOperators`` object in C++, and compile it into its
-graph representation:
-
-.. code-block:: python
-
-  >>> compute.graph
-  graph(%x.1 : Dynamic
-      %y : Dynamic) {
-      %20 : int = prim::Constant[value=1]()
-      %16 : int[] = prim::Constant[value=[0, -1]]()
-      %14 : int = prim::Constant[value=6]()
-      %2 : int = prim::Constant[value=0]()
-      %7 : int = prim::Constant[value=42]()
-      %z.1 : int = prim::Constant[value=5]()
-      %z.2 : int = prim::Constant[value=10]()
-      %13 : int = prim::Constant[value=3]()
-      %4 : Dynamic = aten::select(%x.1, %2, %2)
-      %6 : Dynamic = aten::select(%4, %2, %2)
-      %8 : Dynamic = aten::eq(%6, %7)
-      %9 : bool = prim::TensorToBool(%8)
-      %z : int = prim::If(%9)
-        block0() {
-          -> (%z.1)
-        }
-        block1() {
-          -> (%z.2)
-        }
-      %17 : Dynamic = aten::eye(%13, %14, %2, %16)
-      %x : Dynamic = my_ops::warp_perspective(%x.1, %17)
-      %19 : Dynamic = aten::matmul(%x, %y)
-      %21 : Dynamic = aten::add(%19, %z, %20)
-      return (%21);
-    }
-
-Notice in particular the reference to ``my_ops::warp_perspective`` at the end of
-the graph.
-
-.. attention::
-
-	The TorchScript graph representation is still subject to change. Do not rely
-	on it looking like this.
-
-And that's really it when it comes to using our custom operator in Python. In
-short, you import the library containing your operator(s) using
-``torch.ops.load_library``, and call your custom op like any other ``torch``
-operator from your traced or scripted TorchScript code.
-
-Using the TorchScript Custom Operator in C++
---------------------------------------------
-
-One useful feature of TorchScript is the ability to serialize a model into an
-on-disk file. This file can be sent over the wire, stored in a file system or,
-more importantly, be dynamically deserialized and executed without needing to
-keep the original source code around. This is possible in Python, but also in
-C++. For this, PyTorch provides `a pure C++ API <https://pytorch.org/cppdocs/>`_
-for deserializing as well as executing TorchScript models. If you haven't yet,
-please read `the tutorial on loading and running serialized TorchScript models
-in C++ <https://pytorch.org/tutorials/advanced/cpp_export.html>`_, on which the
-next few paragraphs will build.
-
-In short, custom operators can be executed just like regular ``torch`` operators
-even when deserialized from a file and run in C++. The only requirement for this
-is to link the custom operator shared library we built earlier with the C++
-application in which we execute the model. In Python, this worked simply calling
-``torch.ops.load_library``. In C++, you need to link the shared library with
-your main application in whatever build system you are using. The following
-example will showcase this using CMake.
-
-.. note::
-
-	Technically, you can also dynamically load the shared library into your C++
-	application at runtime in much the same way we did it in Python. On Linux,
-	`you can do this with dlopen
-	<https://tldp.org/HOWTO/Program-Library-HOWTO/dl-libraries.html>`_. There exist
-	equivalents on other platforms.
-
-Building on the C++ execution tutorial linked above, let's start with a minimal
-C++ application in one file, ``main.cpp`` in a different folder from our
-custom operator, that loads and executes a serialized TorchScript model:
-
-.. code-block:: cpp
-
-  #include <torch/script.h> // One-stop header.
-
-  #include <iostream>
-  #include <memory>
-
-
-  int main(int argc, const char* argv[]) {
-    if (argc != 2) {
-      std::cerr << "usage: example-app <path-to-exported-script-module>\n";
-      return -1;
-    }
-
-    // Deserialize the ScriptModule from a file using torch::jit::load().
-    std::shared_ptr<torch::jit::script::Module> module = torch::jit::load(argv[1]);
-
-    std::vector<torch::jit::IValue> inputs;
-    inputs.push_back(torch::randn({4, 8}));
-    inputs.push_back(torch::randn({8, 5}));
-
-    torch::Tensor output = module->forward(std::move(inputs)).toTensor();
-
-    std::cout << output << std::endl;
-  }
-
-Along with a small ``CMakeLists.txt`` file:
-
-.. code-block:: cmake
-
-  cmake_minimum_required(VERSION 3.1 FATAL_ERROR)
-  project(example_app)
-
-  find_package(Torch REQUIRED)
-
-  add_executable(example_app main.cpp)
-  target_link_libraries(example_app "${TORCH_LIBRARIES}")
-  target_compile_features(example_app PRIVATE cxx_range_for)
-
-At this point, we should be able to build the application:
-
-.. code-block:: cpp
-
-  $ mkdir build
-  $ cd build
-  $ cmake -DCMAKE_PREFIX_PATH=/path/to/libtorch ..
-  -- The C compiler identification is GNU 5.4.0
-  -- The CXX compiler identification is GNU 5.4.0
-  -- Check for working C compiler: /usr/bin/cc
-  -- Check for working C compiler: /usr/bin/cc -- works
-  -- Detecting C compiler ABI info
-  -- Detecting C compiler ABI info - done
-  -- Detecting C compile features
-  -- Detecting C compile features - done
-  -- Check for working CXX compiler: /usr/bin/c++
-  -- Check for working CXX compiler: /usr/bin/c++ -- works
-  -- Detecting CXX compiler ABI info
-  -- Detecting CXX compiler ABI info - done
-  -- Detecting CXX compile features
-  -- Detecting CXX compile features - done
-  -- Looking for pthread.h
-  -- Looking for pthread.h - found
-  -- Looking for pthread_create
-  -- Looking for pthread_create - not found
-  -- Looking for pthread_create in pthreads
-  -- Looking for pthread_create in pthreads - not found
-  -- Looking for pthread_create in pthread
-  -- Looking for pthread_create in pthread - found
-  -- Found Threads: TRUE
-  -- Found torch: /libtorch/lib/libtorch.so
-  -- Configuring done
-  -- Generating done
-  -- Build files have been written to: /example_app/build
-  $ make -j
-  Scanning dependencies of target example_app
-  [ 50%] Building CXX object CMakeFiles/example_app.dir/main.cpp.o
-  [100%] Linking CXX executable example_app
-  [100%] Built target example_app
-
-And run it without passing a model just yet:
-
-.. code-block:: cpp
-
-  $ ./example_app
-  usage: example_app <path-to-exported-script-module>
-
-Next, let's serialize the script function we wrote earlier that uses our custom
-operator:
-
-.. code-block:: python
-
-  torch.ops.load_library("libwarp_perspective.so")
-
-  @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("example.pt")
-
-The last line will serialize the script function into a file called
-"example.pt". If we then pass this serialized model to our C++ application, we
-can run it straight away:
-
-.. code-block:: cpp
-
-  $ ./example_app example.pt
-  terminate called after throwing an instance of 'torch::jit::script::ErrorReport'
-  what():
-  Schema not found for node. File a bug report.
-  Node: %16 : Dynamic = my_ops::warp_perspective(%0, %19)
-
-Or maybe not. Maybe not just yet. Of course! We haven't linked the custom
-operator library with our application yet. Let's do this right now, and to do it
-properly let's update our file organization slightly, to look like this::
-
-  example_app/
-    CMakeLists.txt
-    main.cpp
-    warp_perspective/
-      CMakeLists.txt
-      op.cpp
-
-This will allow us to add the ``warp_perspective`` library CMake target as a
-subdirectory of our application target. The top level ``CMakeLists.txt`` in the
-``example_app`` folder should look like this:
-
-.. code-block:: cmake
-
-  cmake_minimum_required(VERSION 3.1 FATAL_ERROR)
-  project(example_app)
-
-  find_package(Torch REQUIRED)
-
-  add_subdirectory(warp_perspective)
-
-  add_executable(example_app main.cpp)
-  target_link_libraries(example_app "${TORCH_LIBRARIES}")
-  target_link_libraries(example_app -Wl,--no-as-needed warp_perspective)
-  target_compile_features(example_app PRIVATE cxx_range_for)
-
-This basic CMake configuration looks much like before, except that we add the
-``warp_perspective`` CMake build as a subdirectory. Once its CMake code runs, we
-link our ``example_app`` application with the ``warp_perspective`` shared
-library.
-
-.. attention::
-
-  There is one crucial detail embedded in the above example: The
-  ``-Wl,--no-as-needed`` prefix to the ``warp_perspective`` link line. This is
-  required because we will not actually be calling any function from the
-  ``warp_perspective`` shared library in our application code. We only need the
-  global ``RegisterOperators`` object's constructor to run. Inconveniently, this
-  confuses the linker and makes it think it can just skip linking against the
-  library altogether. On Linux, the ``-Wl,--no-as-needed`` flag forces the link
-  to happen (NB: this flag is specific to Linux!). There are other workarounds
-  for this. The simplest is to define *some function* in the operator library
-  that you need to call from the main application. This could be as simple as a
-  function ``void init();`` declared in some header, which is then defined as
-  ``void init() { }`` in the operator library. Calling this ``init()`` function
-  in the main application will give the linker the impression that this is a
-  library worth linking against. Unfortunately, this is outside of our control,
-  and we would rather let you know the reason and the simple workaround for this
-  than handing you some opaque macro to plop in your code.
-
-Now, since we find the ``Torch`` package at the top level now, the
-``CMakeLists.txt`` file in the  ``warp_perspective`` subdirectory can be
-shortened a bit. It should look like this:
-
-.. code-block:: cmake
-
-  find_package(OpenCV REQUIRED)
-  add_library(warp_perspective SHARED op.cpp)
-  target_compile_features(warp_perspective PRIVATE cxx_range_for)
-  target_link_libraries(warp_perspective PRIVATE "${TORCH_LIBRARIES}")
-  target_link_libraries(warp_perspective PRIVATE opencv_core opencv_photo)
-
-Let's re-build our example app, which will also link with the custom operator
-library. In the top level ``example_app`` directory:
-
-.. code-block:: shell
-
-  $ mkdir build
-  $ cd build
-  $ cmake -DCMAKE_PREFIX_PATH=/path/to/libtorch ..
-  -- The C compiler identification is GNU 5.4.0
-  -- The CXX compiler identification is GNU 5.4.0
-  -- Check for working C compiler: /usr/bin/cc
-  -- Check for working C compiler: /usr/bin/cc -- works
-  -- Detecting C compiler ABI info
-  -- Detecting C compiler ABI info - done
-  -- Detecting C compile features
-  -- Detecting C compile features - done
-  -- Check for working CXX compiler: /usr/bin/c++
-  -- Check for working CXX compiler: /usr/bin/c++ -- works
-  -- Detecting CXX compiler ABI info
-  -- Detecting CXX compiler ABI info - done
-  -- Detecting CXX compile features
-  -- Detecting CXX compile features - done
-  -- Looking for pthread.h
-  -- Looking for pthread.h - found
-  -- Looking for pthread_create
-  -- Looking for pthread_create - not found
-  -- Looking for pthread_create in pthreads
-  -- Looking for pthread_create in pthreads - not found
-  -- Looking for pthread_create in pthread
-  -- Looking for pthread_create in pthread - found
-  -- Found Threads: TRUE
-  -- Found torch: /libtorch/lib/libtorch.so
-  -- Configuring done
-  -- Generating done
-  -- Build files have been written to: /warp_perspective/example_app/build
-  $ make -j
-  Scanning dependencies of target warp_perspective
-  [ 25%] Building CXX object warp_perspective/CMakeFiles/warp_perspective.dir/op.cpp.o
-  [ 50%] Linking CXX shared library libwarp_perspective.so
-  [ 50%] Built target warp_perspective
-  Scanning dependencies of target example_app
-  [ 75%] Building CXX object CMakeFiles/example_app.dir/main.cpp.o
-  [100%] Linking CXX executable example_app
-  [100%] Built target example_app
-
-If we now run the ``example_app`` binary and hand it our serialized model, we
-should arrive at a happy ending:
-
-.. code-block:: shell
-
-  $ ./example_app example.pt
-  11.4125   5.8262   9.5345   8.6111  12.3997
-   7.4683  13.5969   9.0850  11.0698   9.4008
-   7.4597  15.0926  12.5727   8.9319   9.0666
-   9.4834  11.1747   9.0162  10.9521   8.6269
-  10.0000  10.0000  10.0000  10.0000  10.0000
-  10.0000  10.0000  10.0000  10.0000  10.0000
-  10.0000  10.0000  10.0000  10.0000  10.0000
-  10.0000  10.0000  10.0000  10.0000  10.0000
-  [ Variable[CPUFloatType]{8,5} ]
-
-Success! You are now ready to inference away.
-
-Conclusion
-----------
-
-This tutorial walked you throw how to implement a custom TorchScript operator in
-C++, how to build it into a shared library, how to use it in Python to define
-TorchScript models and lastly how to load it into a C++ application for
-inference workloads. You are now ready to extend your TorchScript models with
-C++ operators that interface with third party C++ libraries, write custom high
-performance CUDA kernels, or implement any other use case that requires the
-lines between Python, TorchScript and C++ to blend smoothly.
-
-As always, if you run into any problems or have questions, you can use our
-`forum <https://discuss.pytorch.org/>`_ or `GitHub issues
-<https://github.com/pytorch/pytorch/issues>`_ to get in touch. Also, our
-`frequently asked questions (FAQ) page
-<https://pytorch.org/cppdocs/notes/faq.html>`_ may have helpful information.
-
-Appendix A: More Ways of Building Custom Operators
---------------------------------------------------
-
-The section "Building the Custom Operator" explained how to build a custom
-operator into a shared library using CMake. This appendix outlines two further
-approaches for compilation. Both of them use Python as the "driver" or
-"interface" to the compilation process. Also, both re-use the `existing
-infrastructure <https://pytorch.org/docs/stable/cpp_extension.html>`_ PyTorch
-provides for `*C++ extensions*
-<https://pytorch.org/tutorials/advanced/cpp_extension.html>`_, which are the
-vanilla (eager) PyTorch equivalent of TorchScript custom operators that rely on
-`pybind11 <https://github.com/pybind/pybind11>`_ for "explicit" binding of
-functions from C++ into Python.
-
-The first approach uses C++ extensions' `convenient just-in-time (JIT)
-compilation interface
-<https://pytorch.org/docs/stable/cpp_extension.html#torch.utils.cpp_extension.load>`_
-to compile your code in the background of your PyTorch script the first time you
-run it. The second approach relies on the venerable ``setuptools`` package and
-involves writing a separate ``setup.py`` file. This allows more advanced
-configuration as well as integration with other ``setuptools``-based projects.
-We will explore both approaches in detail below.
-
-Building with JIT compilation
-*****************************
-
-The JIT compilation feature provided by the PyTorch C++ extension toolkit allows
-embedding the compilation of your custom operator directly into your Python
-code, e.g. at the top of your training script.
-
-.. note::
-
-	"JIT compilation" here has nothing to do with the JIT compilation taking place
-	in the TorchScript compiler to optimize your program. It simply means that
-	your custom operator C++ code will be compiled in a folder under your system's
-	`/tmp` directory the first time you import it, as if you had compiled it
-	yourself beforehand.
-
-This JIT compilation feature comes in two flavors. In the first, you still keep
-your operator implementation in a separate file (``op.cpp``), and then use
-``torch.utils.cpp_extension.load()`` to compile your extension. Usually, this
-function will return the Python module exposing your C++ extension. However,
-since we are not compiling our custom operator into its own Python module, we
-only want to compile a plain shared library . Fortunately,
-``torch.utils.cpp_extension.load()`` has an argument ``is_python_module`` which
-we can set to ``False`` to indicate that we are only interested in building a
-shared library and not a Python module. ``torch.utils.cpp_extension.load()``
-will then compile and also load the shared library into the current process,
-just like ``torch.ops.load_library`` did before:
-
-.. code-block:: python
-
-  import torch.utils.cpp_extension
-
-  torch.utils.cpp_extension.load(
-      name="warp_perspective",
-      sources=["op.cpp"],
-      extra_ldflags=["-lopencv_core", "-lopencv_imgproc"],
-      is_python_module=False,
-      verbose=True
-  )
-
-  print(torch.ops.my_ops.warp_perspective)
-
-This should approximately print:
-
-.. code-block:: python
-
-  <built-in method my_ops::warp_perspective of PyCapsule object at 0x7f3e0f840b10>
-
-The second flavor of JIT compilation allows you to pass the source code for your
-custom TorchScript operator as a string. For this, use
-``torch.utils.cpp_extension.load_inline``:
-
-.. code-block:: python
-
-  import torch
-  import torch.utils.cpp_extension
-
-  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<float>());
-    cv::Mat warp_mat(/*rows=*/warp.size(0),
-                     /*cols=*/warp.size(1),
-                     /*type=*/CV_32FC1,
-                     /*data=*/warp.data<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::jit::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)
-
-Naturally, it is best practice to only use
-``torch.utils.cpp_extension.load_inline`` if your source code is reasonably
-short.
-
-Building with Setuptools
-************************
-
-The second approach to building our custom operator exclusively from Python is
-to use ``setuptools``. This has the advantage that ``setuptools`` has a quite
-powerful and extensive interface for building Python modules written in C++.
-However, since ``setuptools`` is really intended for building Python modules and
-not plain shared libraries (which do not have the necessary entry points Python
-expects from a module), this route can be slightly quirky. That said, all you
-need is a ``setup.py`` file in place of the ``CMakeLists.txt`` which looks like
-this:
-
-.. code-block:: python
-
-  from setuptools import setup
-  from torch.utils.cpp_extension import BuildExtension, CppExtension
-
-  setup(
-      name="warp_perspective",
-      ext_modules=[
-          CppExtension(
-              "warp_perspective",
-              ["example_app/warp_perspective/op.cpp"],
-              libraries=["opencv_core", "opencv_imgproc"],
-          )
-      ],
-      cmdclass={"build_ext": BuildExtension.with_options(no_python_abi_suffix=True)},
-  )
-
-
-Notice that we enabled the ``no_python_abi_suffix`` option in the
-``BuildExtension`` at the bottom. This instructs ``setuptools`` to omit any
-Python-3 specific ABI suffixes in the name of the produced shared library.
-Otherwise, on Python 3.7 for example, the library may be called
-``warp_perspective.cpython-37m-x86_64-linux-gnu.so`` where
-``cpython-37m-x86_64-linux-gnu`` is the ABI tag, but we really just want it to
-be called ``warp_perspective.so``
-
-If we now run ``python setup.py build develop`` in a terminal from within the
-folder in which ``setup.py`` is situated, we should see something like:
-
-.. code-block:: shell
-
-  $ python setup.py build develop
-  running build
-  running build_ext
-  building 'warp_perspective' extension
-  creating build
-  creating build/temp.linux-x86_64-3.7
-  gcc -pthread -B /root/local/miniconda/compiler_compat -Wl,--sysroot=/ -Wsign-compare -DNDEBUG -g -fwrapv -O3 -Wall -Wstrict-prototypes -fPIC -I/root/local/miniconda/lib/python3.7/site-packages/torch/lib/include -I/root/local/miniconda/lib/python3.7/site-packages/torch/lib/include/torch/csrc/api/include -I/root/local/miniconda/lib/python3.7/site-packages/torch/lib/include/TH -I/root/local/miniconda/lib/python3.7/site-packages/torch/lib/include/THC -I/root/local/miniconda/include/python3.7m -c op.cpp -o build/temp.linux-x86_64-3.7/op.o -DTORCH_API_INCLUDE_EXTENSION_H -DTORCH_EXTENSION_NAME=warp_perspective -D_GLIBCXX_USE_CXX11_ABI=0 -std=c++11
-  cc1plus: warning: command line option ‘-Wstrict-prototypes’ is valid for C/ObjC but not for C++
-  creating build/lib.linux-x86_64-3.7
-  g++ -pthread -shared -B /root/local/miniconda/compiler_compat -L/root/local/miniconda/lib -Wl,-rpath=/root/local/miniconda/lib -Wl,--no-as-needed -Wl,--sysroot=/ build/temp.linux-x86_64-3.7/op.o -lopencv_core -lopencv_imgproc -o build/lib.linux-x86_64-3.7/warp_perspective.so
-  running develop
-  running egg_info
-  creating warp_perspective.egg-info
-  writing warp_perspective.egg-info/PKG-INFO
-  writing dependency_links to warp_perspective.egg-info/dependency_links.txt
-  writing top-level names to warp_perspective.egg-info/top_level.txt
-  writing manifest file 'warp_perspective.egg-info/SOURCES.txt'
-  reading manifest file 'warp_perspective.egg-info/SOURCES.txt'
-  writing manifest file 'warp_perspective.egg-info/SOURCES.txt'
-  running build_ext
-  copying build/lib.linux-x86_64-3.7/warp_perspective.so ->
-  Creating /root/local/miniconda/lib/python3.7/site-packages/warp-perspective.egg-link (link to .)
-  Adding warp-perspective 0.0.0 to easy-install.pth file
-
-  Installed /warp_perspective
-  Processing dependencies for warp-perspective==0.0.0
-  Finished processing dependencies for warp-perspective==0.0.0
-
-This will produce a shared library called ``warp_perspective.so``, which we can
-pass to ``torch.ops.load_library`` as we did earlier to make our operator
-visible to TorchScript:
-
-.. code-block:: python
-
-  >>> import torch
-  >>> torch.ops.load_library("warp_perspective.so")
-  >>> print(torch.ops.custom.warp_perspective)
-  <built-in method custom::warp_perspective of PyCapsule object at 0x7ff51c5b7bd0>
+    TorchScript is deprecated, please use 
+    `torch.export <https://docs.pytorch.org/tutorials/intermediate/torch_export_tutorial.html>`__ instead.
\ No newline at end of file
diff --git a/advanced_source/transformer__timeseries_cpp_tutorial/CMakeLists.txt b/advanced_source/transformer__timeseries_cpp_tutorial/CMakeLists.txt
new file mode 100644
index 00000000000..a8246f6886d
--- /dev/null
+++ b/advanced_source/transformer__timeseries_cpp_tutorial/CMakeLists.txt
@@ -0,0 +1,8 @@
+cmake_minimum_required(VERSION 3.0 FATAL_ERROR)
+project(custom_ops)
+
+find_package(Torch REQUIRED)
+
+add_executable(transformer_ts transformer_timeseries.cpp)
+target_link_libraries(transformer_ts "${TORCH_LIBRARIES}")
+set_property(TARGET transformer_ts PROPERTY CXX_STANDARD 14)
diff --git a/advanced_source/transformer__timeseries_cpp_tutorial/scheduler.h b/advanced_source/transformer__timeseries_cpp_tutorial/scheduler.h
new file mode 100644
index 00000000000..9daabd5192e
--- /dev/null
+++ b/advanced_source/transformer__timeseries_cpp_tutorial/scheduler.h
@@ -0,0 +1,112 @@
+// Copyright 2020-present pytorch-cpp Authors
+#pragma once
+
+#include <torch/torch.h>
+#include <vector>
+#include <algorithm>
+
+namespace scheduler {
+template<typename TOptimizer>
+struct OptimizerOptionsMap {
+};
+
+template<>
+struct OptimizerOptionsMap<torch::optim::Adam> {
+    using type = torch::optim::AdamOptions;
+};
+
+template<>
+struct OptimizerOptionsMap<torch::optim::Adagrad> {
+    using type = torch::optim::AdagradOptions;
+};
+
+template<>
+struct OptimizerOptionsMap<torch::optim::LBFGS> {
+    using type = torch::optim::LBFGSOptions;
+};
+
+template<>
+struct OptimizerOptionsMap<torch::optim::RMSprop> {
+    using type = torch::optim::RMSpropOptions;
+};
+
+template<>
+struct OptimizerOptionsMap<torch::optim::SGD> {
+    using type = torch::optim::SGDOptions;
+};
+
+/**
+ * Learning rate scheduler base.
+ *
+ * Based on the Python implementation at
+ * https://github.com/pytorch/pytorch/blob/master/torch/optim/lr_scheduler.py.
+ * @tparam TOptimizer Optimizer type
+ */
+template<typename TOptimizer>
+class LRScheduler {
+ public:
+    explicit LRScheduler(TOptimizer& optimizer, int64_t last_epoch = -1)
+            : optimizer_(optimizer), last_epoch_(last_epoch), base_lrs(get_current_lr()) {}
+
+    virtual std::vector<double> get_lr() = 0;
+
+    void step() {
+        ++last_epoch_;
+
+        const auto values = get_lr();
+        auto &param_groups = optimizer_.param_groups();
+
+        for (decltype(param_groups.size()) i = 0; i != param_groups.size(); ++i) {
+            dynamic_cast<typename OptimizerOptionsMap<TOptimizer>::type &>(param_groups[i].options()).lr(values[i]);
+        }
+    }
+
+    virtual ~LRScheduler() = default;
+
+ protected:
+    TOptimizer& optimizer_;
+    int64_t last_epoch_;
+    std::vector<double> base_lrs;
+
+    std::vector<double> get_current_lr() {
+        std::vector<double> lrs;
+        lrs.reserve(optimizer_.param_groups().size());
+
+        for (auto &param_group : optimizer_.param_groups()) {
+            lrs.push_back(dynamic_cast<typename
+            OptimizerOptionsMap<TOptimizer>::type &>(param_group.options()).lr());
+        }
+
+        return lrs;
+    }
+};
+
+/**
+ * Step learning rate scheduler.
+ *
+ * Based on the python implementation at
+ * https://github.com/pytorch/pytorch/blob/master/torch/optim/lr_scheduler.py.
+ * @tparam TOptimizer Optimizer type
+ */
+template<typename TOptimizer>
+class StepLR : public LRScheduler<TOptimizer> {
+ public:
+    StepLR(TOptimizer& optimizer, int64_t step_size, double gamma = 0.1, int64_t last_epoch = -1)
+            : LRScheduler<TOptimizer>(optimizer, last_epoch), step_size_(step_size), gamma_(gamma) {}
+
+    std::vector<double> get_lr() override {
+        auto new_lr = this->get_current_lr();
+
+        if (this->last_epoch_ != 0 && (this->last_epoch_ % step_size_ == 0)) {
+            std::transform(new_lr.cbegin(), new_lr.cend(), new_lr.begin(),
+                           [gamma_ = gamma_](auto value) { return value * gamma_; });
+        }
+
+        return new_lr;
+    }
+
+ private:
+    int64_t step_size_;
+    double gamma_;
+};
+}  // namespace scheduler
\ No newline at end of file
diff --git a/advanced_source/transformer__timeseries_cpp_tutorial/transformer_timeseries.cpp b/advanced_source/transformer__timeseries_cpp_tutorial/transformer_timeseries.cpp
new file mode 100644
index 00000000000..8bd9ebe8c1b
--- /dev/null
+++ b/advanced_source/transformer__timeseries_cpp_tutorial/transformer_timeseries.cpp
@@ -0,0 +1,240 @@
+#include <torch/torch.h>
+#include <math.h>
+#include <iostream>
+#include <cmath>
+#include <limits>
+#include <chrono>
+#include <ctime>
+#include <random>
+#include "scheduler.h"
+
+using namespace torch::indexing;
+
+struct PositionalEncodingImpl : torch::nn::Module{
+    PositionalEncodingImpl(){
+
+    }
+    PositionalEncodingImpl(int64_t d_model, int64_t max_len=5000){
+        pe = torch::zeros({max_len, d_model});
+        position = torch::arange(0, max_len,
+            torch::TensorOptions(torch::kFloat32).requires_grad(false));
+        position = position.unsqueeze(1);
+        torch::Tensor temp = torch::arange(0, d_model, 2, torch::TensorOptions(torch::kFloat32).requires_grad(false));
+        div_term = torch::exp(temp * (std::log(10000.0) / d_model));
+
+
+        pe.index_put_({Slice(), Slice(0, None, 2)}, torch::sin(position * div_term));
+        pe.index_put_({Slice(), Slice(1, None, 2)}, torch::cos(position * div_term));
+
+
+        
+        pe = pe.unsqueeze(0).transpose(0, 1);
+        register_parameter("pe", pe);
+        register_parameter("position", position);
+        register_parameter("div_term", div_term);
+        register_buffer("pe", pe);
+    }
+
+    torch::Tensor forward(torch::Tensor x){
+        x = x + pe.index({Slice(0, x.size(0)), Slice()});
+        return x;
+    }
+
+    torch::Tensor pe;
+    torch::Tensor position;
+    torch::Tensor div_term;
+};
+
+TORCH_MODULE(PositionalEncoding);
+
+struct TransformerModel : torch::nn::Module{
+    TransformerModel(int64_t feature_size = 250, int64_t nlayers = 1, float dropout_p=0.1){
+        pos_encoder = PositionalEncoding(feature_size);
+        torch::nn::TransformerEncoderLayerOptions elOptions = 
+            torch::nn::TransformerEncoderLayerOptions(feature_size, 10);
+        torch::nn::TransformerEncoderLayer encoder_layers = torch::nn::TransformerEncoderLayer(
+            elOptions.dropout(dropout_p));
+        torch::nn::TransformerEncoderOptions enOptions = torch::nn::TransformerEncoderOptions(encoder_layers, nlayers);
+        transformer_encoder = torch::nn::TransformerEncoder(enOptions);
+        decoder = torch::nn::Linear(feature_size, 1);
+        register_module("pos_encoder", pos_encoder);
+        register_module("transformer_encoder", transformer_encoder);
+        register_module("decoder", decoder);
+    }
+
+    void init_weights(){
+        float initrange = 0.1;
+        decoder->bias.data().zero_();
+        decoder->weight.data().uniform_(-initrange, initrange);
+    }
+
+    torch::Tensor _generate_square_subsequent_mask(int sz){
+        torch::Tensor mask = (torch::triu(torch::ones({sz, sz})) == 1).transpose(0, 1).to(torch::kFloat32);
+        mask = mask.masked_fill(mask == 0, -std::numeric_limits<float>::infinity()).masked_fill(mask == 1, 0.f);
+        return mask;
+    }
+
+    torch::Tensor forward(torch::Tensor src){
+        if (false == is_mask_generated){
+            torch::Tensor mask = _generate_square_subsequent_mask(src.size(0)).to(src.device());
+            src_mask = mask;
+            is_mask_generated = true;
+        }
+
+        src = pos_encoder(src);
+        torch::Tensor output = transformer_encoder(src, src_mask);
+        output = decoder(output);
+        return output;
+    }
+
+    torch::Tensor src_mask;
+    bool is_mask_generated = false;
+    PositionalEncoding pos_encoder;
+    torch::nn::TransformerEncoder transformer_encoder = nullptr;
+    torch::nn::Linear decoder = nullptr;
+    int64_t ninp;
+};
+
+torch::Tensor create_inout_sequences(torch::Tensor input_data, int64_t tw, int64_t output_window = 1){
+    torch::Tensor temp = torch::empty({input_data.size(0) - tw, 2, tw}, torch::TensorOptions(torch::kFloat32));
+    auto len = input_data.numel();
+    auto max_counter = len - tw;
+    int64_t k = 0;
+    for (auto i = 0; i < max_counter; i++){
+        torch::Tensor train_seq = input_data.index({Slice(i, i + tw)});
+        temp[i][0] = input_data.index({Slice(i, i + tw)});
+        temp[i][1] = input_data.index({Slice(i + output_window, i + tw + output_window)});
+
+    }
+
+    return temp;
+}
+
+std::tuple<torch::Tensor, torch::Tensor> get_data(int64_t output_window = 1){
+    //construct a little toy dataset
+    auto time = torch::arange(0, 400, 0.1);
+    auto amplitude = torch::sin(time) + torch::sin(time * 0.05) + torch::sin(time * 0.12);// + dist(mt);
+
+    
+    //from sklearn.preprocessing import MinMaxScaler
+
+    
+    //looks like normalizing input values curtial for the model
+    //scaler = MinMaxScaler(feature_range=(-1, 1)) 
+    //amplitude = scaler.fit_transform(series.to_numpy().reshape(-1, 1)).reshape(-1)
+    //amplitude = scaler.fit_transform(amplitude.reshape(-1, 1)).reshape(-1)
+    
+    
+    auto samples = 2600;
+
+    auto train_data = amplitude.index({Slice(None, samples)});
+    auto test_data = amplitude.index({Slice(samples, None)});
+
+    //convert our train data into a pytorch train tensor
+    auto input_window = 100;
+
+    auto train_sequence = create_inout_sequences(train_data,input_window);
+    train_sequence = train_sequence.index({Slice(None,-output_window)});
+    
+    auto test_sequence = create_inout_sequences(test_data,input_window);
+    test_sequence = test_sequence.index({Slice(None,-output_window)});
+
+    auto cuda_available = torch::cuda::is_available();
+    torch::Device device(cuda_available ? torch::kCUDA : torch::kCPU);
+
+    return std::make_tuple(train_sequence.to(device),test_sequence.to(device));
+}
+
+std::tuple<torch::Tensor, torch::Tensor> get_batch(torch::Tensor source, int64_t i, int64_t batch_size, int64_t input_window = 100){
+    auto seq_len = std::min(batch_size, source.size(0) - i);
+    
+    auto data = source.index({Slice(i, i + seq_len)});
+    auto input = data.index({Slice(), 0, Slice()});
+    auto target = data.index({Slice(), 1, Slice()});
+    auto temp = input.numel()/100;
+    if (temp > 10)
+        temp = 10;
+    input = torch::reshape(input, {100, temp, 1});
+    target = torch::reshape(target, {100, temp, 1});
+    return std::make_tuple(input, target);
+}
+
+
+void train(TransformerModel model, torch::Tensor train_data, int64_t num_epochs = 100){
+    model.train();
+    auto total_loss = 0.0;
+    auto start_time = std::chrono::system_clock::now();
+    auto batch_size = 10;
+    auto batch = 0;
+
+    torch::nn::MSELoss criterion;
+
+
+    auto learning_rate = 0.005;
+    torch::optim::SGD optimizer(model.parameters(), torch::optim::SGDOptions(learning_rate));
+    scheduler::StepLR<decltype(optimizer)> scheduler(optimizer, 1.0, 0.95);
+
+    for(int64_t i = 0; i <= num_epochs; i++){
+        auto start_time = std::chrono::system_clock::now();
+        std::cout<<"Epoch "<<i<<std::endl;
+        batch = 0;
+        for (int64_t j = 0; j < train_data.size(0); j = j + batch_size, batch++){
+            auto data = get_batch(train_data, j, batch_size);
+            optimizer.zero_grad();
+            auto output = model.forward(std::get<0>(data));
+            
+            auto loss = criterion(output, std::get<1>(data));
+            loss.backward();
+            torch::nn::utils::clip_grad_norm_(model.parameters(), 0.7);
+            optimizer.step();
+            total_loss += loss.item<double>();
+            auto log_interval = int(train_data.size(0)) / (batch_size * 5);
+            if (batch != 0 && 0 == batch % log_interval){
+                auto curr_loss = total_loss / log_interval;
+                auto elapsed = std::chrono::system_clock::now() - start_time;
+                std::cout<<"|epoch "<<i<<" | "<<batch<<"/"<<train_data.size(0)/batch_size;
+                std::cout<<" batches | "<<(elapsed.count() * 10)<<" ms | loss"<<curr_loss<<std::endl;;
+                total_loss = 0;
+                start_time = std::chrono::system_clock::now();
+            }
+        }
+
+        scheduler.step();
+    }
+
+    return;
+}
+
+void evaluate(TransformerModel model, torch::Tensor eval_data){
+    model.eval();
+    auto batch_size = 10;
+    auto total_loss = 0.0;
+    torch::nn::MSELoss criterion;
+
+    std::cout<<"Evaluating:";
+    for (int64_t j = 0; j < eval_data.size(0); j = j + batch_size){
+            auto data = get_batch(eval_data, j, batch_size);
+            auto output = model.forward(std::get<0>(data));
+            auto loss = criterion(output, std::get<1>(data));
+            total_loss += loss.item<double>();
+    }
+
+    std::cout<<"Evaluation Loss: "<<total_loss<<std::endl;
+    return;
+}
+
+int main(){
+    auto cuda_available = torch::cuda::is_available();
+    torch::Device device(cuda_available ? torch::kCUDA : torch::kCPU);
+
+    auto model = TransformerModel();
+    model.to(device);
+
+    auto data = get_data();
+    train(model, std::get<0>(data));
+    evaluate(model, std::get<1>(data));
+
+    return 0;
+    
+}
+
diff --git a/advanced_source/usb_semisup_learn.py b/advanced_source/usb_semisup_learn.py
new file mode 100644
index 00000000000..4ea6f621ab7
--- /dev/null
+++ b/advanced_source/usb_semisup_learn.py
@@ -0,0 +1,253 @@
+"""
+Semi-Supervised Learning using USB built upon PyTorch
+=====================================================
+
+**Author**: `Hao Chen <https://github.com/Hhhhhhao>`_
+
+Unified Semi-supervised learning Benchmark (USB) is a semi-supervised
+learning (SSL) framework built upon PyTorch.
+Based on Datasets and Modules provided by PyTorch, USB becomes a flexible,
+modular, and easy-to-use framework for semi-supervised learning.
+It supports a variety of semi-supervised learning algorithms, including
+``FixMatch``, ``FreeMatch``, ``DeFixMatch``, ``SoftMatch``, and so on.
+It also supports a variety of imbalanced semi-supervised learning algorithms.
+The benchmark results across different datasets of computer vision, natural
+language processing, and speech processing are included in USB.
+
+This tutorial will walk you through the basics of using the USB lighting
+package.
+Let's get started by training a ``FreeMatch``/``SoftMatch`` model on
+CIFAR-10 using pretrained Vision Transformers (ViT)!
+And we will show it is easy to change the semi-supervised algorithm and train
+on imbalanced datasets.
+
+
+.. figure:: /_static/img/usb_semisup_learn/code.png
+   :alt: USB framework illustration
+"""
+
+
+######################################################################
+# Introduction to ``FreeMatch`` and ``SoftMatch`` in Semi-Supervised Learning
+# ---------------------------------------------------------------------------
+#
+# Here we provide a brief introduction to ``FreeMatch`` and ``SoftMatch``.
+# First, we introduce a famous baseline for semi-supervised learning called ``FixMatch``.
+# ``FixMatch`` is a very simple framework for semi-supervised learning, where it
+# utilizes a strong augmentation to generate pseudo labels for unlabeled data.
+# It adopts a confidence thresholding strategy to filter out the low-confidence
+# pseudo labels with a fixed threshold set.
+# ``FreeMatch`` and ``SoftMatch`` are two algorithms that improve upon ``FixMatch``.
+# ``FreeMatch`` proposes adaptive thresholding strategy to replace the fixed
+# thresholding strategy in ``FixMatch``. The adaptive thresholding progressively
+# increases the threshold according to the learning status of the model on each
+# class. ``SoftMatch`` absorbs the idea of confidence thresholding as an
+# weighting mechanism. It proposes a Gaussian weighting mechanism to overcome
+# the quantity-quality trade-off in pseudo-labels. In this tutorial, we will
+# use USB to train ``FreeMatch`` and ``SoftMatch``.
+
+
+######################################################################
+# Use USB to Train ``FreeMatch``/``SoftMatch`` on CIFAR-10 with only 40 labels
+# ----------------------------------------------------------------------------
+#
+# USB is easy to use and extend, affordable to small groups, and comprehensive
+# for developing and evaluating SSL algorithms.
+# USB provides the implementation of 14 SSL algorithms based on Consistency
+# Regularization, and 15 tasks for evaluation from CV, NLP, and Audio domain.
+# It has a modular design that allows users to easily extend the package by
+# adding new algorithms and tasks.
+# It also supports a Python API for easier adaptation to different SSL
+# algorithms on new data.
+#
+#
+# Now, let's use USB to train ``FreeMatch`` and ``SoftMatch`` on CIFAR-10.
+# First, we need to install USB package ``semilearn`` and import necessary API
+# functions from USB.
+# If you are running this in Google Colab, install ``semilearn`` by running:
+# ``!pip install semilearn``.
+#
+# Below is a list of functions we will use from ``semilearn``:
+#
+# - ``get_dataset`` to load dataset, here we use CIFAR-10
+# - ``get_data_loader`` to create train (labeled and unlabeled) and test data
+# loaders, the train unlabeled loaders will provide both strong and weak
+# augmentation of unlabeled data
+# - ``get_net_builder`` to create a model, here we use pretrained ViT
+# - ``get_algorithm`` to create the semi-supervised learning algorithm,
+# here we use ``FreeMatch`` and ``SoftMatch``
+# - ``get_config``: to get default configuration of the algorithm
+# - ``Trainer``: a Trainer class for training and evaluating the
+# algorithm on dataset
+# 
+# Note that a CUDA-enabled backend is required for training with the ``semilearn`` package.
+# See `Enabling CUDA in Google Colab <https://pytorch.org/tutorials/beginner/colab#enabling-cuda>`__ for instructions
+# on enabling CUDA in Google Colab.
+#
+import semilearn
+from semilearn import get_dataset, get_data_loader, get_net_builder, get_algorithm, get_config, Trainer
+
+######################################################################
+# After importing necessary functions, we first set the hyper-parameters of the
+# algorithm.
+# 
+config = {
+    'algorithm': 'freematch',
+    'net': 'vit_tiny_patch2_32',
+    'use_pretrain': True, 
+    'pretrain_path': 'https://github.com/microsoft/Semi-supervised-learning/releases/download/v.0.0.0/vit_tiny_patch2_32_mlp_im_1k_32.pth',
+
+    # optimization configs
+    'epoch': 1,  
+    'num_train_iter': 500,
+    'num_eval_iter': 500,  
+    'num_log_iter': 50,  
+    'optim': 'AdamW',
+    'lr': 5e-4,
+    'layer_decay': 0.5,
+    'batch_size': 16,
+    'eval_batch_size': 16,
+
+
+    # dataset configs
+    'dataset': 'cifar10',
+    'num_labels': 40,
+    'num_classes': 10,
+    'img_size': 32,
+    'crop_ratio': 0.875,
+    'data_dir': './data',
+    'ulb_samples_per_class': None,
+
+    # algorithm specific configs
+    'hard_label': True,
+    'T': 0.5,
+    'ema_p': 0.999,
+    'ent_loss_ratio': 0.001,
+    'uratio': 2,
+    'ulb_loss_ratio': 1.0,
+
+    # device configs
+    'gpu': 0,
+    'world_size': 1,
+    'distributed': False,
+    "num_workers": 4,
+}
+config = get_config(config)
+
+
+######################################################################
+# Then, we load the dataset and create data loaders for training and testing.
+# And we specify the model and algorithm to use.
+# 
+dataset_dict = get_dataset(config, config.algorithm, config.dataset, config.num_labels, config.num_classes, data_dir=config.data_dir, include_lb_to_ulb=config.include_lb_to_ulb)
+train_lb_loader = get_data_loader(config, dataset_dict['train_lb'], config.batch_size)
+train_ulb_loader = get_data_loader(config, dataset_dict['train_ulb'], int(config.batch_size * config.uratio))
+eval_loader = get_data_loader(config, dataset_dict['eval'], config.eval_batch_size)
+algorithm = get_algorithm(config,  get_net_builder(config.net, from_name=False), tb_log=None, logger=None)
+
+
+######################################################################
+# We can start training the algorithms on CIFAR-10 with 40 labels now.
+# We train for 500 iterations and evaluate every 500 iterations.
+# 
+trainer = Trainer(config, algorithm)
+trainer.fit(train_lb_loader, train_ulb_loader, eval_loader)
+
+
+######################################################################
+# Finally, let's evaluate the trained model on the validation set.
+# After training 500 iterations with ``FreeMatch`` on only 40 labels of
+# CIFAR-10, we obtain a classifier that achieves around 87% accuracy on the validation set.
+trainer.evaluate(eval_loader)
+
+
+
+######################################################################
+# Use USB to Train ``SoftMatch`` with specific imbalanced algorithm on imbalanced CIFAR-10
+# ----------------------------------------------------------------------------------------
+# 
+# Now let's say we have imbalanced labeled set and unlabeled set of CIFAR-10,
+# and we want to train a ``SoftMatch`` model on it.
+# We create an imbalanced labeled set and imbalanced unlabeled set of CIFAR-10,
+# by setting the ``lb_imb_ratio`` and ``ulb_imb_ratio`` to 10.
+# Also, we replace the ``algorithm`` with ``softmatch`` and set the ``imbalanced``
+# to ``True``.
+# 
+config = {
+    'algorithm': 'softmatch',
+    'net': 'vit_tiny_patch2_32',
+    'use_pretrain': True, 
+    'pretrain_path': 'https://github.com/microsoft/Semi-supervised-learning/releases/download/v.0.0.0/vit_tiny_patch2_32_mlp_im_1k_32.pth',
+
+    # optimization configs
+    'epoch': 1,  
+    'num_train_iter': 500,
+    'num_eval_iter': 500,  
+    'num_log_iter': 50,  
+    'optim': 'AdamW',
+    'lr': 5e-4,
+    'layer_decay': 0.5,
+    'batch_size': 16,
+    'eval_batch_size': 16,
+
+
+    # dataset configs
+    'dataset': 'cifar10',
+    'num_labels': 1500,
+    'num_classes': 10,
+    'img_size': 32,
+    'crop_ratio': 0.875,
+    'data_dir': './data',
+    'ulb_samples_per_class': None,
+    'lb_imb_ratio': 10,
+    'ulb_imb_ratio': 10,
+    'ulb_num_labels': 3000,
+
+    # algorithm specific configs
+    'hard_label': True,
+    'T': 0.5,
+    'ema_p': 0.999,
+    'ent_loss_ratio': 0.001,
+    'uratio': 2,
+    'ulb_loss_ratio': 1.0,
+
+    # device configs
+    'gpu': 0,
+    'world_size': 1,
+    'distributed': False,
+    "num_workers": 4,
+}
+config = get_config(config)
+
+######################################################################
+# Then, we re-load the dataset and create data loaders for training and testing.
+# And we specify the model and algorithm to use.
+# 
+dataset_dict = get_dataset(config, config.algorithm, config.dataset, config.num_labels, config.num_classes, data_dir=config.data_dir, include_lb_to_ulb=config.include_lb_to_ulb)
+train_lb_loader = get_data_loader(config, dataset_dict['train_lb'], config.batch_size)
+train_ulb_loader = get_data_loader(config, dataset_dict['train_ulb'], int(config.batch_size * config.uratio))
+eval_loader = get_data_loader(config, dataset_dict['eval'], config.eval_batch_size)
+algorithm = get_algorithm(config,  get_net_builder(config.net, from_name=False), tb_log=None, logger=None)
+
+
+######################################################################
+# We can start Train the algorithms on CIFAR-10 with 40 labels now.
+# We train for 500 iterations and evaluate every 500 iterations.
+# 
+trainer = Trainer(config, algorithm)
+trainer.fit(train_lb_loader, train_ulb_loader, eval_loader)
+
+
+######################################################################
+# Finally, let's evaluate the trained model on the validation set.
+# 
+trainer.evaluate(eval_loader)
+
+
+
+######################################################################
+# References:
+# - [1] USB: https://github.com/microsoft/Semi-supervised-learning
+# - [2] Kihyuk Sohn et al. FixMatch: Simplifying Semi-Supervised Learning with Consistency and Confidence
+# - [3] Yidong Wang et al. FreeMatch: Self-adaptive Thresholding for Semi-supervised Learning
+# - [4] Hao Chen et al. SoftMatch: Addressing the Quantity-Quality Trade-off in Semi-supervised Learning
diff --git a/beginner_source/PyTorch Cheat.md b/beginner_source/PyTorch Cheat.md
deleted file mode 100644
index 3101bd6a2d3..00000000000
--- a/beginner_source/PyTorch Cheat.md	
+++ /dev/null
@@ -1,191 +0,0 @@
----
-Title: PyTorch Cheat Sheet
-PyTorch version: 1.0Pre
-Date updated: 7/30/18
-
----
-
-# Imports
----------------
-### General
-
-```
-import torch                                        # root package
-from torch.utils.data import Dataset, DataLoader    # dataset representation and loading
-```
-
-### Neural Network API
-
-```
-import torch.autograd as autograd         # computation graph
-from torch.autograd import Variable       # variable node in computation graph
-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)
-
-### Hybrid frontend
-
-```
-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 [hybrid frontend](https://pytorch.org/docs/stable/hybridfrontend)
-
-### ONNX
-
-```
-torch.onnx.export(model, dummy data, xxxx.proto)       # exports an ONNX formatted model using a trained model, dummy data and the desired file name
-model = onnx.load("alexnet.proto")                     # load an ONNX model
-onnx.checker.check_model(model)                        # check that the model IR is well formed
-onnx.helper.printable_graph(model.graph)               # print a human readable representation of the graph
-```
-See [onnx](https://pytorch.org/docs/stable/onnx.html)
-
-### Vision
-
-```
-from torchvision import datasets, models, transforms     # vision datasets, architectures & transforms
-import torchvision.transforms as transforms              # composable transforms
-```
-See [torchvision](https://pytorch.org/docs/stable/torchvision/index.html)
-
-### Distributed Training
-
-```
-import torch.distributed as dist          # distributed communication
-from multiprocessing import Process       # memory sharing processes
-```
-See [distributed](https://pytorch.org/docs/stable/distributed.html) and [multiprocessing](https://pytorch.org/docs/stable/multiprocessing.html)
-
-
-# Tensors
---------------------
-
-### Creation
-
-```
-torch.randn(*size)              # tensor with independent N(0,1) entries
-torch.[ones|zeros](*size)       # tensor with all 1's [or 0's]
-torch.Tensor(L)                 # create tensor from [nested] list or ndarray L
-x.clone()                       # clone of x
-with torch.no_grad():           # code wrap that stops autograd from tracking tensor history
-requires_grad=True              # arg, when set to True, tracks computation history for future derivative calculations
-```
-See [tensor](https://pytorch.org/docs/stable/tensors.html)
-
-### Dimensionality
-
-```
-x.size()                              # return tuple-like object of dimensions
-torch.cat(tensor_seq, dim=0)          # concatenates tensors along dim
-x.view(a,b,...)                       # reshapes x into size (a,b,...)
-x.view(-1,a)                          # reshapes x into size (b,a) for some b
-x.transpose(a,b)                      # swaps dimensions a and b
-x.permute(*dims)                      # permutes dimensions
-x.unsqueeze(dim)                      # tensor with added axis
-x.unsqueeze(dim=2)                    # (a,b,c) tensor -> (a,b,1,c) tensor
-```
-See [tensor](https://pytorch.org/docs/stable/tensors.html)
-
-### Algebra
-
-```
-A.mm(B)       # matrix multiplication
-A.mv(x)       # matrix-vector multiplication
-x.t()         # matrix transpose
-```
-See [math operations](https://pytorch.org/docs/stable/torch.html?highlight=mm#math-operations)
-
-### GPU Usage
-
-```
-torch.cuda.is_available                                 # check for cuda
-x.cuda()                                                # move x's data from CPU to GPU and return new object
-x.cpu()                                                 # move x's data from GPU to CPU and return new object
-
-if not args.disable_cuda and torch.cuda.is_available(): # device agnostic code and modularity
-    args.device = torch.device('cuda')                  #
-else:                                                   #
-    args.device = torch.device('cpu')                   #
-
-net.to(device)                                          # recursively convert their parameters and buffers to device specific tensors
-mytensor.to(device)                                     # copy your tensors to a device (gpu, cpu)
-```
-See [cuda](https://pytorch.org/docs/stable/cuda.html)
-
-
-# Deep Learning
-```
-nn.Linear(m,n)                                # fully connected layer from m to n units
-nn.ConvXd(m,n,s)                              # X dimensional conv layer from m to n channels where X⍷{1,2,3} and the kernel size is s
-nn.MaxPoolXd(s)                               # X dimension pooling layer (notation as above)
-nn.BatchNorm                                  # batch norm layer
-nn.RNN/LSTM/GRU                               # recurrent layers
-nn.Dropout(p=0.5, inplace=False)              # dropout layer for any dimensional input
-nn.Dropout2d(p=0.5, inplace=False)            # 2-dimensional channel-wise dropout
-nn.Embedding(num_embeddings, embedding_dim)   # (tensor-wise) mapping from indices to embedding vectors
-```
-See [nn](https://pytorch.org/docs/stable/nn.html)
-
-### Loss Functions
-
-```
-nn.X                                        # where X is BCELoss, CrossEntropyLoss, L1Loss, MSELoss, NLLLoss, SoftMarginLoss, MultiLabelSoftMarginLoss, CosineEmbeddingLoss, KLDivLoss, MarginRankingLoss, HingeEmbeddingLoss or CosineEmbeddingLoss
-```
-See [loss functions](https://pytorch.org/docs/stable/nn.html#loss-functions)
-
-### Activation Functions
-
-```
-nn.X                                  # where X is ReLU, ReLU6, ELU, SELU, PReLU, LeakyReLU, Threshold, HardTanh, Sigmoid, Tanh, LogSigmoid, Softplus, SoftShrink, Softsign, TanhShrink, Softmin, Softmax, Softmax2d or LogSoftmax
-```
-See [activation functions](https://pytorch.org/docs/stable/nn.html#non-linear-activations-weighted-sum-nonlinearity)
-
-### Optimizers
-
-```
-opt = optim.x(model.parameters(), ...)      # create optimizer
-opt.step()                                  # update weights
-optim.X                                     # where X is SGD, Adadelta, Adagrad, Adam, SparseAdam, Adamax, ASGD, LBFGS, RMSProp or Rprop
-```
-See [optimizers](https://pytorch.org/docs/stable/optim.html)
-
-### Learning rate scheduling
-
-```
-scheduler = optim.X(optimizer,...)      # create lr scheduler
-scheduler.step()                        # update lr at start of epoch
-optim.lr_scheduler.X                    # where X is LambdaLR, StepLR, MultiStepLR, ExponentialLR or ReduceLROnPLateau
-```
-See [learning rate scheduler](https://pytorch.org/docs/stable/optim.html#how-to-adjust-learning-rate)
-
-
-# Data Utilities
-
-### Datasets
-
-```
-Dataset                    # abstract class representing dataset
-TensorDataset              # labelled dataset in the form of tensors
-ConcatDataset              # concatenation of Datasets
-```
-See [datasets](https://pytorch.org/docs/stable/data.html?highlight=dataset#torch.utils.data.Dataset)
-
-### Dataloaders and DataSamplers
-
-```
-DataLoader(dataset, batch_size=1, ...)      # loads data batches agnostic of structure of individual data points
-sampler.Sampler(dataset,...)                # abstract class dealing with ways to sample from dataset
-sampler.XSampler                            # where X is Sequential, Random, Subset, WeightedRandom or Distributed
-```
-See [dataloader](https://pytorch.org/docs/stable/data.html?highlight=dataloader#torch.utils.data.DataLoader)
-
-
-## Also see
-
-* [Deep Learning with PyTorch: A 60 Minute Blitz](https://pytorch.org/tutorials/beginner/deep_learning_60min_blitz.html) _(pytorch.org)_
-* [PyTorch Forums](https://discuss.pytorch.org/) _(discuss.pytorch.org)_
-* [PyTorch for Numpy users](https://github.com/wkentaro/pytorch-for-numpy-users) _(github.com/wkentaro/pytorch-for-numpy-users)_
diff --git a/beginner_source/audio_classifier_tutorial.py b/beginner_source/audio_classifier_tutorial.py
deleted file mode 100644
index 5a9b29a3108..00000000000
--- a/beginner_source/audio_classifier_tutorial.py
+++ /dev/null
@@ -1,310 +0,0 @@
-"""
-Audio Classifier Tutorial
-=========================
-**Author**: `Winston Herring <https://github.com/winston6>`_
-
-This tutorial will show you how to correctly format an audio dataset and
-then train/test an audio classifier network on the dataset. First, let’s
-import the common torch packages as well as ``torchaudio``, ``pandas``,
-and ``numpy``. ``torchaudio`` is available `here <https://github.com/pytorch/audio>`_
-and can be installed by following the
-instructions on the website.
-
-"""
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-import torch.optim as optim
-from torchvision import datasets, transforms
-from torch.utils.data import Dataset
-import torchaudio
-import pandas as pd
-import numpy as np
-
-
-######################################################################
-# Let’s check if a CUDA GPU is available and select our device. Running
-# the network on a GPU will greatly decrease the training/testing runtime.
-#
-
-device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-print(device)
-
-
-######################################################################
-# Importing the Dataset
-# ---------------------
-#
-# We will use the UrbanSound8K dataset to train our network. It is
-# available for free `here <https://urbansounddataset.weebly.com/>`_ and contains
-# 10 audio classes with over 8000 audio samples! Once you have downloaded
-# the compressed dataset, extract it to your current working directory.
-# First, we will look at the csv file that provides information about the
-# individual sound files. ``pandas`` allows us to open the csv file and
-# use ``.iloc()`` to access the data within it.
-#
-
-csvData = pd.read_csv('./data/UrbanSound8K/metadata/UrbanSound8K.csv')
-print(csvData.iloc[0, :])
-
-
-######################################################################
-# The 10 audio classes in the UrbanSound8K dataset are air_conditioner,
-# car_horn, children_playing, dog_bark, drilling, enginge_idling,
-# gun_shot, jackhammer, siren, and street_music. Let’s play a couple files
-# and see what they sound like. The first file is street music and the
-# second is an air conditioner.
-#
-
-import IPython.display as ipd
-ipd.Audio('./data/UrbanSound8K/audio/fold1/108041-9-0-5.wav')
-
-ipd.Audio('./data/UrbanSound8K/audio/fold5/100852-0-0-19.wav')
-
-
-######################################################################
-# Formatting the Data
-# -------------------
-#
-# Now that we know the format of the csv file entries, we can construct
-# our dataset. We will create a rapper class for our dataset using
-# ``torch.utils.data.Dataset`` that will handle loading the files and
-# performing some formatting steps. The UrbanSound8K dataset is separated
-# into 10 folders. We will use the data from 9 of these folders to train
-# our network and then use the 10th folder to test the network. The rapper
-# class will store the file names, labels, and folder numbers of the audio
-# files in the inputted folder list when initialized. The actual loading
-# and formatting steps will happen in the access function ``__getitem__``.
-#
-# In ``__getitem__``, we use ``torchaudio.load()`` to convert the wav
-# files to tensors. ``torchaudio.load()`` returns a tuple containing the
-# newly created tensor along with the sampling frequency of the audio file
-# (44.1kHz for UrbanSound8K). The dataset uses two channels for audio so
-# we will use ``torchaudio.transforms.DownmixMono()`` to convert the audio
-# data to one channel. Next, we need to format the audio data. The network
-# we will make takes an input size of 32,000, while most of the audio
-# files have well over 100,000 samples. The UrbanSound8K audio is sampled
-# at 44.1kHz, so 32,000 samples only covers around 700 milliseconds. By
-# downsampling the audio to aproximately 8kHz, we can represent 4 seconds
-# with the 32,000 samples. This downsampling is achieved by taking every
-# fifth sample of the original audio tensor. Not every audio tensor is
-# long enough to handle the downsampling so these tensors will need to be
-# padded with zeros. The minimum length that won’t require padding is
-# 160,000 samples.
-#
-
-class UrbanSoundDataset(Dataset):
-#rapper for the UrbanSound8K dataset
-    # Argument List
-    #  path to the UrbanSound8K csv file
-    #  path to the UrbanSound8K audio files
-    #  list of folders to use in the dataset
-
-    def __init__(self, csv_path, file_path, folderList):
-        csvData = pd.read_csv(csv_path)
-        #initialize lists to hold file names, labels, and folder numbers
-        self.file_names = []
-        self.labels = []
-        self.folders = []
-        #loop through the csv entries and only add entries from folders in the folder list
-        for i in range(0,len(csvData)):
-            if csvData.iloc[i, 5] in folderList:
-                self.file_names.append(csvData.iloc[i, 0])
-                self.labels.append(csvData.iloc[i, 6])
-                self.folders.append(csvData.iloc[i, 5])
-
-        self.file_path = file_path
-        self.mixer = torchaudio.transforms.DownmixMono() #UrbanSound8K uses two channels, this will convert them to one
-        self.folderList = folderList
-
-    def __getitem__(self, index):
-        #format the file path and load the file
-        path = self.file_path + "fold" + str(self.folders[index]) + "/" + self.file_names[index]
-        sound = torchaudio.load(path, out = None, normalization = True)
-        #load returns a tensor with the sound data and the sampling frequency (44.1kHz for UrbanSound8K)
-        soundData = self.mixer(sound[0])
-        #downsample the audio to ~8kHz
-        tempData = torch.zeros([160000, 1]) #tempData accounts for audio clips that are too short
-        if soundData.numel() < 160000:
-            tempData[:soundData.numel()] = soundData[:]
-        else:
-            tempData[:] = soundData[:160000]
-
-        soundData = tempData
-        soundFormatted = torch.zeros([32000, 1])
-        soundFormatted[:32000] = soundData[::5] #take every fifth sample of soundData
-        soundFormatted = soundFormatted.permute(1, 0)
-        return soundFormatted, self.labels[index]
-
-    def __len__(self):
-        return len(self.file_names)
-
-
-csv_path = './data/UrbanSound8K/metadata/UrbanSound8K.csv'
-file_path = './data/UrbanSound8K/audio/'
-
-train_set = UrbanSoundDataset(csv_path, file_path, range(1,10))
-test_set = UrbanSoundDataset(csv_path, file_path, [10])
-print("Train set size: " + str(len(train_set)))
-print("Test set size: " + str(len(test_set)))
-
-kwargs = {'num_workers': 1, 'pin_memory': True} if device == 'cuda' else {} #needed for using datasets on gpu
-
-train_loader = torch.utils.data.DataLoader(train_set, batch_size = 128, shuffle = True, **kwargs)
-test_loader = torch.utils.data.DataLoader(test_set, batch_size = 128, shuffle = True, **kwargs)
-
-
-######################################################################
-# Define the Network
-# ------------------
-#
-# For this tutorial we will use a convolutional neural network to process
-# the raw audio data. Usually more advanced transforms are applied to the
-# audio data, however CNNs can be used to accurately process the raw data.
-# The specific architecture is modeled after the M5 network architecture
-# described in https://arxiv.org/pdf/1610.00087.pdf. An important aspect
-# of models processing raw audio data is the receptive field of their
-# first layer’s filters. Our model’s first filter is length 80 so when
-# processing audio sampled at 8kHz the receptive field is around 10ms.
-# This size is similar to speech processing applications that often use
-# receptive fields ranging from 20ms to 40ms.
-#
-
-class Net(nn.Module):
-    def __init__(self):
-        super(Net, self).__init__()
-        self.conv1 = nn.Conv1d(1, 128, 80, 4)
-        self.bn1 = nn.BatchNorm1d(128)
-        self.pool1 = nn.MaxPool1d(4)
-        self.conv2 = nn.Conv1d(128, 128, 3)
-        self.bn2 = nn.BatchNorm1d(128)
-        self.pool2 = nn.MaxPool1d(4)
-        self.conv3 = nn.Conv1d(128, 256, 3)
-        self.bn3 = nn.BatchNorm1d(256)
-        self.pool3 = nn.MaxPool1d(4)
-        self.conv4 = nn.Conv1d(256, 512, 3)
-        self.bn4 = nn.BatchNorm1d(512)
-        self.pool4 = nn.MaxPool1d(4)
-        self.avgPool = nn.AvgPool1d(30) #input should be 512x30 so this outputs a 512x1
-        self.fc1 = nn.Linear(512, 10)
-
-    def forward(self, x):
-        x = self.conv1(x)
-        x = F.relu(self.bn1(x))
-        x = self.pool1(x)
-        x = self.conv2(x)
-        x = F.relu(self.bn2(x))
-        x = self.pool2(x)
-        x = self.conv3(x)
-        x = F.relu(self.bn3(x))
-        x = self.pool3(x)
-        x = self.conv4(x)
-        x = F.relu(self.bn4(x))
-        x = self.pool4(x)
-        x = self.avgPool(x)
-        x = x.permute(0, 2, 1) #change the 512x1 to 1x512
-        x = self.fc1(x)
-        return F.log_softmax(x, dim = 2)
-
-model = Net()
-model.to(device)
-print(model)
-
-
-######################################################################
-# We will use the same optimization technique used in the paper, an Adam
-# optimizer with weight decay set to 0.0001. At first, we will train with
-# a learning rate of 0.01, but we will use a ``scheduler`` to decrease it
-# to 0.001 during training.
-#
-
-optimizer = optim.Adam(model.parameters(), lr = 0.01, weight_decay = 0.0001)
-scheduler = optim.lr_scheduler.StepLR(optimizer, step_size = 20, gamma = 0.1)
-
-
-######################################################################
-# Training and Testing the Network
-# --------------------------------
-#
-# Now let’s define a training function that will feed our training data
-# into the model and perform the backward pass and optimization steps.
-#
-
-def train(model, epoch):
-    model.train()
-    for batch_idx, (data, target) in enumerate(train_loader):
-        optimizer.zero_grad()
-        data = data.to(device)
-        target = target.to(device)
-        data = data.requires_grad_() #set requires_grad to True for training
-        output = model(data)
-        output = output.permute(1, 0, 2) #original output dimensions are batchSizex1x10
-        loss = F.nll_loss(output[0], target) #the loss functions expects a batchSizex10 input
-        loss.backward()
-        optimizer.step()
-        if batch_idx % log_interval == 0: #print training stats
-            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
-                epoch, batch_idx * len(data), len(train_loader.dataset),
-                100. * batch_idx / len(train_loader), loss))
-
-
-######################################################################
-# Now that we have a training function, we need to make one for testing
-# the networks accuracy. We will set the model to ``eval()`` mode and then
-# run inference on the test dataset. Calling ``eval()`` sets the training
-# variable in all modules in the network to false. Certain layers like
-# batch normalization and dropout layers behave differently during
-# training so this step is crucial for getting correct results.
-#
-
-def test(model, epoch):
-    model.eval()
-    correct = 0
-    for data, target in test_loader:
-        data = data.to(device)
-        target = target.to(device)
-        output = model(data)
-        output = output.permute(1, 0, 2)
-        pred = output.max(2)[1] # get the index of the max log-probability
-        correct += pred.eq(target).cpu().sum().item()
-    print('\nTest set: Accuracy: {}/{} ({:.0f}%)\n'.format(
-        correct, len(test_loader.dataset),
-        100. * correct / len(test_loader.dataset)))
-
-
-######################################################################
-# Finally, we can train and test the network. We will train the network
-# for ten epochs then reduce the learn rate and train for ten more epochs.
-# The network will be tested after each epoch to see how the accuracy
-# varies during the training.
-#
-# .. note:: Due to a build issue, we've reduced the number of epochs to 10.
-#           Run this sample with 40 locally to get the proper values.
-#
-
-log_interval = 20
-for epoch in range(1, 11):
-    if epoch == 31:
-        print("First round of training complete. Setting learn rate to 0.001.")
-    scheduler.step()
-    train(model, epoch)
-    test(model, epoch)
-
-
-######################################################################
-# Conclusion
-# ----------
-#
-# If trained on 9 folders, the network should be more than 50% accurate by
-# the end of the training process. Training on less folders will result in
-# a lower overall accuracy but may be necessary if long runtimes are a
-# problem. Greater accuracies can be achieved using deeper CNNs at the
-# expense of a larger memory footprint.
-#
-# For more advanced audio applications, such as speech recognition,
-# recurrent neural networks (RNNs) are commonly used. There are also other
-# data preprocessing methods, such as finding the mel frequency cepstral
-# coefficients (MFCC), that can reduce the size of the dataset.
-#
-
diff --git a/beginner_source/audio_data_augmentation_tutorial.rst b/beginner_source/audio_data_augmentation_tutorial.rst
new file mode 100644
index 00000000000..55ba024a590
--- /dev/null
+++ b/beginner_source/audio_data_augmentation_tutorial.rst
@@ -0,0 +1,10 @@
+Audio Data Augmentation
+=======================
+
+This tutorial has been moved to https://pytorch.org/audio/stable/tutorials/audio_data_augmentation_tutorial.html
+
+It will redirect in 3 seconds.
+
+.. raw:: html
+
+   <meta http-equiv="Refresh" content="3; url='https://pytorch.org/audio/stable/tutorials/audio_data_augmentation_tutorial.html'" />
diff --git a/beginner_source/audio_datasets_tutorial.rst b/beginner_source/audio_datasets_tutorial.rst
new file mode 100644
index 00000000000..6e9b4f4f48a
--- /dev/null
+++ b/beginner_source/audio_datasets_tutorial.rst
@@ -0,0 +1,10 @@
+Audio Datasets
+==============
+
+This tutorial has been moved to https://pytorch.org/audio/stable/tutorials/audio_datasets_tutorial.html
+
+It will redirect in 3 seconds.
+
+.. raw:: html
+
+   <meta http-equiv="Refresh" content="3; url='https://pytorch.org/audio/stable/tutorials/audio_datasets_tutorial.html'" />
diff --git a/beginner_source/audio_feature_augmentation_tutorial.rst b/beginner_source/audio_feature_augmentation_tutorial.rst
new file mode 100644
index 00000000000..55d3811b3fa
--- /dev/null
+++ b/beginner_source/audio_feature_augmentation_tutorial.rst
@@ -0,0 +1,10 @@
+Audio Feature Augmentation
+==========================
+
+This tutorial has been moved to https://pytorch.org/audio/stable/tutorials/audio_data_augmentation_tutorial.html
+
+It will redirect in 3 seconds.
+
+.. raw:: html
+
+   <meta http-equiv="Refresh" content="3; url='https://pytorch.org/audio/stable/tutorials/audio_data_augmentation_tutorial.html'" />
diff --git a/beginner_source/audio_feature_extractions_tutorial.rst b/beginner_source/audio_feature_extractions_tutorial.rst
new file mode 100644
index 00000000000..a2a8da4ab75
--- /dev/null
+++ b/beginner_source/audio_feature_extractions_tutorial.rst
@@ -0,0 +1,10 @@
+Audio Feature Extractions
+=========================
+
+This tutorial has been moved to https://pytorch.org/audio/stable/tutorials/audio_feature_extractions_tutorial.html
+
+It will redirect in 3 seconds.
+
+.. raw:: html
+
+   <meta http-equiv="Refresh" content="3; url='https://pytorch.org/audio/stable/tutorials/audio_feature_extractions_tutorial.html'" />
diff --git a/beginner_source/audio_io_tutorial.rst b/beginner_source/audio_io_tutorial.rst
new file mode 100644
index 00000000000..3263ad93a98
--- /dev/null
+++ b/beginner_source/audio_io_tutorial.rst
@@ -0,0 +1,10 @@
+Audio I/O
+=========
+
+This tutorial has been moved to https://pytorch.org/audio/stable/tutorials/audio_io_tutorial.html
+
+It will redirect in 3 seconds.
+
+.. raw:: html
+
+   <meta http-equiv="Refresh" content="3; url='https://pytorch.org/audio/stable/tutorials/audio_io_tutorial.html'" />
diff --git a/beginner_source/audio_resampling_tutorial.rst b/beginner_source/audio_resampling_tutorial.rst
new file mode 100644
index 00000000000..01210830eb7
--- /dev/null
+++ b/beginner_source/audio_resampling_tutorial.rst
@@ -0,0 +1,9 @@
+Audio Resampling
+================
+
+This tutorial has been moved to `a new location <https://pytorch.org/audio/stable/tutorials/audio_resampling_tutorial.html>`_
+You will be redirected in 3 seconds.
+
+.. raw:: html
+
+   <meta http-equiv="Refresh" content="3; url='https://pytorch.org/audio/stable/tutorials/audio_resampling_tutorial.html'" />
diff --git a/beginner_source/aws_distributed_training_tutorial.py b/beginner_source/aws_distributed_training_tutorial.py
deleted file mode 100644
index dbc03698cf2..00000000000
--- a/beginner_source/aws_distributed_training_tutorial.py
+++ /dev/null
@@ -1,695 +0,0 @@
-"""
-PyTorch 1.0 Distributed Trainer with Amazon AWS
-===============================================
-
-**Author**: `Nathan Inkawhich <https://github.com/inkawhich>`_
-
-**Edited by**: `Teng Li <https://github.com/teng-li>`_
-
-"""
-
-
-######################################################################
-# In this tutorial we will show how to setup, code, and run a PyTorch 1.0
-# distributed trainer across two multi-gpu Amazon AWS nodes. We will start
-# with describing the AWS setup, then the PyTorch environment
-# configuration, and finally the code for the distributed trainer.
-# Hopefully you will find that there is actually very little code change
-# required to extend your current training code to a distributed
-# application, and most of the work is in the one-time environment setup.
-#
-
-
-######################################################################
-# Amazon AWS Setup
-# ----------------
-#
-# In this tutorial we will run distributed training across two multi-gpu
-# nodes. In this section we will first cover how to create the nodes, then
-# how to setup the security group so the nodes can communicate with
-# eachother.
-#
-# Creating the Nodes
-# ~~~~~~~~~~~~~~~~~~
-#
-# In Amazon AWS, there are seven steps to creating an instance. To get
-# started, login and select **Launch Instance**.
-#
-# **Step 1: Choose an Amazon Machine Image (AMI)** - Here we will select
-# the ``Deep Learning AMI (Ubuntu) Version 14.0``. As described, this
-# instance comes with many of the most popular deep learning frameworks
-# installed and is preconfigured with CUDA, cuDNN, and NCCL. It is a very
-# good starting point for this tutorial.
-#
-# **Step 2: Choose an Instance Type** - Now, select the GPU compute unit
-# called ``p2.8xlarge``. Notice, each of these instances has a different
-# cost but this instance provides 8 NVIDIA Tesla K80 GPUs per node, and
-# provides a good architecture for multi-gpu distributed training.
-#
-# **Step 3: Configure Instance Details** - The only setting to change here
-# is increasing the *Number of instances* to 2. All other configurations
-# may be left at default.
-#
-# **Step 4: Add Storage** - Notice, by default these nodes do not come
-# with a lot of storage (only 75 GB). For this tutorial, since we are only
-# using the STL-10 dataset, this is plenty of storage. But, if you want to
-# train on a larger dataset such as ImageNet, you will have to add much
-# more storage just to fit the dataset and any trained models you wish to
-# save.
-#
-# **Step 5: Add Tags** - Nothing to be done here, just move on.
-#
-# **Step 6: Configure Security Group** - This is a critical step in the
-# configuration process. By default two nodes in the same security group
-# would not be able to communicate in the distributed training setting.
-# Here, we want to create a **new** security group for the two nodes to be
-# in. However, we cannot finish configuring in this step. For now, just
-# remember your new security group name (e.g. launch-wizard-12) then move
-# on to Step 7.
-#
-# **Step 7: Review Instance Launch** - Here, review the instance then
-# launch it. By default, this will automatically start initializing the
-# two instances. You can monitor the initialization progress from the
-# dashboard.
-#
-# Configure Security Group
-# ~~~~~~~~~~~~~~~~~~~~~~~~
-#
-# Recall that we were not able to properly configure the security group
-# when creating the instances. Once you have launched the instance, select
-# the *Network & Security > Security Groups* tab in the EC2 dashboard.
-# This will bring up a list of security groups you have access to. Select
-# the new security group you created in Step 6 (i.e. launch-wizard-12),
-# which will bring up tabs called *Description, Inbound, Outbound, and
-# Tags*. First, select the *Inbound* tab and *Edit* to add a rule to allow
-# "All Traffic" from "Sources" in the launch-wizard-12 security group.
-# Then select the *Outbound* tab and do the exact same thing. Now, we have
-# effectively allowed all Inbound and Outbound traffic of all types
-# between nodes in the launch-wizard-12 security group.
-#
-# Necessary Information
-# ~~~~~~~~~~~~~~~~~~~~~
-#
-# Before continuing, we must find and remember the IP addresses of both
-# nodes. In the EC2 dashboard find your running instances. For both
-# instances, write down the *IPv4 Public IP* and the *Private IPs*. For
-# the remainder of the document, we will refer to these as the
-# **node0-publicIP**, **node0-privateIP**, **node1-publicIP**, and
-# **node1-privateIP**. The public IPs are the addresses we will use to SSH
-# in, and the private IPs will be used for inter-node communication.
-#
-
-
-######################################################################
-# Environment Setup
-# -----------------
-#
-# The next critical step is the setup of each node. Unfortunately, we
-# cannot configure both nodes at the same time, so this process must be
-# done on each node separately. However, this is a one time setup, so once
-# you have the nodes configured properly you will not have to reconfigure
-# for future distributed training projects.
-#
-# The first step, once logged onto the node, is to create a new conda
-# environment with python 3.6 and numpy. Once created activate the
-# environment.
-#
-# ::
-#
-#     $ conda create -n nightly_pt python=3.6 numpy
-#     $ source activate nightly_pt
-#
-# Next, we will install a nightly build of Cuda 9.0 enabled PyTorch with
-# pip in the conda environment.
-#
-# ::
-#
-#     $ pip install torch_nightly -f https://download.pytorch.org/whl/nightly/cu90/torch_nightly.html
-#
-# We must also install torchvision so we can use the torchvision model and
-# dataset. At this time, we must build torchvision from source as the pip
-# installation will by default install an old version of PyTorch on top of
-# the nightly build we just installed.
-#
-# ::
-#
-#     $ cd
-#     $ git clone https://github.com/pytorch/vision.git
-#     $ cd vision
-#     $ python setup.py install
-#
-# And finally, **VERY IMPORTANT** step is to set the network interface
-# name for the NCCL socket. This is set with the environment variable
-# ``NCCL_SOCKET_IFNAME``. To get the correct name, run the ``ifconfig``
-# command on the node and look at the interface name that corresponds to
-# the node's *privateIP* (e.g. ens3). Then set the environment variable as
-#
-# ::
-#
-#     $ export NCCL_SOCKET_IFNAME=ens3
-#
-# Remember, do this on both nodes. You may also consider adding the
-# NCCL\_SOCKET\_IFNAME setting to your *.bashrc*. An important observation
-# is that we did not setup a shared filesystem between the nodes.
-# Therefore, each node will have to have a copy of the code and a copy of
-# the datasets. For more information about setting up a shared network
-# filesystem between nodes, see
-# `here <https://aws.amazon.com/blogs/aws/amazon-elastic-file-system-shared-file-storage-for-amazon-ec2/>`__.
-#
-
-
-######################################################################
-# Distributed Training Code
-# -------------------------
-#
-# With the instances running and the environments setup we can now get
-# into the training code. Most of the code here has been taken from the
-# `PyTorch ImageNet
-# Example <https://github.com/pytorch/examples/tree/master/imagenet>`__
-# which also supports distributed training. This code provides a good
-# starting point for a custom trainer as it has much of the boilerplate
-# training loop, validation loop, and accuracy tracking functionality.
-# However, you will notice that the argument parsing and other
-# non-essential functions have been stripped out for simplicity.
-#
-# In this example we will use
-# `torchvision.models.resnet18 <https://pytorch.org/docs/stable/torchvision/models.html#torchvision.models.resnet18>`__
-# model and will train it on the
-# `torchvision.datasets.STL10 <https://pytorch.org/docs/stable/torchvision/datasets.html#torchvision.datasets.STL10>`__
-# dataset. To accomodate for the dimensionality mismatch of STL-10 with
-# Resnet18, we will resize each image to 224x224 with a transform. Notice,
-# the choice of model and dataset are orthogonal to the distributed
-# training code, you may use any dataset and model you wish and the
-# process is the same. Lets get started by first handling the imports and
-# talking about some helper functions. Then we will define the train and
-# test functions, which have been largely taken from the ImageNet Example.
-# At the end, we will build the main part of the code which handles the
-# distributed training setup. And finally, we will discuss how to actually
-# run the code.
-#
-
-
-######################################################################
-# Imports
-# ~~~~~~~
-#
-# The important distributed training specific imports here are
-# `torch.nn.parallel <https://pytorch.org/docs/stable/nn.html#torch.nn.parallel.DistributedDataParallel>`__,
-# `torch.distributed <https://pytorch.org/docs/stable/distributed.html>`__,
-# `torch.utils.data.distributed <https://pytorch.org/docs/stable/data.html#torch.utils.data.distributed.DistributedSampler>`__,
-# and
-# `torch.multiprocessing <https://pytorch.org/docs/stable/multiprocessing.html>`__.
-# It is also important to set the multiprocessing start method to *spawn*
-# or *forkserver* (only supported in Python 3),
-# as the default is *fork* which may cause deadlocks when using multiple
-# worker processes for dataloading.
-#
-
-import time
-import sys
-import torch
-
-if __name__ == '__main__':
-    torch.multiprocessing.set_start_method('spawn')
-
-import torch.nn as nn
-import torch.nn.parallel
-import torch.distributed as dist
-import torch.optim
-import torch.utils.data
-import torch.utils.data.distributed
-import torchvision.transforms as transforms
-import torchvision.datasets as datasets
-import torchvision.models as models
-
-from torch.multiprocessing import Pool, Process
-
-
-######################################################################
-# Helper Functions
-# ~~~~~~~~~~~~~~~~
-#
-# We must also define some helper functions and classes that will make
-# training easier. The ``AverageMeter`` class tracks training statistics
-# like accuracy and iteration count. The ``accuracy`` function computes
-# and returns the top-k accuracy of the model so we can track learning
-# progress. Both are provided for training convenience but neither are
-# distributed training specific.
-#
-
-class AverageMeter(object):
-    """Computes and stores the average and current value"""
-    def __init__(self):
-        self.reset()
-
-    def reset(self):
-        self.val = 0
-        self.avg = 0
-        self.sum = 0
-        self.count = 0
-
-    def update(self, val, n=1):
-        self.val = val
-        self.sum += val * n
-        self.count += n
-        self.avg = self.sum / self.count
-
-def accuracy(output, target, topk=(1,)):
-    """Computes the precision@k for the specified values of k"""
-    with torch.no_grad():
-        maxk = max(topk)
-        batch_size = target.size(0)
-
-        _, pred = output.topk(maxk, 1, True, True)
-        pred = pred.t()
-        correct = pred.eq(target.view(1, -1).expand_as(pred))
-
-        res = []
-        for k in topk:
-            correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)
-            res.append(correct_k.mul_(100.0 / batch_size))
-        return res
-
-
-######################################################################
-# Train Functions
-# ~~~~~~~~~~~~~~~
-#
-# To simplify the main loop, it is best to separate a training epoch step
-# into a function called ``train``. This function trains the input model
-# for one epoch of the *train\_loader*. The only distributed training
-# artifact in this function is setting the
-# `non\_blocking <https://pytorch.org/docs/stable/notes/cuda.html#use-pinned-memory-buffers>`__
-# attributes of the data and label tensors to ``True`` before the forward
-# pass. This allows asynchronous GPU copies of the data meaning transfers
-# can be overlapped with computation. This function also outputs training
-# statistics along the way so we can track progress throughout the epoch.
-#
-# The other function to define here is ``adjust_learning_rate``, which
-# decays the initial learning rate at a fixed schedule. This is another
-# boilerplate trainer function that is useful to train accurate models.
-#
-
-def train(train_loader, model, criterion, optimizer, epoch):
-
-    batch_time = AverageMeter()
-    data_time = AverageMeter()
-    losses = AverageMeter()
-    top1 = AverageMeter()
-    top5 = AverageMeter()
-
-    # switch to train mode
-    model.train()
-
-    end = time.time()
-    for i, (input, target) in enumerate(train_loader):
-
-        # measure data loading time
-        data_time.update(time.time() - end)
-
-        # Create non_blocking tensors for distributed training
-        input = input.cuda(non_blocking=True)
-        target = target.cuda(non_blocking=True)
-
-        # compute output
-        output = model(input)
-        loss = criterion(output, target)
-
-        # measure accuracy and record loss
-        prec1, prec5 = accuracy(output, target, topk=(1, 5))
-        losses.update(loss.item(), input.size(0))
-        top1.update(prec1[0], input.size(0))
-        top5.update(prec5[0], input.size(0))
-
-        # compute gradients in a backward pass
-        optimizer.zero_grad()
-        loss.backward()
-
-        # Call step of optimizer to update model params
-        optimizer.step()
-
-        # measure elapsed time
-        batch_time.update(time.time() - end)
-        end = time.time()
-
-        if i % 10 == 0:
-            print('Epoch: [{0}][{1}/{2}]\t'
-                  'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
-                  'Data {data_time.val:.3f} ({data_time.avg:.3f})\t'
-                  'Loss {loss.val:.4f} ({loss.avg:.4f})\t'
-                  'Prec@1 {top1.val:.3f} ({top1.avg:.3f})\t'
-                  'Prec@5 {top5.val:.3f} ({top5.avg:.3f})'.format(
-                   epoch, i, len(train_loader), batch_time=batch_time,
-                   data_time=data_time, loss=losses, top1=top1, top5=top5))
-
-def adjust_learning_rate(initial_lr, optimizer, epoch):
-    """Sets the learning rate to the initial LR decayed by 10 every 30 epochs"""
-    lr = initial_lr * (0.1 ** (epoch // 30))
-    for param_group in optimizer.param_groups:
-        param_group['lr'] = lr
-
-
-
-######################################################################
-# Validation Function
-# ~~~~~~~~~~~~~~~~~~~
-#
-# To track generalization performance and simplify the main loop further
-# we can also extract the validation step into a function called
-# ``validate``. This function runs a full validation step of the input
-# model on the input validation dataloader and returns the top-1 accuracy
-# of the model on the validation set. Again, you will notice the only
-# distributed training feature here is setting ``non_blocking=True`` for
-# the training data and labels before they are passed to the model.
-#
-
-def validate(val_loader, model, criterion):
-
-    batch_time = AverageMeter()
-    losses = AverageMeter()
-    top1 = AverageMeter()
-    top5 = AverageMeter()
-
-    # switch to evaluate mode
-    model.eval()
-
-    with torch.no_grad():
-        end = time.time()
-        for i, (input, target) in enumerate(val_loader):
-
-            input = input.cuda(non_blocking=True)
-            target = target.cuda(non_blocking=True)
-
-            # compute output
-            output = model(input)
-            loss = criterion(output, target)
-
-            # measure accuracy and record loss
-            prec1, prec5 = accuracy(output, target, topk=(1, 5))
-            losses.update(loss.item(), input.size(0))
-            top1.update(prec1[0], input.size(0))
-            top5.update(prec5[0], input.size(0))
-
-            # measure elapsed time
-            batch_time.update(time.time() - end)
-            end = time.time()
-
-            if i % 100 == 0:
-                print('Test: [{0}/{1}]\t'
-                      'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
-                      'Loss {loss.val:.4f} ({loss.avg:.4f})\t'
-                      'Prec@1 {top1.val:.3f} ({top1.avg:.3f})\t'
-                      'Prec@5 {top5.val:.3f} ({top5.avg:.3f})'.format(
-                       i, len(val_loader), batch_time=batch_time, loss=losses,
-                       top1=top1, top5=top5))
-
-        print(' * Prec@1 {top1.avg:.3f} Prec@5 {top5.avg:.3f}'
-              .format(top1=top1, top5=top5))
-
-    return top1.avg
-
-
-######################################################################
-# Inputs
-# ~~~~~~
-#
-# With the helper functions out of the way, now we have reached the
-# interesting part. Here is where we will define the inputs for the run.
-# Some of the inputs are standard model training inputs such as batch size
-# and number of training epochs, and some are specific to our distributed
-# training task. The required inputs are:
-#
-# -  **batch\_size** - batch size for *each* process in the distributed
-#    training group. Total batch size across distributed model is
-#    batch\_size\*world\_size
-#
-# -  **workers** - number of worker processes used with the dataloaders in
-#    each process
-#
-# -  **num\_epochs** - total number of epochs to train for
-#
-# -  **starting\_lr** - starting learning rate for training
-#
-# -  **world\_size** - number of processes in the distributed training
-#    environment
-#
-# -  **dist\_backend** - backend to use for distributed training
-#    communication (i.e. NCCL, Gloo, MPI, etc.). In this tutorial, since
-#    we are using several multi-gpu nodes, NCCL is suggested.
-#
-# -  **dist\_url** - URL to specify the initialization method of the
-#    process group. This may contain the IP address and port of the rank0
-#    process or be a non-existant file on a shared file system. Here,
-#    since we do not have a shared file system this will incorporate the
-#    **node0-privateIP** and the port on node0 to use.
-#
-
-print("Collect Inputs...")
-
-# Batch Size for training and testing
-batch_size = 32
-
-# Number of additional worker processes for dataloading
-workers = 2
-
-# Number of epochs to train for
-num_epochs = 2
-
-# Starting Learning Rate
-starting_lr = 0.1
-
-# Number of distributed processes
-world_size = 4
-
-# Distributed backend type
-dist_backend = 'nccl'
-
-# Url used to setup distributed training
-dist_url = "tcp://172.31.22.234:23456"
-
-
-######################################################################
-# Initialize process group
-# ~~~~~~~~~~~~~~~~~~~~~~~~
-#
-# One of the most important parts of distributed training in PyTorch is to
-# properly setup the process group, which is the **first** step in
-# initializing the ``torch.distributed`` package. To do this, we will use
-# the ``torch.distributed.init_process_group`` function which takes
-# several inputs. First, a *backend* input which specifies the backend to
-# use (i.e. NCCL, Gloo, MPI, etc.). An *init\_method* input which is
-# either a url containing the address and port of the rank0 machine or a
-# path to a non-existant file on the shared file system. Note, to use the
-# file init\_method, all machines must have access to the file, similarly
-# for the url method, all machines must be able to communicate on the
-# network so make sure to configure any firewalls and network settings to
-# accomodate. The *init\_process\_group* function also takes *rank* and
-# *world\_size* arguments which specify the rank of this process when run
-# and the number of processes in the collective, respectively.
-# The *init\_method* input can also be "env://". In this case, the address
-# and port of the rank0 machine will be read from the following two
-# environment variables respectively: MASTER_ADDR, MASTER_PORT.  If *rank*
-# and *world\_size* arguments are not specified in the *init\_process\_group*
-# function, they both can be read from the following two environment
-# variables respectively as well: RANK, WORLD_SIZE.
-#
-# Another important step, especially when each node has multiple gpus is
-# to set the *local\_rank* of this process. For example, if you have two
-# nodes, each with 8 GPUs and you wish to train with all of them then
-# :math:`world\_size=16` and each node will have a process with local rank
-# 0-7. This local\_rank is used to set the device (i.e. which GPU to use)
-# for the process and later used to set the device when creating a
-# distributed data parallel model. It is also recommended to use NCCL
-# backend in this hypothetical environment as NCCL is preferred for
-# multi-gpu nodes.
-#
-
-print("Initialize Process Group...")
-# Initialize Process Group
-# v1 - init with url
-dist.init_process_group(backend=dist_backend, init_method=dist_url, rank=int(sys.argv[1]), world_size=world_size)
-# v2 - init with file
-# dist.init_process_group(backend="nccl", init_method="file:///home/ubuntu/pt-distributed-tutorial/trainfile", rank=int(sys.argv[1]), world_size=world_size)
-# v3 - init with environment variables
-# dist.init_process_group(backend="nccl", init_method="env://", rank=int(sys.argv[1]), world_size=world_size)
-
-
-# Establish Local Rank and set device on this node
-local_rank = int(sys.argv[2])
-dp_device_ids = [local_rank]
-torch.cuda.set_device(local_rank)
-
-
-######################################################################
-# Initialize Model
-# ~~~~~~~~~~~~~~~~
-#
-# The next major step is to initialize the model to be trained. Here, we
-# will use a resnet18 model from ``torchvision.models`` but any model may
-# be used. First, we initialize the model and place it in GPU memory.
-# Next, we make the model ``DistributedDataParallel``, which handles the
-# distribution of the data to and from the model and is critical for
-# distributed training. The ``DistributedDataParallel`` module also
-# handles the averaging of gradients across the world, so we do not have
-# to explicitly average the gradients in the training step.
-#
-# It is important to note that this is a blocking function, meaning
-# program execution will wait at this function until *world\_size*
-# processes have joined the process group. Also, notice we pass our device
-# ids list as a parameter which contains the local rank (i.e. GPU) we are
-# using. Finally, we specify the loss function and optimizer to train the
-# model with.
-#
-
-print("Initialize Model...")
-# Construct Model
-model = models.resnet18(pretrained=False).cuda()
-# Make model DistributedDataParallel
-model = torch.nn.parallel.DistributedDataParallel(model, device_ids=dp_device_ids, output_device=local_rank)
-
-# define loss function (criterion) and optimizer
-criterion = nn.CrossEntropyLoss().cuda()
-optimizer = torch.optim.SGD(model.parameters(), starting_lr, momentum=0.9, weight_decay=1e-4)
-
-
-######################################################################
-# Initialize Dataloaders
-# ~~~~~~~~~~~~~~~~~~~~~~
-#
-# The last step in preparation for the training is to specify which
-# dataset to use. Here we use the `STL-10
-# dataset <https://cs.stanford.edu/~acoates/stl10/>`__ from
-# `torchvision.datasets.STL10 <https://pytorch.org/docs/stable/torchvision/datasets.html#torchvision.datasets.STL10>`__.
-# The STL10 dataset is a 10 class dataset of 96x96px color images. For use
-# with our model, we resize the images to 224x224px in the transform. One
-# distributed training specific item in this section is the use of the
-# ``DistributedSampler`` for the training set, which is designed to be
-# used in conjunction with ``DistributedDataParallel`` models. This object
-# handles the partitioning of the dataset across the distributed
-# environment so that not all models are training on the same subset of
-# data, which would be counterproductive. Finally, we create the
-# ``DataLoader``'s which are responsible for feeding the data to the
-# processes.
-#
-# The STL-10 dataset will automatically download on the nodes if they are
-# not present. If you wish to use your own dataset you should download the
-# data, write your own dataset handler, and construct a dataloader for
-# your dataset here.
-#
-
-print("Initialize Dataloaders...")
-# Define the transform for the data. Notice, we must resize to 224x224 with this dataset and model.
-transform = transforms.Compose(
-    [transforms.Resize(224),
-     transforms.ToTensor(),
-     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
-
-# Initialize Datasets. STL10 will automatically download if not present
-trainset = datasets.STL10(root='./data', split='train', download=True, transform=transform)
-valset = datasets.STL10(root='./data', split='test', download=True, transform=transform)
-
-# Create DistributedSampler to handle distributing the dataset across nodes when training
-# This can only be called after torch.distributed.init_process_group is called
-train_sampler = torch.utils.data.distributed.DistributedSampler(trainset)
-
-# Create the Dataloaders to feed data to the training and validation steps
-train_loader = torch.utils.data.DataLoader(trainset, batch_size=batch_size, shuffle=(train_sampler is None), num_workers=workers, pin_memory=False, sampler=train_sampler)
-val_loader = torch.utils.data.DataLoader(valset, batch_size=batch_size, shuffle=False, num_workers=workers, pin_memory=False)
-
-
-######################################################################
-# Training Loop
-# ~~~~~~~~~~~~~
-#
-# The last step is to define the training loop. We have already done most
-# of the work for setting up the distributed training so this is not
-# distributed training specific. The only detail is setting the current
-# epoch count in the ``DistributedSampler``, as the sampler shuffles the
-# data going to each process deterministically based on epoch. After
-# updating the sampler, the loop runs a full training epoch, runs a full
-# validation step then prints the performance of the current model against
-# the best performing model so far. After training for num\_epochs, the
-# loop exits and the tutorial is complete. Notice, since this is an
-# exercise we are not saving models but one may wish to keep track of the
-# best performing model then save it at the end of training (see
-# `here <https://github.com/pytorch/examples/blob/master/imagenet/main.py#L184>`__).
-#
-
-best_prec1 = 0
-
-for epoch in range(num_epochs):
-    # Set epoch count for DistributedSampler
-    train_sampler.set_epoch(epoch)
-
-    # Adjust learning rate according to schedule
-    adjust_learning_rate(starting_lr, optimizer, epoch)
-
-    # train for one epoch
-    print("\nBegin Training Epoch {}".format(epoch+1))
-    train(train_loader, model, criterion, optimizer, epoch)
-
-    # evaluate on validation set
-    print("Begin Validation @ Epoch {}".format(epoch+1))
-    prec1 = validate(val_loader, model, criterion)
-
-    # remember best prec@1 and save checkpoint if desired
-    # is_best = prec1 > best_prec1
-    best_prec1 = max(prec1, best_prec1)
-
-    print("Epoch Summary: ")
-    print("\tEpoch Accuracy: {}".format(prec1))
-    print("\tBest Accuracy: {}".format(best_prec1))
-
-
-######################################################################
-# Running the Code
-# ----------------
-#
-# Unlike most of the other PyTorch tutorials, this code may not be run
-# directly out of this notebook. To run, download the .py version of this
-# file (or convert it using
-# `this <https://gist.github.com/chsasank/7218ca16f8d022e02a9c0deb94a310fe>`__)
-# and upload a copy to both nodes. The astute reader would have noticed
-# that we hardcoded the **node0-privateIP** and :math:`world\_size=4` but
-# input the *rank* and *local\_rank* inputs as arg[1] and arg[2] command
-# line arguments, respectively. Once uploaded, open two ssh terminals into
-# each node.
-#
-# -  On the first terminal for node0, run ``$ python main.py 0 0``
-#
-# -  On the second terminal for node0 run ``$ python main.py 1 1``
-#
-# -  On the first terminal for node1, run ``$ python main.py 2 0``
-#
-# -  On the second terminal for node1 run ``$ python main.py 3 1``
-#
-# The programs will start and wait after printing "Initialize Model..."
-# for all four processes to join the process group. Notice the first
-# argument is not repeated as this is the unique global rank of the
-# process. The second argument is repeated as that is the local rank of
-# the process running on the node. If you run ``nvidia-smi`` on each node,
-# you will see two processes on each node, one running on GPU0 and one on
-# GPU1.
-#
-# We have now completed the distributed training example! Hopefully you
-# can see how you would use this tutorial to help train your own models on
-# your own datasets, even if you are not using the exact same distributed
-# envrionment. If you are using AWS, don't forget to **SHUT DOWN YOUR
-# NODES** if you are not using them or you may find an uncomfortably large
-# bill at the end of the month.
-#
-# **Where to go next**
-#
-# -  Check out the `launcher
-#    utility <https://pytorch.org/docs/stable/distributed.html#launch-utility>`__
-#    for a different way of kicking off the run
-#
-# -  Check out the `torch.multiprocessing.spawn
-#    utility <https://pytorch.org/docs/master/multiprocessing.html#spawning-subprocesses>`__
-#    for another easy way of kicking off multiple distributed processes.
-#    `PyTorch ImageNet Example <https://github.com/pytorch/examples/tree/master/imagenet>`__
-#    has it implemented and can demonstrate how to use it.
-#
-# -  If possible, setup a NFS so you only need one copy of the dataset
-#
-
diff --git a/beginner_source/basics/README.txt b/beginner_source/basics/README.txt
new file mode 100644
index 00000000000..d247c7253ea
--- /dev/null
+++ b/beginner_source/basics/README.txt
@@ -0,0 +1,38 @@
+Learn the Basics
+------------------
+
+1. intro.py
+    Learn the Basics
+    https://pytorch.org/tutorials/beginner/basics/intro.html
+
+2. quickstart_tutorial.py
+    Quickstart
+    https://pytorch.org/tutorials/beginner/basics/quickstart_tutorial.html
+
+3. tensorqs_tutorial.py
+    Tensors
+    https://pytorch.org/tutorials/beginner/basics/tensor_tutorial.html
+
+4. data_tutorial.py
+    Datasets & DataLoaders
+    https://pytorch.org/tutorials/beginner/basics/data_tutorial.html
+
+5. transforms_tutorial.py
+    Transforms
+    https://pytorch.org/tutorials/beginner/basics/transforms_tutorial.html
+
+6. buildmodel_tutorial.py
+    Building the Neural Network
+    https://pytorch.org/tutorials/beginner/basics/buildmodel_tutorial.html
+
+7. autogradqs_tutorial.py
+    Automatic Differentiation with torch.autograd_tutorial
+    https://pytorch.org/tutorials/beginner/basics/autograd_tutorial.html
+
+8. optimization_tutorial.py
+    Optimizing Model Parameters
+    https://pytorch.org/tutorials/beginner/basics/optimization_tutorial.html
+
+9. saveloadrun_tutorial.py
+    Save and Load the Model
+    https://pytorch.org/tutorials/beginner/basics/saveloadrun_tutorial.html
diff --git a/beginner_source/basics/autogradqs_tutorial.py b/beginner_source/basics/autogradqs_tutorial.py
new file mode 100644
index 00000000000..8eff127ddee
--- /dev/null
+++ b/beginner_source/basics/autogradqs_tutorial.py
@@ -0,0 +1,240 @@
+"""
+`Learn the Basics <intro.html>`_ ||
+`Quickstart <quickstart_tutorial.html>`_ ||
+`Tensors <tensorqs_tutorial.html>`_ ||
+`Datasets & DataLoaders <data_tutorial.html>`_ ||
+`Transforms <transforms_tutorial.html>`_ ||
+`Build Model <buildmodel_tutorial.html>`_ ||
+**Autograd** ||
+`Optimization <optimization_tutorial.html>`_ ||
+`Save & Load Model <saveloadrun_tutorial.html>`_
+
+Automatic Differentiation with ``torch.autograd``
+=================================================
+
+When training neural networks, the most frequently used algorithm is
+**back propagation**. In this algorithm, parameters (model weights) are
+adjusted according to the **gradient** of the loss function with respect
+to the given parameter.
+
+To compute those gradients, PyTorch has a built-in differentiation engine
+called ``torch.autograd``. It supports automatic computation of gradient for any
+computational graph.
+
+Consider the simplest one-layer neural network, with input ``x``,
+parameters ``w`` and ``b``, and some loss function. It can be defined in
+PyTorch in the following manner:
+"""
+
+import torch
+
+x = torch.ones(5)  # input tensor
+y = torch.zeros(3)  # expected output
+w = torch.randn(5, 3, requires_grad=True)
+b = torch.randn(3, requires_grad=True)
+z = torch.matmul(x, w)+b
+loss = torch.nn.functional.binary_cross_entropy_with_logits(z, y)
+
+
+######################################################################
+# Tensors, Functions and Computational graph
+# ------------------------------------------
+#
+# This code defines the following **computational graph**:
+#
+# .. figure:: /_static/img/basics/comp-graph.png
+#    :alt:
+#
+# In this network, ``w`` and ``b`` are **parameters**, which we need to
+# optimize. Thus, we need to be able to compute the gradients of loss
+# function with respect to those variables. In order to do that, we set
+# the ``requires_grad`` property of those tensors.
+
+#######################################################################
+# .. note:: You can set the value of ``requires_grad`` when creating a
+#           tensor, or later by using ``x.requires_grad_(True)`` method.
+
+#######################################################################
+# A function that we apply to tensors to construct computational graph is
+# in fact an object of class ``Function``. This object knows how to
+# compute the function in the *forward* direction, and also how to compute
+# its derivative during the *backward propagation* step. A reference to
+# the backward propagation function is stored in ``grad_fn`` property of a
+# tensor. You can find more information of ``Function`` `in the
+# documentation <https://pytorch.org/docs/stable/autograd.html#function>`__.
+#
+
+print(f"Gradient function for z = {z.grad_fn}")
+print(f"Gradient function for loss = {loss.grad_fn}")
+
+######################################################################
+# Computing Gradients
+# -------------------
+#
+# To optimize weights of parameters in the neural network, we need to
+# compute the derivatives of our loss function with respect to parameters,
+# namely, we need :math:`\frac{\partial loss}{\partial w}` and
+# :math:`\frac{\partial loss}{\partial b}` under some fixed values of
+# ``x`` and ``y``. To compute those derivatives, we call
+# ``loss.backward()``, and then retrieve the values from ``w.grad`` and
+# ``b.grad``:
+#
+
+loss.backward()
+print(w.grad)
+print(b.grad)
+
+
+######################################################################
+# .. note::
+#   - We can only obtain the ``grad`` properties for the leaf
+#     nodes of the computational graph, which have ``requires_grad`` property
+#     set to ``True``. For all other nodes in our graph, gradients will not be
+#     available.
+#   - We can only perform gradient calculations using
+#     ``backward`` once on a given graph, for performance reasons. If we need
+#     to do several ``backward`` calls on the same graph, we need to pass
+#     ``retain_graph=True`` to the ``backward`` call.
+#
+
+
+######################################################################
+# Disabling Gradient Tracking
+# ---------------------------
+#
+# By default, all tensors with ``requires_grad=True`` are tracking their
+# computational history and support gradient computation. However, there
+# are some cases when we do not need to do that, for example, when we have
+# trained the model and just want to apply it to some input data, i.e. we
+# only want to do *forward* computations through the network. We can stop
+# tracking computations by surrounding our computation code with
+# ``torch.no_grad()`` block:
+#
+
+z = torch.matmul(x, w)+b
+print(z.requires_grad)
+
+with torch.no_grad():
+    z = torch.matmul(x, w)+b
+print(z.requires_grad)
+
+
+######################################################################
+# Another way to achieve the same result is to use the ``detach()`` method
+# on the tensor:
+#
+
+z = torch.matmul(x, w)+b
+z_det = z.detach()
+print(z_det.requires_grad)
+
+######################################################################
+# There are reasons you might want to disable gradient tracking:
+#   - To mark some parameters in your neural network as **frozen parameters**.
+#   - To **speed up computations** when you are only doing forward pass, because computations on tensors that do
+#     not track gradients would be more efficient.
+
+
+######################################################################
+
+######################################################################
+# More on Computational Graphs
+# ----------------------------
+# Conceptually, autograd keeps a record of data (tensors) and all executed
+# operations (along with the resulting new tensors) in a directed acyclic
+# graph (DAG) consisting of
+# `Function <https://pytorch.org/docs/stable/autograd.html#torch.autograd.Function>`__
+# objects. In this DAG, leaves are the input tensors, roots are the output
+# tensors. By tracing this graph from roots to leaves, you can
+# automatically compute the gradients using the chain rule.
+#
+# In a forward pass, autograd does two things simultaneously:
+#
+# - run the requested operation to compute a resulting tensor
+# - maintain the operation’s *gradient function* in the DAG.
+#
+# The backward pass kicks off when ``.backward()`` is called on the DAG
+# root. ``autograd`` then:
+#
+# - computes the gradients from each ``.grad_fn``,
+# - accumulates them in the respective tensor’s ``.grad`` attribute
+# - using the chain rule, propagates all the way to the leaf tensors.
+#
+# .. note::
+#   **DAGs are dynamic in PyTorch**
+#   An important thing to note is that the graph is recreated from scratch; after each
+#   ``.backward()`` call, autograd starts populating a new graph. This is
+#   exactly what allows you to use control flow statements in your model;
+#   you can change the shape, size and operations at every iteration if
+#   needed.
+
+######################################################################
+# Optional Reading: Tensor Gradients and Jacobian Products
+# --------------------------------------------------------
+#
+# In many cases, we have a scalar loss function, and we need to compute
+# the gradient with respect to some parameters. However, there are cases
+# when the output function is an arbitrary tensor. In this case, PyTorch
+# allows you to compute so-called **Jacobian product**, and not the actual
+# gradient.
+#
+# For a vector function :math:`\vec{y}=f(\vec{x})`, where
+# :math:`\vec{x}=\langle x_1,\dots,x_n\rangle` and
+# :math:`\vec{y}=\langle y_1,\dots,y_m\rangle`, a gradient of
+# :math:`\vec{y}` with respect to :math:`\vec{x}` is given by **Jacobian
+# matrix**:
+#
+# .. math::
+#
+#
+#    J=\left(\begin{array}{ccc}
+#       \frac{\partial y_{1}}{\partial x_{1}} & \cdots & \frac{\partial y_{1}}{\partial x_{n}}\\
+#       \vdots & \ddots & \vdots\\
+#       \frac{\partial y_{m}}{\partial x_{1}} & \cdots & \frac{\partial y_{m}}{\partial x_{n}}
+#       \end{array}\right)
+#
+# Instead of computing the Jacobian matrix itself, PyTorch allows you to
+# compute **Jacobian Product** :math:`v^T\cdot J` for a given input vector
+# :math:`v=(v_1 \dots v_m)`. This is achieved by calling ``backward`` with
+# :math:`v` as an argument. The size of :math:`v` should be the same as
+# the size of the original tensor, with respect to which we want to
+# compute the product:
+#
+
+inp = torch.eye(4, 5, requires_grad=True)
+out = (inp+1).pow(2).t()
+out.backward(torch.ones_like(out), retain_graph=True)
+print(f"First call\n{inp.grad}")
+out.backward(torch.ones_like(out), retain_graph=True)
+print(f"\nSecond call\n{inp.grad}")
+inp.grad.zero_()
+out.backward(torch.ones_like(out), retain_graph=True)
+print(f"\nCall after zeroing gradients\n{inp.grad}")
+
+
+######################################################################
+# Notice that when we call ``backward`` for the second time with the same
+# argument, the value of the gradient is different. This happens because
+# when doing ``backward`` propagation, PyTorch **accumulates the
+# gradients**, i.e. the value of computed gradients is added to the
+# ``grad`` property of all leaf nodes of computational graph. If you want
+# to compute the proper gradients, you need to zero out the ``grad``
+# property before. In real-life training an *optimizer* helps us to do
+# this.
+
+######################################################################
+# .. note:: Previously we were calling ``backward()`` function without
+#           parameters. This is essentially equivalent to calling
+#           ``backward(torch.tensor(1.0))``, which is a useful way to compute the
+#           gradients in case of a scalar-valued function, such as loss during
+#           neural network training.
+#
+
+######################################################################
+# --------------
+#
+
+#################################################################
+# Further Reading
+# ~~~~~~~~~~~~~~~~~
+# - `Autograd Mechanics <https://pytorch.org/docs/stable/notes/autograd.html>`_
diff --git a/beginner_source/basics/buildmodel_tutorial.py b/beginner_source/basics/buildmodel_tutorial.py
new file mode 100644
index 00000000000..1806e80feb5
--- /dev/null
+++ b/beginner_source/basics/buildmodel_tutorial.py
@@ -0,0 +1,194 @@
+"""
+`Learn the Basics <intro.html>`_ ||
+`Quickstart <quickstart_tutorial.html>`_ ||
+`Tensors <tensorqs_tutorial.html>`_ ||
+`Datasets & DataLoaders <data_tutorial.html>`_ ||
+`Transforms <transforms_tutorial.html>`_ ||
+**Build Model** ||
+`Autograd <autogradqs_tutorial.html>`_ ||
+`Optimization <optimization_tutorial.html>`_ ||
+`Save & Load Model <saveloadrun_tutorial.html>`_
+
+Build the Neural Network
+========================
+
+Neural networks comprise of layers/modules that perform operations on data.
+The `torch.nn <https://pytorch.org/docs/stable/nn.html>`_ namespace provides all the building blocks you need to
+build your own neural network. Every module in PyTorch subclasses the `nn.Module <https://pytorch.org/docs/stable/generated/torch.nn.Module.html>`_.
+A neural network is a module itself that consists of other modules (layers). This nested structure allows for
+building and managing complex architectures easily.
+
+In the following sections, we'll build a neural network to classify images in the FashionMNIST dataset.
+
+"""
+
+import os
+import torch
+from torch import nn
+from torch.utils.data import DataLoader
+from torchvision import datasets, transforms
+
+
+#############################################
+# Get Device for Training
+# -----------------------
+# We want to be able to train our model on an `accelerator <https://pytorch.org/docs/stable/torch.html#accelerators>`__
+# such as CUDA, MPS, MTIA, or XPU. If the current accelerator is available, we will use it. Otherwise, we use the CPU.
+
+device = torch.accelerator.current_accelerator().type if torch.accelerator.is_available() else "cpu"
+print(f"Using {device} device")
+
+##############################################
+# Define the Class
+# -------------------------
+# We define our neural network by subclassing ``nn.Module``, and
+# initialize the neural network layers in ``__init__``. Every ``nn.Module`` subclass implements
+# the operations on input data in the ``forward`` method.
+
+class NeuralNetwork(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.flatten = nn.Flatten()
+        self.linear_relu_stack = nn.Sequential(
+            nn.Linear(28*28, 512),
+            nn.ReLU(),
+            nn.Linear(512, 512),
+            nn.ReLU(),
+            nn.Linear(512, 10),
+        )
+
+    def forward(self, x):
+        x = self.flatten(x)
+        logits = self.linear_relu_stack(x)
+        return logits
+
+##############################################
+# We create an instance of ``NeuralNetwork``, and move it to the ``device``, and print
+# its structure.
+
+model = NeuralNetwork().to(device)
+print(model)
+
+
+##############################################
+# To use the model, we pass it the input data. This executes the model's ``forward``,
+# along with some `background operations <https://github.com/pytorch/pytorch/blob/270111b7b611d174967ed204776985cefca9c144/torch/nn/modules/module.py#L866>`_.
+# Do not call ``model.forward()`` directly!
+#
+# Calling the model on the input returns a 2-dimensional tensor with dim=0 corresponding to each output of 10 raw predicted values for each class, and dim=1 corresponding to the individual values of each output.
+# We get the prediction probabilities by passing it through an instance of the ``nn.Softmax`` module.
+
+X = torch.rand(1, 28, 28, device=device)
+logits = model(X)
+pred_probab = nn.Softmax(dim=1)(logits)
+y_pred = pred_probab.argmax(1)
+print(f"Predicted class: {y_pred}")
+
+
+######################################################################
+# --------------
+#
+
+
+##############################################
+# Model Layers
+# -------------------------
+#
+# Let's break down the layers in the FashionMNIST model. To illustrate it, we
+# will take a sample minibatch of 3 images of size 28x28 and see what happens to it as
+# we pass it through the network.
+
+input_image = torch.rand(3,28,28)
+print(input_image.size())
+
+##################################################
+# nn.Flatten
+# ^^^^^^^^^^^^^^^^^^^^^^
+# We initialize the `nn.Flatten  <https://pytorch.org/docs/stable/generated/torch.nn.Flatten.html>`_
+# layer to convert each 2D 28x28 image into a contiguous array of 784 pixel values (
+# the minibatch dimension (at dim=0) is maintained).
+
+flatten = nn.Flatten()
+flat_image = flatten(input_image)
+print(flat_image.size())
+
+##############################################
+# nn.Linear
+# ^^^^^^^^^^^^^^^^^^^^^^
+# The `linear layer <https://pytorch.org/docs/stable/generated/torch.nn.Linear.html>`_
+# is a module that applies a linear transformation on the input using its stored weights and biases.
+#
+layer1 = nn.Linear(in_features=28*28, out_features=20)
+hidden1 = layer1(flat_image)
+print(hidden1.size())
+
+
+#################################################
+# nn.ReLU
+# ^^^^^^^^^^^^^^^^^^^^^^
+# Non-linear activations are what create the complex mappings between the model's inputs and outputs.
+# They are applied after linear transformations to introduce *nonlinearity*, helping neural networks
+# learn a wide variety of phenomena.
+#
+# In this model, we use `nn.ReLU <https://pytorch.org/docs/stable/generated/torch.nn.ReLU.html>`_ between our
+# linear layers, but there's other activations to introduce non-linearity in your model.
+
+print(f"Before ReLU: {hidden1}\n\n")
+hidden1 = nn.ReLU()(hidden1)
+print(f"After ReLU: {hidden1}")
+
+
+
+#################################################
+# nn.Sequential
+# ^^^^^^^^^^^^^^^^^^^^^^
+# `nn.Sequential <https://pytorch.org/docs/stable/generated/torch.nn.Sequential.html>`_ is an ordered
+# container of modules. The data is passed through all the modules in the same order as defined. You can use
+# sequential containers to put together a quick network like ``seq_modules``.
+
+seq_modules = nn.Sequential(
+    flatten,
+    layer1,
+    nn.ReLU(),
+    nn.Linear(20, 10)
+)
+input_image = torch.rand(3,28,28)
+logits = seq_modules(input_image)
+
+################################################################
+# nn.Softmax
+# ^^^^^^^^^^^^^^^^^^^^^^
+# The last linear layer of the neural network returns `logits` - raw values in [-\infty, \infty] - which are passed to the
+# `nn.Softmax <https://pytorch.org/docs/stable/generated/torch.nn.Softmax.html>`_ module. The logits are scaled to values
+# [0, 1] representing the model's predicted probabilities for each class. ``dim`` parameter indicates the dimension along
+# which the values must sum to 1.
+
+softmax = nn.Softmax(dim=1)
+pred_probab = softmax(logits)
+
+
+#################################################
+# Model Parameters
+# -------------------------
+# Many layers inside a neural network are *parameterized*, i.e. have associated weights
+# and biases that are optimized during training. Subclassing ``nn.Module`` automatically
+# tracks all fields defined inside your model object, and makes all parameters
+# accessible using your model's ``parameters()`` or ``named_parameters()`` methods.
+#
+# In this example, we iterate over each parameter, and print its size and a preview of its values.
+#
+
+
+print(f"Model structure: {model}\n\n")
+
+for name, param in model.named_parameters():
+    print(f"Layer: {name} | Size: {param.size()} | Values : {param[:2]} \n")
+
+######################################################################
+# --------------
+#
+
+#################################################################
+# Further Reading
+# -----------------
+# - `torch.nn API <https://pytorch.org/docs/stable/nn.html>`_
diff --git a/beginner_source/basics/data_tutorial.py b/beginner_source/basics/data_tutorial.py
new file mode 100644
index 00000000000..2c46b33122a
--- /dev/null
+++ b/beginner_source/basics/data_tutorial.py
@@ -0,0 +1,247 @@
+"""
+`Learn the Basics <intro.html>`_ ||
+`Quickstart <quickstart_tutorial.html>`_ ||
+`Tensors <tensorqs_tutorial.html>`_ ||
+**Datasets & DataLoaders** ||
+`Transforms <transforms_tutorial.html>`_ ||
+`Build Model <buildmodel_tutorial.html>`_ ||
+`Autograd <autogradqs_tutorial.html>`_ ||
+`Optimization <optimization_tutorial.html>`_ ||
+`Save & Load Model <saveloadrun_tutorial.html>`_
+
+Datasets & DataLoaders
+======================
+
+"""
+
+#################################################################
+# Code for processing data samples can get messy and hard to maintain; we ideally want our dataset code
+# to be decoupled from our model training code for better readability and modularity.
+# PyTorch provides two data primitives: ``torch.utils.data.DataLoader`` and ``torch.utils.data.Dataset``
+# that allow you to use pre-loaded datasets as well as your own data.
+# ``Dataset`` stores the samples and their corresponding labels, and ``DataLoader`` wraps an iterable around
+# the ``Dataset`` to enable easy access to the samples.
+#
+# PyTorch domain libraries provide a number of pre-loaded datasets (such as FashionMNIST) that
+# subclass ``torch.utils.data.Dataset`` and implement functions specific to the particular data.
+# They can be used to prototype and benchmark your model. You can find them
+# here: `Image Datasets <https://pytorch.org/vision/stable/datasets.html>`_,
+# `Text Datasets  <https://pytorch.org/text/stable/datasets.html>`_, and
+# `Audio Datasets <https://pytorch.org/audio/stable/datasets.html>`_
+#
+
+############################################################
+# Loading a Dataset
+# -------------------
+#
+# Here is an example of how to load the `Fashion-MNIST <https://research.zalando.com/project/fashion_mnist/fashion_mnist/>`_ dataset from TorchVision.
+# Fashion-MNIST is a dataset of Zalando’s article images consisting of 60,000 training examples and 10,000 test examples.
+# Each example comprises a 28×28 grayscale image and an associated label from one of 10 classes.
+#
+# We load the `FashionMNIST Dataset <https://pytorch.org/vision/stable/datasets.html#fashion-mnist>`_ with the following parameters:
+#  - ``root`` is the path where the train/test data is stored,
+#  - ``train`` specifies training or test dataset,
+#  - ``download=True`` downloads the data from the internet if it's not available at ``root``.
+#  - ``transform`` and ``target_transform`` specify the feature and label transformations
+
+
+import torch
+from torch.utils.data import Dataset
+from torchvision import datasets
+from torchvision.transforms import ToTensor
+import matplotlib.pyplot as plt
+
+
+training_data = datasets.FashionMNIST(
+    root="data",
+    train=True,
+    download=True,
+    transform=ToTensor()
+)
+
+test_data = datasets.FashionMNIST(
+    root="data",
+    train=False,
+    download=True,
+    transform=ToTensor()
+)
+
+
+#################################################################
+# Iterating and Visualizing the Dataset
+# -------------------------------------
+#
+# We can index ``Datasets`` manually like a list: ``training_data[index]``.
+# We use ``matplotlib`` to visualize some samples in our training data.
+
+labels_map = {
+    0: "T-Shirt",
+    1: "Trouser",
+    2: "Pullover",
+    3: "Dress",
+    4: "Coat",
+    5: "Sandal",
+    6: "Shirt",
+    7: "Sneaker",
+    8: "Bag",
+    9: "Ankle Boot",
+}
+figure = plt.figure(figsize=(8, 8))
+cols, rows = 3, 3
+for i in range(1, cols * rows + 1):
+    sample_idx = torch.randint(len(training_data), size=(1,)).item()
+    img, label = training_data[sample_idx]
+    figure.add_subplot(rows, cols, i)
+    plt.title(labels_map[label])
+    plt.axis("off")
+    plt.imshow(img.squeeze(), cmap="gray")
+plt.show()
+
+#################################################################
+# ..
+#  .. figure:: /_static/img/basics/fashion_mnist.png
+#    :alt: fashion_mnist
+
+
+######################################################################
+# --------------
+#
+
+#################################################################
+# Creating a Custom Dataset for your files
+# ---------------------------------------------------
+#
+# A custom Dataset class must implement three functions: `__init__`, `__len__`, and `__getitem__`.
+# Take a look at this implementation; the FashionMNIST images are stored
+# in a directory ``img_dir``, and their labels are stored separately in a CSV file ``annotations_file``.
+#
+# In the next sections, we'll break down what's happening in each of these functions.
+
+
+import os
+import pandas as pd
+from torchvision.io import decode_image
+
+class CustomImageDataset(Dataset):
+    def __init__(self, annotations_file, img_dir, transform=None, target_transform=None):
+        self.img_labels = pd.read_csv(annotations_file)
+        self.img_dir = img_dir
+        self.transform = transform
+        self.target_transform = target_transform
+
+    def __len__(self):
+        return len(self.img_labels)
+
+    def __getitem__(self, idx):
+        img_path = os.path.join(self.img_dir, self.img_labels.iloc[idx, 0])
+        image = decode_image(img_path)
+        label = self.img_labels.iloc[idx, 1]
+        if self.transform:
+            image = self.transform(image)
+        if self.target_transform:
+            label = self.target_transform(label)
+        return image, label
+
+
+#################################################################
+# ``__init__``
+# ^^^^^^^^^^^^^^^^^^^^
+#
+# The __init__ function is run once when instantiating the Dataset object. We initialize
+# the directory containing the images, the annotations file, and both transforms (covered
+# in more detail in the next section).
+#
+# The labels.csv file looks like: ::
+#
+#     tshirt1.jpg, 0
+#     tshirt2.jpg, 0
+#     ......
+#     ankleboot999.jpg, 9
+
+
+def __init__(self, annotations_file, img_dir, transform=None, target_transform=None):
+    self.img_labels = pd.read_csv(annotations_file)
+    self.img_dir = img_dir
+    self.transform = transform
+    self.target_transform = target_transform
+
+
+#################################################################
+# ``__len__``
+# ^^^^^^^^^^^^^^^^^^^^
+#
+# The __len__ function returns the number of samples in our dataset.
+#
+# Example:
+
+
+def __len__(self):
+    return len(self.img_labels)
+
+
+#################################################################
+# ``__getitem__``
+# ^^^^^^^^^^^^^^^^^^^^
+#
+# The __getitem__ function loads and returns a sample from the dataset at the given index ``idx``.
+# Based on the index, it identifies the image's location on disk, converts that to a tensor using ``decode_image``, retrieves the
+# corresponding label from the csv data in ``self.img_labels``, calls the transform functions on them (if applicable), and returns the
+# tensor image and corresponding label in a tuple.
+
+def __getitem__(self, idx):
+    img_path = os.path.join(self.img_dir, self.img_labels.iloc[idx, 0])
+    image = decode_image(img_path)
+    label = self.img_labels.iloc[idx, 1]
+    if self.transform:
+        image = self.transform(image)
+    if self.target_transform:
+        label = self.target_transform(label)
+    return image, label
+
+
+######################################################################
+# --------------
+#
+
+
+#################################################################
+# Preparing your data for training with DataLoaders
+# -------------------------------------------------
+# The ``Dataset`` retrieves our dataset's features and labels one sample at a time. While training a model, we typically want to
+# pass samples in "minibatches", reshuffle the data at every epoch to reduce model overfitting, and use Python's ``multiprocessing`` to
+# speed up data retrieval.
+#
+# ``DataLoader`` is an iterable that abstracts this complexity for us in an easy API.
+
+from torch.utils.data import DataLoader
+
+train_dataloader = DataLoader(training_data, batch_size=64, shuffle=True)
+test_dataloader = DataLoader(test_data, batch_size=64, shuffle=True)
+
+###########################
+# Iterate through the DataLoader
+# -------------------------------
+#
+# We have loaded that dataset into the ``DataLoader`` and can iterate through the dataset as needed.
+# Each iteration below returns a batch of ``train_features`` and ``train_labels`` (containing ``batch_size=64`` features and labels respectively).
+# Because we specified ``shuffle=True``, after we iterate over all batches the data is shuffled (for finer-grained control over
+# the data loading order, take a look at `Samplers <https://pytorch.org/docs/stable/data.html#data-loading-order-and-sampler>`_).
+
+# Display image and label.
+train_features, train_labels = next(iter(train_dataloader))
+print(f"Feature batch shape: {train_features.size()}")
+print(f"Labels batch shape: {train_labels.size()}")
+img = train_features[0].squeeze()
+label = train_labels[0]
+plt.imshow(img, cmap="gray")
+plt.show()
+print(f"Label: {label}")
+
+######################################################################
+# --------------
+#
+
+#################################################################
+# Further Reading
+# ----------------
+# - `torch.utils.data API <https://pytorch.org/docs/stable/data.html>`_
diff --git a/beginner_source/basics/intro.py b/beginner_source/basics/intro.py
new file mode 100644
index 00000000000..30ff5e17ff6
--- /dev/null
+++ b/beginner_source/basics/intro.py
@@ -0,0 +1,64 @@
+"""
+**Learn the Basics** ||
+`Quickstart <quickstart_tutorial.html>`_ ||
+`Tensors <tensorqs_tutorial.html>`_ ||
+`Datasets & DataLoaders <data_tutorial.html>`_ ||
+`Transforms <transforms_tutorial.html>`_ ||
+`Build Model <buildmodel_tutorial.html>`_ ||
+`Autograd <autogradqs_tutorial.html>`_ ||
+`Optimization <optimization_tutorial.html>`_ ||
+`Save & Load Model <saveloadrun_tutorial.html>`_
+
+Learn the Basics
+===================
+
+Authors:
+`Suraj Subramanian <https://github.com/subramen>`_,
+`Seth Juarez <https://github.com/sethjuarez/>`_,
+`Cassie Breviu <https://github.com/cassiebreviu/>`_,
+`Dmitry Soshnikov <https://soshnikov.com/>`_,
+`Ari Bornstein <https://github.com/aribornstein/>`_
+
+Most machine learning workflows involve working with data, creating models, optimizing model
+parameters, and saving the trained models. This tutorial introduces you to a complete ML workflow
+implemented in PyTorch, with links to learn more about each of these concepts.
+
+We'll use the FashionMNIST dataset to train a neural network that predicts if an input image belongs
+to one of the following classes: T-shirt/top, Trouser, Pullover, Dress, Coat, Sandal, Shirt, Sneaker,
+Bag, or Ankle boot.
+
+`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:
+
+- **In the cloud**: This is the easiest way to get started! Each section has a "Run in Microsoft Learn" and "Run in Google Colab" link at the top, which opens an integrated notebook in Microsoft Learn or Google Colab, respectively, with the code in a fully-hosted environment.
+- **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.
+
+
+How to Use this Guide
+---------------------
+If you're familiar with other deep learning frameworks, check out the `0. Quickstart <quickstart_tutorial.html>`_ first
+to quickly familiarize yourself with PyTorch's API.
+
+If you're new to deep learning frameworks, head right into the first section of our step-by-step guide: `1. Tensors <tensorqs_tutorial.html>`_.
+
+
+.. 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/basics/optimization_tutorial.py b/beginner_source/basics/optimization_tutorial.py
new file mode 100644
index 00000000000..82bfaa8f07c
--- /dev/null
+++ b/beginner_source/basics/optimization_tutorial.py
@@ -0,0 +1,213 @@
+"""
+`Learn the Basics <intro.html>`_ ||
+`Quickstart <quickstart_tutorial.html>`_ ||
+`Tensors <tensorqs_tutorial.html>`_ ||
+`Datasets & DataLoaders <data_tutorial.html>`_ ||
+`Transforms <transforms_tutorial.html>`_ ||
+`Build Model <buildmodel_tutorial.html>`_ ||
+`Autograd <autogradqs_tutorial.html>`_ ||
+**Optimization** ||
+`Save & Load Model <saveloadrun_tutorial.html>`_
+
+Optimizing Model Parameters
+===========================
+
+Now that we have a model and data it's time to train, validate and test our model by optimizing its parameters on
+our data. Training a model is an iterative process; in each iteration the model makes a guess about the output, calculates
+the error in its guess (*loss*), collects the derivatives of the error with respect to its parameters (as we saw in
+the `previous section  <autograd_tutorial.html>`_), and **optimizes** these parameters using gradient descent. For a more
+detailed walkthrough of this process, check out this video on `backpropagation from 3Blue1Brown <https://www.youtube.com/watch?v=tIeHLnjs5U8>`__.
+
+Prerequisite Code
+-----------------
+We load the code from the previous sections on `Datasets & DataLoaders <data_tutorial.html>`_
+and `Build Model  <buildmodel_tutorial.html>`_.
+"""
+
+import torch
+from torch import nn
+from torch.utils.data import DataLoader
+from torchvision import datasets
+from torchvision.transforms import ToTensor
+
+training_data = datasets.FashionMNIST(
+    root="data",
+    train=True,
+    download=True,
+    transform=ToTensor()
+)
+
+test_data = datasets.FashionMNIST(
+    root="data",
+    train=False,
+    download=True,
+    transform=ToTensor()
+)
+
+train_dataloader = DataLoader(training_data, batch_size=64)
+test_dataloader = DataLoader(test_data, batch_size=64)
+
+class NeuralNetwork(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.flatten = nn.Flatten()
+        self.linear_relu_stack = nn.Sequential(
+            nn.Linear(28*28, 512),
+            nn.ReLU(),
+            nn.Linear(512, 512),
+            nn.ReLU(),
+            nn.Linear(512, 10),
+        )
+
+    def forward(self, x):
+        x = self.flatten(x)
+        logits = self.linear_relu_stack(x)
+        return logits
+
+model = NeuralNetwork()
+
+
+##############################################
+# Hyperparameters
+# -----------------
+#
+# Hyperparameters are adjustable parameters that let you control the model optimization process.
+# Different hyperparameter values can impact model training and convergence rates
+# (`read more <https://pytorch.org/tutorials/beginner/hyperparameter_tuning_tutorial.html>`__ about hyperparameter tuning)
+#
+# We define the following hyperparameters for training:
+#  - **Number of Epochs** - the number of times to iterate over the dataset
+#  - **Batch Size** - the number of data samples propagated through the network before the parameters are updated
+#  - **Learning Rate** - how much to update models parameters at each batch/epoch. Smaller values yield slow learning speed, while large values may result in unpredictable behavior during training.
+#
+
+learning_rate = 1e-3
+batch_size = 64
+epochs = 5
+
+
+
+#####################################
+# Optimization Loop
+# -----------------
+#
+# Once we set our hyperparameters, we can then train and optimize our model with an optimization loop. Each
+# iteration of the optimization loop is called an **epoch**.
+#
+# Each epoch consists of two main parts:
+#  - **The Train Loop** - iterate over the training dataset and try to converge to optimal parameters.
+#  - **The Validation/Test Loop** - iterate over the test dataset to check if model performance is improving.
+#
+# Let's briefly familiarize ourselves with some of the concepts used in the training loop. Jump ahead to
+# see the :ref:`full-impl-label` of the optimization loop.
+#
+# Loss Function
+# ~~~~~~~~~~~~~~~~~
+#
+# When presented with some training data, our untrained network is likely not to give the correct
+# answer. **Loss function** measures the degree of dissimilarity of obtained result to the target value,
+# and it is the loss function that we want to minimize during training. To calculate the loss we make a
+# prediction using the inputs of our given data sample and compare it against the true data label value.
+#
+# Common loss functions include `nn.MSELoss <https://pytorch.org/docs/stable/generated/torch.nn.MSELoss.html#torch.nn.MSELoss>`_ (Mean Square Error) for regression tasks, and
+# `nn.NLLLoss <https://pytorch.org/docs/stable/generated/torch.nn.NLLLoss.html#torch.nn.NLLLoss>`_ (Negative Log Likelihood) for classification.
+# `nn.CrossEntropyLoss <https://pytorch.org/docs/stable/generated/torch.nn.CrossEntropyLoss.html#torch.nn.CrossEntropyLoss>`_ combines ``nn.LogSoftmax`` and ``nn.NLLLoss``.
+#
+# We pass our model's output logits to ``nn.CrossEntropyLoss``, which will normalize the logits and compute the prediction error.
+
+# Initialize the loss function
+loss_fn = nn.CrossEntropyLoss()
+
+
+
+#####################################
+# Optimizer
+# ~~~~~~~~~~~~~~~~~
+#
+# Optimization is the process of adjusting model parameters to reduce model error in each training step. **Optimization algorithms** define how this process is performed (in this example we use Stochastic Gradient Descent).
+# All optimization logic is encapsulated in  the ``optimizer`` object. Here, we use the SGD optimizer; additionally, there are many `different optimizers <https://pytorch.org/docs/stable/optim.html>`_
+# available in PyTorch such as ADAM and RMSProp, that work better for different kinds of models and data.
+#
+# We initialize the optimizer by registering the model's parameters that need to be trained, and passing in the learning rate hyperparameter.
+
+optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)
+
+#####################################
+# Inside the training loop, optimization happens in three steps:
+#  * Call ``optimizer.zero_grad()`` to reset the gradients of model parameters. Gradients by default add up; to prevent double-counting, we explicitly zero them at each iteration.
+#  * Backpropagate the prediction loss with a call to ``loss.backward()``. PyTorch deposits the gradients of the loss w.r.t. each parameter.
+#  * Once we have our gradients, we call ``optimizer.step()`` to adjust the parameters by the gradients collected in the backward pass.
+
+
+########################################
+# .. _full-impl-label:
+#
+# Full Implementation
+# -----------------------
+# We define ``train_loop`` that loops over our optimization code, and ``test_loop`` that
+# evaluates the model's performance against our test data.
+
+def train_loop(dataloader, model, loss_fn, optimizer):
+    size = len(dataloader.dataset)
+    # Set the model to training mode - important for batch normalization and dropout layers
+    # Unnecessary in this situation but added for best practices
+    model.train()
+    for batch, (X, y) in enumerate(dataloader):
+        # Compute prediction and loss
+        pred = model(X)
+        loss = loss_fn(pred, y)
+
+        # Backpropagation
+        loss.backward()
+        optimizer.step()
+        optimizer.zero_grad()
+
+        if batch % 100 == 0:
+            loss, current = loss.item(), batch * batch_size + len(X)
+            print(f"loss: {loss:>7f}  [{current:>5d}/{size:>5d}]")
+
+
+def test_loop(dataloader, model, loss_fn):
+    # Set the model to evaluation mode - important for batch normalization and dropout layers
+    # Unnecessary in this situation but added for best practices
+    model.eval()
+    size = len(dataloader.dataset)
+    num_batches = len(dataloader)
+    test_loss, correct = 0, 0
+
+    # Evaluating the model with torch.no_grad() ensures that no gradients are computed during test mode
+    # also serves to reduce unnecessary gradient computations and memory usage for tensors with requires_grad=True
+    with torch.no_grad():
+        for X, y in dataloader:
+            pred = model(X)
+            test_loss += loss_fn(pred, y).item()
+            correct += (pred.argmax(1) == y).type(torch.float).sum().item()
+
+    test_loss /= num_batches
+    correct /= size
+    print(f"Test Error: \n Accuracy: {(100*correct):>0.1f}%, Avg loss: {test_loss:>8f} \n")
+
+
+########################################
+# We initialize the loss function and optimizer, and pass it to ``train_loop`` and ``test_loop``.
+# Feel free to increase the number of epochs to track the model's improving performance.
+
+loss_fn = nn.CrossEntropyLoss()
+optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)
+
+epochs = 10
+for t in range(epochs):
+    print(f"Epoch {t+1}\n-------------------------------")
+    train_loop(train_dataloader, model, loss_fn, optimizer)
+    test_loop(test_dataloader, model, loss_fn)
+print("Done!")
+
+
+
+#################################################################
+# Further Reading
+# -----------------------
+# - `Loss Functions <https://pytorch.org/docs/stable/nn.html#loss-functions>`_
+# - `torch.optim <https://pytorch.org/docs/stable/optim.html>`_
+# - `Warmstart Training a Model <https://pytorch.org/tutorials/recipes/recipes/warmstarting_model_using_parameters_from_a_different_model.html>`_
+#
diff --git a/beginner_source/basics/qs_toc.txt b/beginner_source/basics/qs_toc.txt
new file mode 100644
index 00000000000..7a63e1c7e9d
--- /dev/null
+++ b/beginner_source/basics/qs_toc.txt
@@ -0,0 +1,8 @@
+| 0. `Quickstart <quickstart_tutorial.html>`_
+| 1. `Tensors <tensorqs_tutorial.html>`_
+| 2. `Datasets and DataLoaders <data_tutorial.html>`_
+| 3. `Transforms <transforms_tutorial.html>`_
+| 4. `Build Model <buildmodel_tutorial.html>`_
+| 5. `Automatic Differentiation <autogradqs_tutorial.html>`_
+| 6. `Optimization Loop <optimization_tutorial.html>`_
+| 7. `Save, Load and Use Model <saveloadrun_tutorial.html>`_
diff --git a/beginner_source/basics/quickstart_tutorial.py b/beginner_source/basics/quickstart_tutorial.py
new file mode 100644
index 00000000000..5cce8dcfe9a
--- /dev/null
+++ b/beginner_source/basics/quickstart_tutorial.py
@@ -0,0 +1,242 @@
+"""
+`Learn the Basics <intro.html>`_ ||
+**Quickstart** ||
+`Tensors <tensorqs_tutorial.html>`_ ||
+`Datasets & DataLoaders <data_tutorial.html>`_ ||
+`Transforms <transforms_tutorial.html>`_ ||
+`Build Model <buildmodel_tutorial.html>`_ ||
+`Autograd <autogradqs_tutorial.html>`_ ||
+`Optimization <optimization_tutorial.html>`_ ||
+`Save & Load Model <saveloadrun_tutorial.html>`_
+
+Quickstart
+===================
+This section runs through the API for common tasks in machine learning. Refer to the links in each section to dive deeper.
+
+Working with data
+-----------------
+PyTorch has two `primitives to work with data <https://pytorch.org/docs/stable/data.html>`_:
+``torch.utils.data.DataLoader`` and ``torch.utils.data.Dataset``.
+``Dataset`` stores the samples and their corresponding labels, and ``DataLoader`` wraps an iterable around
+the ``Dataset``.
+
+"""
+
+import torch
+from torch import nn
+from torch.utils.data import DataLoader
+from torchvision import datasets
+from torchvision.transforms import ToTensor
+
+######################################################################
+# PyTorch offers domain-specific libraries such as `TorchText <https://pytorch.org/text/stable/index.html>`_,
+# `TorchVision <https://pytorch.org/vision/stable/index.html>`_, and `TorchAudio <https://pytorch.org/audio/stable/index.html>`_,
+# all of which include datasets. For this tutorial, we  will be using a TorchVision dataset.
+#
+# The ``torchvision.datasets`` module contains ``Dataset`` objects for many real-world vision data like
+# CIFAR, COCO (`full list here <https://pytorch.org/vision/stable/datasets.html>`_). In this tutorial, we
+# use the FashionMNIST dataset. Every TorchVision ``Dataset`` includes two arguments: ``transform`` and
+# ``target_transform`` to modify the samples and labels respectively.
+
+# Download training data from open datasets.
+training_data = datasets.FashionMNIST(
+    root="data",
+    train=True,
+    download=True,
+    transform=ToTensor(),
+)
+
+# Download test data from open datasets.
+test_data = datasets.FashionMNIST(
+    root="data",
+    train=False,
+    download=True,
+    transform=ToTensor(),
+)
+
+######################################################################
+# We pass the ``Dataset`` as an argument to ``DataLoader``. This wraps an iterable over our dataset, and supports
+# automatic batching, sampling, shuffling and multiprocess data loading. Here we define a batch size of 64, i.e. each element
+# in the dataloader iterable will return a batch of 64 features and labels.
+
+batch_size = 64
+
+# Create data loaders.
+train_dataloader = DataLoader(training_data, batch_size=batch_size)
+test_dataloader = DataLoader(test_data, batch_size=batch_size)
+
+for X, y in test_dataloader:
+    print(f"Shape of X [N, C, H, W]: {X.shape}")
+    print(f"Shape of y: {y.shape} {y.dtype}")
+    break
+
+######################################################################
+# Read more about `loading data in PyTorch <data_tutorial.html>`_.
+#
+
+######################################################################
+# --------------
+#
+
+################################
+# Creating Models
+# ------------------
+# To define a neural network in PyTorch, we create a class that inherits
+# from `nn.Module <https://pytorch.org/docs/stable/generated/torch.nn.Module.html>`_. We define the layers of the network
+# in the ``__init__`` function and specify how data will pass through the network in the ``forward`` function. To accelerate
+# operations in the neural network, we move it to the `accelerator <https://pytorch.org/docs/stable/torch.html#accelerators>`__
+# such as CUDA, MPS, MTIA, or XPU. If the current accelerator is available, we will use it. Otherwise, we use the CPU.
+
+device = torch.accelerator.current_accelerator().type if torch.accelerator.is_available() else "cpu"
+print(f"Using {device} device")
+
+# Define model
+class NeuralNetwork(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.flatten = nn.Flatten()
+        self.linear_relu_stack = nn.Sequential(
+            nn.Linear(28*28, 512),
+            nn.ReLU(),
+            nn.Linear(512, 512),
+            nn.ReLU(),
+            nn.Linear(512, 10)
+        )
+
+    def forward(self, x):
+        x = self.flatten(x)
+        logits = self.linear_relu_stack(x)
+        return logits
+
+model = NeuralNetwork().to(device)
+print(model)
+
+######################################################################
+# Read more about `building neural networks in PyTorch <buildmodel_tutorial.html>`_.
+#
+
+
+######################################################################
+# --------------
+#
+
+
+#####################################################################
+# Optimizing the Model Parameters
+# ----------------------------------------
+# To train a model, we need a `loss function <https://pytorch.org/docs/stable/nn.html#loss-functions>`_
+# and an `optimizer <https://pytorch.org/docs/stable/optim.html>`_.
+
+loss_fn = nn.CrossEntropyLoss()
+optimizer = torch.optim.SGD(model.parameters(), lr=1e-3)
+
+
+#######################################################################
+# In a single training loop, the model makes predictions on the training dataset (fed to it in batches), and
+# backpropagates the prediction error to adjust the model's parameters.
+
+def train(dataloader, model, loss_fn, optimizer):
+    size = len(dataloader.dataset)
+    model.train()
+    for batch, (X, y) in enumerate(dataloader):
+        X, y = X.to(device), y.to(device)
+
+        # Compute prediction error
+        pred = model(X)
+        loss = loss_fn(pred, y)
+
+        # Backpropagation
+        loss.backward()
+        optimizer.step()
+        optimizer.zero_grad()
+
+        if batch % 100 == 0:
+            loss, current = loss.item(), (batch + 1) * len(X)
+            print(f"loss: {loss:>7f}  [{current:>5d}/{size:>5d}]")
+
+##############################################################################
+# We also check the model's performance against the test dataset to ensure it is learning.
+
+def test(dataloader, model, loss_fn):
+    size = len(dataloader.dataset)
+    num_batches = len(dataloader)
+    model.eval()
+    test_loss, correct = 0, 0
+    with torch.no_grad():
+        for X, y in dataloader:
+            X, y = X.to(device), y.to(device)
+            pred = model(X)
+            test_loss += loss_fn(pred, y).item()
+            correct += (pred.argmax(1) == y).type(torch.float).sum().item()
+    test_loss /= num_batches
+    correct /= size
+    print(f"Test Error: \n Accuracy: {(100*correct):>0.1f}%, Avg loss: {test_loss:>8f} \n")
+
+##############################################################################
+# The training process is conducted over several iterations (*epochs*). During each epoch, the model learns
+# parameters to make better predictions. We print the model's accuracy and loss at each epoch; we'd like to see the
+# accuracy increase and the loss decrease with every epoch.
+
+epochs = 5
+for t in range(epochs):
+    print(f"Epoch {t+1}\n-------------------------------")
+    train(train_dataloader, model, loss_fn, optimizer)
+    test(test_dataloader, model, loss_fn)
+print("Done!")
+
+######################################################################
+# Read more about `Training your model <optimization_tutorial.html>`_.
+#
+
+######################################################################
+# --------------
+#
+
+######################################################################
+# Saving Models
+# -------------
+# A common way to save a model is to serialize the internal state dictionary (containing the model parameters).
+
+torch.save(model.state_dict(), "model.pth")
+print("Saved PyTorch Model State to model.pth")
+
+
+
+######################################################################
+# Loading Models
+# ----------------------------
+#
+# The process for loading a model includes re-creating the model structure and loading
+# the state dictionary into it.
+
+model = NeuralNetwork().to(device)
+model.load_state_dict(torch.load("model.pth", weights_only=True))
+
+#############################################################
+# This model can now be used to make predictions.
+
+classes = [
+    "T-shirt/top",
+    "Trouser",
+    "Pullover",
+    "Dress",
+    "Coat",
+    "Sandal",
+    "Shirt",
+    "Sneaker",
+    "Bag",
+    "Ankle boot",
+]
+
+model.eval()
+x, y = test_data[0][0], test_data[0][1]
+with torch.no_grad():
+    x = x.to(device)
+    pred = model(x)
+    predicted, actual = classes[pred[0].argmax(0)], classes[y]
+    print(f'Predicted: "{predicted}", Actual: "{actual}"')
+
+
+######################################################################
+# Read more about `Saving & Loading your model <saveloadrun_tutorial.html>`_.
+#
diff --git a/beginner_source/basics/saveloadrun_tutorial.py b/beginner_source/basics/saveloadrun_tutorial.py
new file mode 100644
index 00000000000..e80d32a6eaa
--- /dev/null
+++ b/beginner_source/basics/saveloadrun_tutorial.py
@@ -0,0 +1,74 @@
+"""
+`Learn the Basics <intro.html>`_ ||
+`Quickstart <quickstart_tutorial.html>`_ ||
+`Tensors <tensorqs_tutorial.html>`_ ||
+`Datasets & DataLoaders <data_tutorial.html>`_ ||
+`Transforms <transforms_tutorial.html>`_ ||
+`Build Model <buildmodel_tutorial.html>`_ ||
+`Autograd <autogradqs_tutorial.html>`_ ||
+`Optimization <optimization_tutorial.html>`_ ||
+**Save & Load Model**
+
+Save and Load the Model
+============================
+
+In this section we will look at how to persist model state with saving, loading and running model predictions.
+"""
+
+import torch
+import torchvision.models as models
+
+
+#######################################################################
+# Saving and Loading Model Weights
+# --------------------------------
+# PyTorch models store the learned parameters in an internal
+# state dictionary, called ``state_dict``. These can be persisted via the ``torch.save``
+# method:
+
+model = models.vgg16(weights='IMAGENET1K_V1')
+torch.save(model.state_dict(), 'model_weights.pth')
+
+##########################
+# To load model weights, you need to create an instance of the same model first, and then load the parameters
+# using ``load_state_dict()`` method.
+#
+# In the code below, we set ``weights_only=True`` to limit the
+# functions executed during unpickling to only those necessary for
+# loading weights. Using ``weights_only=True`` is considered
+# a best practice when loading weights.
+
+model = models.vgg16() # we do not specify ``weights``, i.e. create untrained model
+model.load_state_dict(torch.load('model_weights.pth', weights_only=True))
+model.eval()
+
+###########################
+# .. note:: be sure to call ``model.eval()`` method before inferencing to set the dropout and batch normalization layers to evaluation mode. Failing to do this will yield inconsistent inference results.
+
+#######################################################################
+# Saving and Loading Models with Shapes
+# -------------------------------------
+# When loading model weights, we needed to instantiate the model class first, because the class
+# defines the structure of a network. We might want to save the structure of this class together with
+# the model, in which case we can pass ``model`` (and not ``model.state_dict()``) to the saving function:
+
+torch.save(model, 'model.pth')
+
+########################
+# We can then load the model as demonstrated below.
+#
+# As described in `Saving and loading torch.nn.Modules <https://pytorch.org/docs/main/notes/serialization.html#saving-and-loading-torch-nn-modules>`_,
+# saving ``state_dict`` is considered the best practice. However,
+# below we use ``weights_only=False`` because this involves loading the
+# model, which is a legacy use case for ``torch.save``.
+
+model = torch.load('model.pth', weights_only=False)
+
+########################
+# .. note:: This approach uses Python `pickle <https://docs.python.org/3/library/pickle.html>`_ module when serializing the model, thus it relies on the actual class definition to be available when loading the model.
+
+#######################
+# Related Tutorials
+# -----------------
+# - `Saving and Loading a General Checkpoint in PyTorch <https://pytorch.org/tutorials/recipes/recipes/saving_and_loading_a_general_checkpoint.html>`_
+# - `Tips for loading an nn.Module from a checkpoint <https://pytorch.org/tutorials/recipes/recipes/module_load_state_dict_tips.html?highlight=loading%20nn%20module%20from%20checkpoint>`_
diff --git a/beginner_source/basics/tensorqs_tutorial.py b/beginner_source/basics/tensorqs_tutorial.py
new file mode 100644
index 00000000000..30e05cb10d0
--- /dev/null
+++ b/beginner_source/basics/tensorqs_tutorial.py
@@ -0,0 +1,227 @@
+"""
+`Learn the Basics <intro.html>`_ ||
+`Quickstart <quickstart_tutorial.html>`_ ||
+**Tensors** ||
+`Datasets & DataLoaders <data_tutorial.html>`_ ||
+`Transforms <transforms_tutorial.html>`_ ||
+`Build Model <buildmodel_tutorial.html>`_ ||
+`Autograd <autogradqs_tutorial.html>`_ ||
+`Optimization <optimization_tutorial.html>`_ ||
+`Save & Load Model <saveloadrun_tutorial.html>`_
+
+Tensors
+==========================
+
+Tensors are a specialized data structure that are very similar to arrays and matrices.
+In PyTorch, we use tensors to encode the inputs and outputs of a model, as well as the model’s parameters.
+
+Tensors are similar to `NumPy’s <https://numpy.org/>`_ ndarrays, except that tensors can run on GPUs or other hardware accelerators. In fact, tensors and
+NumPy arrays can often share the same underlying memory, eliminating the need to copy data (see :ref:`bridge-to-np-label`). Tensors
+are also optimized for automatic differentiation (we'll see more about that later in the `Autograd <autogradqs_tutorial.html>`__
+section). If you’re familiar with ndarrays, you’ll be right at home with the Tensor API. If not, follow along!
+"""
+
+import torch
+import numpy as np
+
+
+######################################################################
+# Initializing a Tensor
+# ~~~~~~~~~~~~~~~~~~~~~
+#
+# Tensors can be initialized in various ways. Take a look at the following examples:
+#
+# **Directly from data**
+#
+# Tensors can be created directly from data. The data type is automatically inferred.
+
+data = [[1, 2],[3, 4]]
+x_data = torch.tensor(data)
+
+######################################################################
+# **From a NumPy array**
+#
+# Tensors can be created from NumPy arrays (and vice versa - see :ref:`bridge-to-np-label`).
+np_array = np.array(data)
+x_np = torch.from_numpy(np_array)
+
+
+###############################################################
+# **From another tensor:**
+#
+# The new tensor retains the properties (shape, datatype) of the argument tensor, unless explicitly overridden.
+
+x_ones = torch.ones_like(x_data) # retains the properties of x_data
+print(f"Ones Tensor: \n {x_ones} \n")
+
+x_rand = torch.rand_like(x_data, dtype=torch.float) # overrides the datatype of x_data
+print(f"Random Tensor: \n {x_rand} \n")
+
+
+######################################################################
+# **With random or constant values:**
+#
+# ``shape`` is a tuple of tensor dimensions. In the functions below, it determines the dimensionality of the output tensor.
+
+shape = (2,3,)
+rand_tensor = torch.rand(shape)
+ones_tensor = torch.ones(shape)
+zeros_tensor = torch.zeros(shape)
+
+print(f"Random Tensor: \n {rand_tensor} \n")
+print(f"Ones Tensor: \n {ones_tensor} \n")
+print(f"Zeros Tensor: \n {zeros_tensor}")
+
+
+
+######################################################################
+# --------------
+#
+
+######################################################################
+# Attributes of a Tensor
+# ~~~~~~~~~~~~~~~~~~~~~~
+#
+# Tensor attributes describe their shape, datatype, and the device on which they are stored.
+
+tensor = torch.rand(3,4)
+
+print(f"Shape of tensor: {tensor.shape}")
+print(f"Datatype of tensor: {tensor.dtype}")
+print(f"Device tensor is stored on: {tensor.device}")
+
+
+######################################################################
+# --------------
+#
+
+######################################################################
+# Operations on Tensors
+# ~~~~~~~~~~~~~~~~~~~~~~~
+#
+# Over 1200 tensor operations, including arithmetic, linear algebra, matrix manipulation (transposing,
+# indexing, slicing), sampling and more are
+# comprehensively described `here <https://pytorch.org/docs/stable/torch.html>`__.
+#
+# Each of these operations can be run on the CPU and `Accelerator <https://pytorch.org/docs/stable/torch.html#accelerators>`__
+# such as CUDA, MPS, MTIA, or XPU. If you’re using Colab, allocate an accelerator by going to Runtime > Change runtime type > GPU.
+#
+# By default, tensors are created on the CPU. We need to explicitly move tensors to the accelerator using
+# ``.to`` method (after checking for accelerator availability). Keep in mind that copying large tensors
+# across devices can be expensive in terms of time and memory!
+
+# We move our tensor to the current accelerator if available
+if torch.accelerator.is_available():
+    tensor = tensor.to(torch.accelerator.current_accelerator())
+
+
+######################################################################
+# Try out some of the operations from the list.
+# If you're familiar with the NumPy API, you'll find the Tensor API a breeze to use.
+#
+
+###############################################################
+# **Standard numpy-like indexing and slicing:**
+
+tensor = torch.ones(4, 4)
+print(f"First row: {tensor[0]}")
+print(f"First column: {tensor[:, 0]}")
+print(f"Last column: {tensor[..., -1]}")
+tensor[:,1] = 0
+print(tensor)
+
+######################################################################
+# **Joining tensors** You can use ``torch.cat`` to concatenate a sequence of tensors along a given dimension.
+# See also `torch.stack <https://pytorch.org/docs/stable/generated/torch.stack.html>`__,
+# another tensor joining operator that is subtly different from ``torch.cat``.
+t1 = torch.cat([tensor, tensor, tensor], dim=1)
+print(t1)
+
+
+######################################################################
+# **Arithmetic operations**
+
+# This computes the matrix multiplication between two tensors. y1, y2, y3 will have the same value
+# ``tensor.T`` returns the transpose of a tensor
+y1 = tensor @ tensor.T
+y2 = tensor.matmul(tensor.T)
+
+y3 = torch.rand_like(y1)
+torch.matmul(tensor, tensor.T, out=y3)
+
+
+# This computes the element-wise product. z1, z2, z3 will have the same value
+z1 = tensor * tensor
+z2 = tensor.mul(tensor)
+
+z3 = torch.rand_like(tensor)
+torch.mul(tensor, tensor, out=z3)
+
+
+######################################################################
+# **Single-element tensors** If you have a one-element tensor, for example by aggregating all
+# values of a tensor into one value, you can convert it to a Python
+# numerical value using ``item()``:
+
+agg = tensor.sum()
+agg_item = agg.item()
+print(agg_item, type(agg_item))
+
+
+######################################################################
+# **In-place operations**
+# Operations that store the result into the operand are called in-place. They are denoted by a ``_`` suffix.
+# For example: ``x.copy_(y)``, ``x.t_()``, will change ``x``.
+
+print(f"{tensor} \n")
+tensor.add_(5)
+print(tensor)
+
+######################################################################
+# .. note::
+#      In-place operations save some memory, but can be problematic when computing derivatives because of an immediate loss
+#      of history. Hence, their use is discouraged.
+
+
+
+######################################################################
+# --------------
+#
+
+
+######################################################################
+# .. _bridge-to-np-label:
+#
+# Bridge with NumPy
+# ~~~~~~~~~~~~~~~~~
+# Tensors on the CPU and NumPy arrays can share their underlying memory
+# locations, and changing one will change	the other.
+
+
+######################################################################
+# Tensor to NumPy array
+# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+t = torch.ones(5)
+print(f"t: {t}")
+n = t.numpy()
+print(f"n: {n}")
+
+######################################################################
+# A change in the tensor reflects in the NumPy array.
+
+t.add_(1)
+print(f"t: {t}")
+print(f"n: {n}")
+
+
+######################################################################
+# NumPy array to Tensor
+# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+n = np.ones(5)
+t = torch.from_numpy(n)
+
+######################################################################
+# Changes in the NumPy array reflects in the tensor.
+np.add(n, 1, out=n)
+print(f"t: {t}")
+print(f"n: {n}")
diff --git a/beginner_source/basics/transforms_tutorial.py b/beginner_source/basics/transforms_tutorial.py
new file mode 100644
index 00000000000..33076958bf5
--- /dev/null
+++ b/beginner_source/basics/transforms_tutorial.py
@@ -0,0 +1,70 @@
+"""
+`Learn the Basics <intro.html>`_ ||
+`Quickstart <quickstart_tutorial.html>`_ ||
+`Tensors <tensorqs_tutorial.html>`_ ||
+`Datasets & DataLoaders <data_tutorial.html>`_ ||
+**Transforms** ||
+`Build Model <buildmodel_tutorial.html>`_ ||
+`Autograd <autogradqs_tutorial.html>`_ ||
+`Optimization <optimization_tutorial.html>`_ ||
+`Save & Load Model <saveloadrun_tutorial.html>`_
+
+Transforms
+===================
+
+Data does not always come in its final processed form that is required for
+training machine learning algorithms. We use **transforms** to perform some
+manipulation of the data and make it suitable for training.
+
+All TorchVision datasets have two parameters -``transform`` to modify the features and
+``target_transform`` to modify the labels - that accept callables containing the transformation logic.
+The `torchvision.transforms <https://pytorch.org/vision/stable/transforms.html>`_ module offers
+several commonly-used transforms out of the box.
+
+The FashionMNIST features are in PIL Image format, and the labels are integers.
+For training, we need the features as normalized tensors, and the labels as one-hot encoded tensors.
+To make these transformations, we use ``ToTensor`` and ``Lambda``.
+"""
+
+import torch
+from torchvision import datasets
+from torchvision.transforms import ToTensor, Lambda
+
+ds = datasets.FashionMNIST(
+    root="data",
+    train=True,
+    download=True,
+    transform=ToTensor(),
+    target_transform=Lambda(lambda y: torch.zeros(10, dtype=torch.float).scatter_(0, torch.tensor(y), value=1))
+)
+
+#################################################
+# ToTensor()
+# -------------------------------
+#
+# `ToTensor <https://pytorch.org/vision/stable/transforms.html#torchvision.transforms.ToTensor>`_
+# converts a PIL image or NumPy ``ndarray`` into a ``FloatTensor``. and scales
+# the image's pixel intensity values in the range [0., 1.]
+#
+
+##############################################
+# Lambda Transforms
+# -------------------------------
+#
+# Lambda transforms apply any user-defined lambda function. Here, we define a function
+# to turn the integer into a one-hot encoded tensor.
+# It first creates a zero tensor of size 10 (the number of labels in our dataset) and calls
+# `scatter_ <https://pytorch.org/docs/stable/generated/torch.Tensor.scatter_.html>`_ which assigns a
+# ``value=1`` on the index as given by the label ``y``.
+
+target_transform = Lambda(lambda y: torch.zeros(
+    10, dtype=torch.float).scatter_(dim=0, index=torch.tensor(y), value=1))
+
+######################################################################
+# --------------
+#
+
+#################################################################
+# Further Reading
+# ~~~~~~~~~~~~~~~~~
+# - `torchvision.transforms API <https://pytorch.org/vision/stable/transforms.html>`_
diff --git a/beginner_source/bettertransformer_tutorial.rst b/beginner_source/bettertransformer_tutorial.rst
new file mode 100644
index 00000000000..76aebd839a0
--- /dev/null
+++ b/beginner_source/bettertransformer_tutorial.rst
@@ -0,0 +1,10 @@
+Fast Transformer Inference with Better Transformer
+==================================================
+
+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/blitz/README.txt b/beginner_source/blitz/README.txt
index 3383e324cec..f529d42e028 100644
--- a/beginner_source/blitz/README.txt
+++ b/beginner_source/blitz/README.txt
@@ -13,12 +13,11 @@ Deep Learning with PyTorch: A 60 Minute Blitz
 	Neural Networks
 	https://pytorch.org/tutorials/beginner/blitz/neural_networks_tutorial.html#
 
-4. autograd_tutorial.py
-	Automatic Differentiation 
-	https://pytorch.org/tutorials/beginner/blitz/autograd_tutorial.html
-
-5. cifar10_tutorial.py
+4. cifar10_tutorial.py
 	Training a Classifier
 	https://pytorch.org/tutorials/beginner/blitz/cifar10_tutorial.html
 
+5. data_parallel_tutorial.py 
+	Optional: Data Parallelism
+	https://pytorch.org/tutorials/beginner/blitz/data_parallel_tutorial.html
 
diff --git a/beginner_source/blitz/autograd_tutorial.py b/beginner_source/blitz/autograd_tutorial.py
index 51a0e49992a..d4d0f96816e 100644
--- a/beginner_source/blitz/autograd_tutorial.py
+++ b/beginner_source/blitz/autograd_tutorial.py
@@ -1,189 +1,323 @@
 # -*- coding: utf-8 -*-
 """
-Autograd: Automatic Differentiation
-===================================
+A Gentle Introduction to ``torch.autograd``
+===========================================
 
-Central to all neural networks in PyTorch is the ``autograd`` package.
-Let’s first briefly visit this, and we will then go to training our
-first neural network.
+``torch.autograd`` is PyTorch’s automatic differentiation engine that powers
+neural network training. In this section, you will get a conceptual
+understanding of how autograd helps a neural network train.
 
+Background
+~~~~~~~~~~
+Neural networks (NNs) are a collection of nested functions that are
+executed on some input data. These functions are defined by *parameters*
+(consisting of weights and biases), which in PyTorch are stored in
+tensors.
 
-The ``autograd`` package provides automatic differentiation for all operations
-on Tensors. It is a define-by-run framework, which means that your backprop is
-defined by how your code is run, and that every single iteration can be
-different.
+Training a NN happens in two steps:
 
-Let us see this in more simple terms with some examples.
+**Forward Propagation**: In forward prop, the NN makes its best guess
+about the correct output. It runs the input data through each of its
+functions to make this guess.
 
-Tensor
---------
+**Backward Propagation**: In backprop, the NN adjusts its parameters
+proportionate to the error in its guess. It does this by traversing
+backwards from the output, collecting the derivatives of the error with
+respect to the parameters of the functions (*gradients*), and optimizing
+the parameters using gradient descent. For a more detailed walkthrough
+of backprop, check out this `video from
+3Blue1Brown <https://www.youtube.com/watch?v=tIeHLnjs5U8>`__.
 
-``torch.Tensor`` is the central class of the package. If you set its attribute
-``.requires_grad`` as ``True``, it starts to track all operations on it. When
-you finish your computation you can call ``.backward()`` and have all the
-gradients computed automatically. The gradient for this tensor will be
-accumulated into ``.grad`` attribute.
 
-To stop a tensor from tracking history, you can call ``.detach()`` to detach
-it from the computation history, and to prevent future computation from being
-tracked.
 
-To prevent tracking history (and using memory), you can also wrap the code block
-in ``with torch.no_grad():``. This can be particularly helpful when evaluating a
-model because the model may have trainable parameters with
-``requires_grad=True``, but for which we don't need the gradients.
 
-There’s one more class which is very important for autograd
-implementation - a ``Function``.
+Usage in PyTorch
+~~~~~~~~~~~~~~~~
+Let's take a look at a single training step.
+For this example, we load a pretrained resnet18 model from ``torchvision``.
+We create a random data tensor to represent a single image with 3 channels, and height & width of 64,
+and its corresponding ``label`` initialized to some random values. Label in pretrained models has
+shape (1,1000).
 
-``Tensor`` and ``Function`` are interconnected and build up an acyclic
-graph, that encodes a complete history of computation. Each tensor has
-a ``.grad_fn`` attribute that references a ``Function`` that has created
-the ``Tensor`` (except for Tensors created by the user - their
-``grad_fn is None``).
+.. note::
+    This tutorial works only on the CPU and will not work on GPU devices (even if tensors are moved to CUDA).
 
-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
-data), you don’t need to specify any arguments to ``backward()``,
-however if it has more elements, you need to specify a ``gradient``
-argument that is a tensor of matching shape.
 """
+import torch
+from torchvision.models import resnet18, ResNet18_Weights
+model = resnet18(weights=ResNet18_Weights.DEFAULT)
+data = torch.rand(1, 3, 64, 64)
+labels = torch.rand(1, 1000)
+
+############################################################
+# Next, we run the input data through the model through each of its layers to make a prediction.
+# This is the **forward pass**.
+#
+
+prediction = model(data) # forward pass
+
+############################################################
+# We use the model's prediction and the corresponding label to calculate the error (``loss``).
+# The next step is to backpropagate this error through the network.
+# Backward propagation is kicked off when we call ``.backward()`` on the error tensor.
+# Autograd then calculates and stores the gradients for each model parameter in the parameter's ``.grad`` attribute.
+#
+
+loss = (prediction - labels).sum()
+loss.backward() # backward pass
+
+############################################################
+# Next, we load an optimizer, in this case SGD with a learning rate of 0.01 and `momentum <https://medium.com/data-science/stochastic-gradient-descent-with-momentum-a84097641a5d>`__ of 0.9.
+# We register all the parameters of the model in the optimizer.
+#
+
+optim = torch.optim.SGD(model.parameters(), lr=1e-2, momentum=0.9)
+
+######################################################################
+# Finally, we call ``.step()`` to initiate gradient descent. The optimizer adjusts each parameter by its gradient stored in ``.grad``.
+#
+
+optim.step() #gradient descent
+
+######################################################################
+# At this point, you have everything you need to train your neural network.
+# The below sections detail the workings of autograd - feel free to skip them.
+#
+
+
+######################################################################
+# --------------
+#
+
+
+######################################################################
+# Differentiation in Autograd
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# Let's take a look at how ``autograd`` collects gradients. We create two tensors ``a`` and ``b`` with
+# ``requires_grad=True``. This signals to ``autograd`` that every operation on them should be tracked.
+#
 
 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)
-
-###############################################################
-# Do a tensor operation:
-y = x + 2
-print(y)
-
-###############################################################
-# ``y`` was created as a result of an operation, so it has a ``grad_fn``.
-print(y.grad_fn)
-
-###############################################################
-# Do 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 ``False`` 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.
-# Because ``out`` contains a single scalar, ``out.backward()`` is
-# equivalent to ``out.backward(torch.tensor(1.))``.
-
-out.backward()
-
-###############################################################
-# Print gradients d(out)/dx
-#
-
-print(x.grad)
-
-###############################################################
-# You should have got a matrix of ``4.5``. Let’s call the ``out``
-# *Tensor* “:math:`o`”.
-# We have that :math:`o = \frac{1}{4}\sum_i z_i`,
-# :math:`z_i = 3(x_i+2)^2` and :math:`z_i\bigr\rvert_{x_i=1} = 27`.
-# Therefore,
-# :math:`\frac{\partial o}{\partial x_i} = \frac{3}{2}(x_i+2)`, hence
-# :math:`\frac{\partial o}{\partial x_i}\bigr\rvert_{x_i=1} = \frac{9}{2} = 4.5`.
-
-###############################################################
-# Mathematically, if you have a vector valued function :math:`\vec{y}=f(\vec{x})`,
-# then the gradient of :math:`\vec{y}` with respect to :math:`\vec{x}`
-# is a Jacobian matrix:
+a = torch.tensor([2., 3.], requires_grad=True)
+b = torch.tensor([6., 4.], requires_grad=True)
+
+######################################################################
+# We create another tensor ``Q`` from ``a`` and ``b``.
+#
+# .. math::
+#    Q = 3a^3 - b^2
+
+Q = 3*a**3 - b**2
+
+
+######################################################################
+# Let's assume ``a`` and ``b`` to be parameters of an NN, and ``Q``
+# to be the error. In NN training, we want gradients of the error
+# w.r.t. parameters, i.e.
+#
+# .. math::
+#    \frac{\partial Q}{\partial a} = 9a^2
+#
+# .. math::
+#    \frac{\partial Q}{\partial b} = -2b
+#
+#
+# When we call ``.backward()`` on ``Q``, autograd calculates these gradients
+# and stores them in the respective tensors' ``.grad`` attribute.
+#
+# We need to explicitly pass a ``gradient`` argument in ``Q.backward()`` because it is a vector.
+# ``gradient`` is a tensor of the same shape as ``Q``, and it represents the
+# gradient of Q w.r.t. itself, i.e.
+#
+# .. math::
+#    \frac{dQ}{dQ} = 1
+#
+# Equivalently, we can also aggregate Q into a scalar and call backward implicitly, like ``Q.sum().backward()``.
+#
+external_grad = torch.tensor([1., 1.])
+Q.backward(gradient=external_grad)
+
+
+#######################################################################
+# Gradients are now deposited in ``a.grad`` and ``b.grad``
+
+# check if collected gradients are correct
+print(9*a**2 == a.grad)
+print(-2*b == b.grad)
+
+
+######################################################################
+# Optional Reading - Vector Calculus using ``autograd``
+# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#
+# Mathematically, if you have a vector valued function
+# :math:`\vec{y}=f(\vec{x})`, then the gradient of :math:`\vec{y}` with
+# respect to :math:`\vec{x}` is a Jacobian matrix :math:`J`:
 #
 # .. math::
-#   J=\left(\begin{array}{ccc}
-#    \frac{\partial y_{1}}{\partial x_{1}} & \cdots & \frac{\partial y_{1}}{\partial x_{n}}\\
-#    \vdots & \ddots & \vdots\\
-#    \frac{\partial y_{m}}{\partial x_{1}} & \cdots & \frac{\partial y_{m}}{\partial x_{n}}
-#    \end{array}\right)
+#
+#
+#      J
+#      =
+#       \left(\begin{array}{cc}
+#       \frac{\partial \bf{y}}{\partial x_{1}} &
+#       ... &
+#       \frac{\partial \bf{y}}{\partial x_{n}}
+#       \end{array}\right)
+#      =
+#      \left(\begin{array}{ccc}
+#       \frac{\partial y_{1}}{\partial x_{1}} & \cdots & \frac{\partial y_{1}}{\partial x_{n}}\\
+#       \vdots & \ddots & \vdots\\
+#       \frac{\partial y_{m}}{\partial x_{1}} & \cdots & \frac{\partial y_{m}}{\partial x_{n}}
+#       \end{array}\right)
 #
 # Generally speaking, ``torch.autograd`` is an engine for computing
-# vector-Jacobian product. That is, given any vector
-# :math:`v=\left(\begin{array}{cccc} v_{1} & v_{2} & \cdots & v_{m}\end{array}\right)^{T}`,
-# compute the product :math:`v^{T}\cdot J`. If :math:`v` happens to be
-# the gradient of a scalar function :math:`l=g\left(\vec{y}\right)`,
-# that is,
-# :math:`v=\left(\begin{array}{ccc}\frac{\partial l}{\partial y_{1}} & \cdots & \frac{\partial l}{\partial y_{m}}\end{array}\right)^{T}`,
+# vector-Jacobian product. That is, given any vector :math:`\vec{v}`, compute the product
+# :math:`J^{T}\cdot \vec{v}`
+#
+# If :math:`\vec{v}` happens to be the gradient of a scalar function :math:`l=g\left(\vec{y}\right)`:
+#
+# .. math::
+#
+#
+#   \vec{v}
+#    =
+#    \left(\begin{array}{ccc}\frac{\partial l}{\partial y_{1}} & \cdots & \frac{\partial l}{\partial y_{m}}\end{array}\right)^{T}
+#
 # then by the chain rule, the vector-Jacobian product would be the
 # gradient of :math:`l` with respect to :math:`\vec{x}`:
 #
 # .. math::
-#   J^{T}\cdot v=\left(\begin{array}{ccc}
-#    \frac{\partial y_{1}}{\partial x_{1}} & \cdots & \frac{\partial y_{m}}{\partial x_{1}}\\
-#    \vdots & \ddots & \vdots\\
-#    \frac{\partial y_{1}}{\partial x_{n}} & \cdots & \frac{\partial y_{m}}{\partial x_{n}}
-#    \end{array}\right)\left(\begin{array}{c}
-#    \frac{\partial l}{\partial y_{1}}\\
-#    \vdots\\
-#    \frac{\partial l}{\partial y_{m}}
-#    \end{array}\right)=\left(\begin{array}{c}
-#    \frac{\partial l}{\partial x_{1}}\\
-#    \vdots\\
-#    \frac{\partial l}{\partial x_{n}}
-#    \end{array}\right)
-#
-# (Note that :math:`v^{T}\cdot J` gives a row vector which can be
-# treated as a column vector by taking :math:`J^{T}\cdot v`.)
-#
-# This characteristic of vector-Jacobian product makes it very
-# convenient to feed external gradients into a model that has
-# non-scalar output.
-
-###############################################################
-# Now let's take a look at an example of vector-Jacobian product:
-
-x = torch.randn(3, requires_grad=True)
-
-y = x * 2
-while y.data.norm() < 1000:
-    y = y * 2
-
-print(y)
-
-###############################################################
-# Now in this case ``y`` is no longer a scalar. ``torch.autograd``
-# could not compute the full Jacobian directly, but if we just
-# want the vector-Jacobian product, simply pass the vector to
-# ``backward`` as argument:
-v = torch.tensor([0.1, 1.0, 0.0001], dtype=torch.float)
-y.backward(v)
-
-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)
-
-###############################################################
-# **Read Later:**
-#
-# Documentation of ``autograd`` and ``Function`` is at
-# https://pytorch.org/docs/autograd
+#
+#
+#      J^{T}\cdot \vec{v} = \left(\begin{array}{ccc}
+#       \frac{\partial y_{1}}{\partial x_{1}} & \cdots & \frac{\partial y_{m}}{\partial x_{1}}\\
+#       \vdots & \ddots & \vdots\\
+#       \frac{\partial y_{1}}{\partial x_{n}} & \cdots & \frac{\partial y_{m}}{\partial x_{n}}
+#       \end{array}\right)\left(\begin{array}{c}
+#       \frac{\partial l}{\partial y_{1}}\\
+#       \vdots\\
+#       \frac{\partial l}{\partial y_{m}}
+#       \end{array}\right) = \left(\begin{array}{c}
+#       \frac{\partial l}{\partial x_{1}}\\
+#       \vdots\\
+#       \frac{\partial l}{\partial x_{n}}
+#       \end{array}\right)
+#
+# This characteristic of vector-Jacobian product is what we use in the above example;
+# ``external_grad`` represents :math:`\vec{v}`.
+
+
+
+######################################################################
+# Computational Graph
+# ~~~~~~~~~~~~~~~~~~~
+#
+# Conceptually, autograd keeps a record of data (tensors) & all executed
+# operations (along with the resulting new tensors) in a directed acyclic
+# graph (DAG) consisting of
+# `Function <https://pytorch.org/docs/stable/autograd.html#torch.autograd.Function>`__
+# objects. In this DAG, leaves are the input tensors, roots are the output
+# tensors. By tracing this graph from roots to leaves, you can
+# automatically compute the gradients using the chain rule.
+#
+# In a forward pass, autograd does two things simultaneously:
+#
+# - run the requested operation to compute a resulting tensor, and
+# - maintain the operation’s *gradient function* in the DAG.
+#
+# The backward pass kicks off when ``.backward()`` is called on the DAG
+# root. ``autograd`` then:
+#
+# - computes the gradients from each ``.grad_fn``,
+# - accumulates them in the respective tensor’s ``.grad`` attribute, and
+# - using the chain rule, propagates all the way to the leaf tensors.
+#
+# Below is a visual representation of the DAG in our example. In the graph,
+# the arrows are in the direction of the forward pass. The nodes represent the backward functions
+# of each operation in the forward pass. The leaf nodes in blue represent our leaf tensors ``a`` and ``b``.
+#
+# .. figure:: /_static/img/dag_autograd.png
+#
+# .. note::
+#   **DAGs are dynamic in PyTorch**
+#   An important thing to note is that the graph is recreated from scratch; after each
+#   ``.backward()`` call, autograd starts populating a new graph. This is
+#   exactly what allows you to use control flow statements in your model;
+#   you can change the shape, size and operations at every iteration if
+#   needed.
+#
+# Exclusion from the DAG
+# ^^^^^^^^^^^^^^^^^^^^^^
+#
+# ``torch.autograd`` tracks operations on all tensors which have their
+# ``requires_grad`` flag set to ``True``. For tensors that don’t require
+# gradients, setting this attribute to ``False`` excludes it from the
+# gradient computation DAG.
+#
+# The output tensor of an operation will require gradients even if only a
+# single input tensor has ``requires_grad=True``.
+#
+
+x = torch.rand(5, 5)
+y = torch.rand(5, 5)
+z = torch.rand((5, 5), requires_grad=True)
+
+a = x + y
+print(f"Does `a` require gradients?: {a.requires_grad}")
+b = x + z
+print(f"Does `b` require gradients?: {b.requires_grad}")
+
+
+######################################################################
+# In a NN, parameters that don't compute gradients are usually called **frozen parameters**.
+# It is useful to "freeze" part of your model if you know in advance that you won't need the gradients of those parameters
+# (this offers some performance benefits by reducing autograd computations).
+#
+# In finetuning, we freeze most of the model and typically only modify the classifier layers to make predictions on new labels.
+# Let's walk through a small example to demonstrate this. As before, we load a pretrained resnet18 model, and freeze all the parameters.
+
+from torch import nn, optim
+
+model = resnet18(weights=ResNet18_Weights.DEFAULT)
+
+# Freeze all the parameters in the network
+for param in model.parameters():
+    param.requires_grad = False
+
+######################################################################
+# Let's say we want to finetune the model on a new dataset with 10 labels.
+# In resnet, the classifier is the last linear layer ``model.fc``.
+# We can simply replace it with a new linear layer (unfrozen by default)
+# that acts as our classifier.
+
+model.fc = nn.Linear(512, 10)
+
+######################################################################
+# Now all parameters in the model, except the parameters of ``model.fc``, are frozen.
+# The only parameters that compute gradients are the weights and bias of ``model.fc``.
+
+# Optimize only the classifier
+optimizer = optim.SGD(model.parameters(), lr=1e-2, momentum=0.9)
+
+##########################################################################
+# Notice although we register all the parameters in the optimizer,
+# the only parameters that are computing gradients (and hence updated in gradient descent)
+# are the weights and bias of the classifier.
+#
+# The same exclusionary functionality is available as a context manager in
+# `torch.no_grad() <https://pytorch.org/docs/stable/generated/torch.no_grad.html>`__
+#
+
+######################################################################
+# --------------
+#
+
+######################################################################
+# Further readings:
+# ~~~~~~~~~~~~~~~~~~~
+#
+# -  `In-place operations & Multithreaded Autograd <https://pytorch.org/docs/stable/notes/autograd.html>`__
+# -  `Example implementation of reverse-mode autodiff <https://colab.research.google.com/drive/1VpeE6UvEPRz9HmsHh1KS0XxXjYu533EC>`__
+# -  `Video: PyTorch Autograd Explained - In-depth Tutorial <https://www.youtube.com/watch?v=MswxJw-8PvE>`__
diff --git a/beginner_source/blitz/cifar10_tutorial.py b/beginner_source/blitz/cifar10_tutorial.py
index d84e2fab7e0..8f19f5964c6 100644
--- a/beginner_source/blitz/cifar10_tutorial.py
+++ b/beginner_source/blitz/cifar10_tutorial.py
@@ -22,7 +22,7 @@
 
 Specifically for vision, we have created a package called
 ``torchvision``, that has data loaders for common datasets such as
-Imagenet, CIFAR10, MNIST, etc. and data transformers for images, viz.,
+ImageNet, CIFAR10, MNIST, etc. and data transformers for images, viz.,
 ``torchvision.datasets`` and ``torch.utils.data.DataLoader``.
 
 This provides a huge convenience and avoids writing boilerplate code.
@@ -43,15 +43,15 @@
 
 We will do the following steps in order:
 
-1. Load and normalizing the CIFAR10 training and test datasets using
+1. Load and normalize the CIFAR10 training and test datasets using
    ``torchvision``
 2. Define a Convolutional Neural Network
 3. Define a loss function
 4. Train the network on the training data
 5. Test the network on the test data
 
-1. Loading and normalizing CIFAR10
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+1. Load and normalize CIFAR10
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Using ``torchvision``, it’s extremely easy to load CIFAR10.
 """
@@ -63,18 +63,26 @@
 # The output of torchvision datasets are PILImage images of range [0, 1].
 # We transform them to Tensors of normalized range [-1, 1].
 
+########################################################################
+# .. note::
+#     If you are running this tutorial on Windows or MacOS and encounter a
+#     BrokenPipeError or RuntimeError related to multiprocessing, try setting
+#     the num_worker of torch.utils.data.DataLoader() to 0.
+
 transform = transforms.Compose(
     [transforms.ToTensor(),
      transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
 
+batch_size = 4
+
 trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
                                         download=True, transform=transform)
-trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
+trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size,
                                           shuffle=True, num_workers=2)
 
 testset = torchvision.datasets.CIFAR10(root='./data', train=False,
                                        download=True, transform=transform)
-testloader = torch.utils.data.DataLoader(testset, batch_size=4,
+testloader = torch.utils.data.DataLoader(testset, batch_size=batch_size,
                                          shuffle=False, num_workers=2)
 
 classes = ('plane', 'car', 'bird', 'cat',
@@ -98,17 +106,17 @@ def imshow(img):
 
 # get some random training images
 dataiter = iter(trainloader)
-images, labels = dataiter.next()
+images, labels = next(dataiter)
 
 # show images
 imshow(torchvision.utils.make_grid(images))
 # print labels
-print(' '.join('%5s' % classes[labels[j]] for j in range(4)))
+print(' '.join(f'{classes[labels[j]]:5s}' for j in range(batch_size)))
 
 
 ########################################################################
 # 2. Define a Convolutional Neural Network
-# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 # Copy the neural network from the Neural Networks section before and modify it to
 # take 3-channel images (instead of 1-channel images as it was defined).
 
@@ -118,7 +126,7 @@ def imshow(img):
 
 class Net(nn.Module):
     def __init__(self):
-        super(Net, self).__init__()
+        super().__init__()
         self.conv1 = nn.Conv2d(3, 6, 5)
         self.pool = nn.MaxPool2d(2, 2)
         self.conv2 = nn.Conv2d(6, 16, 5)
@@ -129,7 +137,7 @@ def __init__(self):
     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 = torch.flatten(x, 1) # flatten all dimensions except batch
         x = F.relu(self.fc1(x))
         x = F.relu(self.fc2(x))
         x = self.fc3(x)
@@ -175,13 +183,21 @@ def forward(self, x):
         # print statistics
         running_loss += loss.item()
         if i % 2000 == 1999:    # print every 2000 mini-batches
-            print('[%d, %5d] loss: %.3f' %
-                  (epoch + 1, i + 1, running_loss / 2000))
+            print(f'[{epoch + 1}, {i + 1:5d}] loss: {running_loss / 2000:.3f}')
             running_loss = 0.0
 
 print('Finished Training')
 
 ########################################################################
+# Let's quickly save our trained model:
+
+PATH = './cifar_net.pth'
+torch.save(net.state_dict(), PATH)
+
+########################################################################
+# See `here <https://pytorch.org/docs/stable/notes/serialization.html>`_
+# for more details on saving PyTorch models.
+#
 # 5. Test the network on the test data
 # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 #
@@ -195,11 +211,18 @@ def forward(self, x):
 # Okay, first step. Let us display an image from the test set to get familiar.
 
 dataiter = iter(testloader)
-images, labels = dataiter.next()
+images, labels = next(dataiter)
 
 # print images
 imshow(torchvision.utils.make_grid(images))
-print('GroundTruth: ', ' '.join('%5s' % classes[labels[j]] for j in range(4)))
+print('GroundTruth: ', ' '.join(f'{classes[labels[j]]:5s}' for j in range(4)))
+
+########################################################################
+# Next, let's load back in our saved model (note: saving and re-loading the model
+# wasn't necessary here, we only did it to illustrate how to do so):
+
+net = Net()
+net.load_state_dict(torch.load(PATH, weights_only=True))
 
 ########################################################################
 # Okay, now let us see what the neural network thinks these examples above are:
@@ -213,7 +236,7 @@ def forward(self, x):
 # So, let's get the index of the highest energy:
 _, predicted = torch.max(outputs, 1)
 
-print('Predicted: ', ' '.join('%5s' % classes[predicted[j]]
+print('Predicted: ', ' '.join(f'{classes[predicted[j]]:5s}'
                               for j in range(4)))
 
 ########################################################################
@@ -223,42 +246,48 @@ def forward(self, x):
 
 correct = 0
 total = 0
+# since we're not training, we don't need to calculate the gradients for our outputs
 with torch.no_grad():
     for data in testloader:
         images, labels = data
+        # calculate outputs by running images through the network
         outputs = net(images)
-        _, predicted = torch.max(outputs.data, 1)
+        # the class with the highest energy is what we choose as prediction
+        _, predicted = torch.max(outputs, 1)
         total += labels.size(0)
         correct += (predicted == labels).sum().item()
 
-print('Accuracy of the network on the 10000 test images: %d %%' % (
-    100 * correct / total))
+print(f'Accuracy of the network on the 10000 test images: {100 * correct // total} %')
 
 ########################################################################
-# That looks waaay better than chance, which is 10% accuracy (randomly picking
+# That looks way better than chance, which is 10% accuracy (randomly picking
 # a class out of 10 classes).
 # Seems like the network learnt something.
 #
 # Hmmm, what are the classes that performed well, and the classes that did
 # not perform well:
 
-class_correct = list(0. for i in range(10))
-class_total = list(0. for i in range(10))
+# prepare to count predictions for each class
+correct_pred = {classname: 0 for classname in classes}
+total_pred = {classname: 0 for classname in classes}
+
+# again no gradients needed
 with torch.no_grad():
     for data in testloader:
         images, labels = data
         outputs = net(images)
-        _, predicted = torch.max(outputs, 1)
-        c = (predicted == labels).squeeze()
-        for i in range(4):
-            label = labels[i]
-            class_correct[label] += c[i].item()
-            class_total[label] += 1
+        _, predictions = torch.max(outputs, 1)
+        # collect the correct predictions for each class
+        for label, prediction in zip(labels, predictions):
+            if label == prediction:
+                correct_pred[classes[label]] += 1
+            total_pred[classes[label]] += 1
 
 
-for i in range(10):
-    print('Accuracy of %5s : %2d %%' % (
-        classes[i], 100 * class_correct[i] / class_total[i]))
+# print accuracy for each class
+for classname, correct_count in correct_pred.items():
+    accuracy = 100 * float(correct_count) / total_pred[classname]
+    print(f'Accuracy for class: {classname:5s} is {accuracy:.1f} %')
 
 ########################################################################
 # Okay, so what next?
@@ -273,7 +302,7 @@ def forward(self, x):
 # Let's first define our device as the first visible cuda device if we have
 # CUDA available:
 
-device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
 
 # Assuming that we are on a CUDA machine, this should print a CUDA device:
 
@@ -297,8 +326,8 @@ def forward(self, x):
 #
 #         inputs, labels = data[0].to(device), data[1].to(device)
 #
-# Why dont I notice MASSIVE speedup compared to CPU? Because your network
-# is realllly small.
+# Why don't I notice MASSIVE speedup compared to CPU? Because your network
+# is really small.
 #
 # **Exercise:** Try increasing the width of your network (argument 2 of
 # the first ``nn.Conv2d``, and argument 1 of the second ``nn.Conv2d`` –
diff --git a/beginner_source/blitz/neural_networks_tutorial.py b/beginner_source/blitz/neural_networks_tutorial.py
index 04b099a3066..9c04d9af0f3 100644
--- a/beginner_source/blitz/neural_networks_tutorial.py
+++ b/beginner_source/blitz/neural_networks_tutorial.py
@@ -7,7 +7,7 @@
 
 Now that you had a glimpse of ``autograd``, ``nn`` depends on
 ``autograd`` to define models and differentiate them.
-An ``nn.Module`` contains layers, and a method ``forward(input)``\ that
+An ``nn.Module`` contains layers, and a method ``forward(input)`` that
 returns the ``output``.
 
 For example, look at this network that classifies digit images:
@@ -46,32 +46,42 @@ class Net(nn.Module):
 
     def __init__(self):
         super(Net, self).__init__()
-        # 1 input image channel, 6 output channels, 3x3 square convolution
+        # 1 input image channel, 6 output channels, 5x5 square convolution
         # kernel
-        self.conv1 = nn.Conv2d(1, 6, 3)
-        self.conv2 = nn.Conv2d(6, 16, 3)
+        self.conv1 = nn.Conv2d(1, 6, 5)
+        self.conv2 = nn.Conv2d(6, 16, 5)
         # an affine operation: y = Wx + b
-        self.fc1 = nn.Linear(16 * 6 * 6, 120)  # 6*6 from image dimension 
+        self.fc1 = nn.Linear(16 * 5 * 5, 120)  # 5*5 from image dimension 
         self.fc2 = nn.Linear(120, 84)
         self.fc3 = nn.Linear(84, 10)
 
-    def forward(self, x):
-        # Max pooling over a (2, 2) window
-        x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
-        # If the size is a square you can only specify a single number
-        x = F.max_pool2d(F.relu(self.conv2(x)), 2)
-        x = x.view(-1, self.num_flat_features(x))
-        x = F.relu(self.fc1(x))
-        x = F.relu(self.fc2(x))
-        x = self.fc3(x)
-        return x
-
-    def num_flat_features(self, x):
-        size = x.size()[1:]  # all dimensions except the batch dimension
-        num_features = 1
-        for s in size:
-            num_features *= s
-        return num_features
+    def forward(self, input):
+        # Convolution layer C1: 1 input image channel, 6 output channels,
+        # 5x5 square convolution, it uses RELU activation function, and
+        # outputs a Tensor with size (N, 6, 28, 28), where N is the size of the batch
+        c1 = F.relu(self.conv1(input))
+        # Subsampling layer S2: 2x2 grid, purely functional,
+        # this layer does not have any parameter, and outputs a (N, 6, 14, 14) Tensor
+        s2 = F.max_pool2d(c1, (2, 2))
+        # Convolution layer C3: 6 input channels, 16 output channels,
+        # 5x5 square convolution, it uses RELU activation function, and
+        # outputs a (N, 16, 10, 10) Tensor
+        c3 = F.relu(self.conv2(s2))
+        # Subsampling layer S4: 2x2 grid, purely functional,
+        # this layer does not have any parameter, and outputs a (N, 16, 5, 5) Tensor
+        s4 = F.max_pool2d(c3, 2)
+        # Flatten operation: purely functional, outputs a (N, 400) Tensor
+        s4 = torch.flatten(s4, 1)
+        # Fully connected layer F5: (N, 400) Tensor input,
+        # and outputs a (N, 120) Tensor, it uses RELU activation function
+        f5 = F.relu(self.fc1(s4))
+        # Fully connected layer F6: (N, 120) Tensor input,
+        # and outputs a (N, 84) Tensor, it uses RELU activation function
+        f6 = F.relu(self.fc2(f5))
+        # Gaussian layer OUTPUT: (N, 84) Tensor input, and
+        # outputs a (N, 10) Tensor
+        output = self.fc3(f6)
+        return output
 
 
 net = Net()
@@ -90,9 +100,9 @@ def num_flat_features(self, x):
 print(params[0].size())  # conv1's .weight
 
 ########################################################################
-# Let try a random 32x32 input.
+# Let's try a random 32x32 input.
 # Note: expected input size of this net (LeNet) is 32x32. To use this net on
-# MNIST dataset, please resize the images from the dataset to 32x32.
+# the MNIST dataset, please resize the images from the dataset to 32x32.
 
 input = torch.randn(1, 1, 32, 32)
 out = net(input)
@@ -151,7 +161,7 @@ def num_flat_features(self, x):
 # `loss functions <https://pytorch.org/docs/nn.html#loss-functions>`_ under the
 # nn package .
 # A simple loss is: ``nn.MSELoss`` which computes the mean-squared error
-# between the input and the target.
+# between the output and the target.
 #
 # For example:
 
@@ -168,16 +178,17 @@ def num_flat_features(self, x):
 # ``.grad_fn`` attribute, you will see a graph of computations that looks
 # like this:
 #
-# ::
+# .. code-block:: sh
 #
 #     input -> conv2d -> relu -> maxpool2d -> conv2d -> relu -> maxpool2d
-#           -> view -> linear -> relu -> linear -> relu -> linear
+#           -> flatten -> linear -> relu -> linear -> relu -> linear
 #           -> MSELoss
 #           -> loss
 #
 # So, when we call ``loss.backward()``, the whole graph is differentiated
-# w.r.t. the loss, and all Tensors in the graph that has ``requires_grad=True``
-# will have their ``.grad`` Tensor accumulated with the gradient.
+# w.r.t. the neural net parameters, and all Tensors in the graph that have
+# ``requires_grad=True`` will have their ``.grad`` Tensor accumulated with the
+# gradient.
 #
 # For illustration, let us follow a few steps backward:
 
@@ -225,9 +236,11 @@ def num_flat_features(self, x):
 # The simplest update rule used in practice is the Stochastic Gradient
 # Descent (SGD):
 #
-#      ``weight = weight - learning_rate * gradient``
+# .. code:: python
+#
+#     weight = weight - learning_rate * gradient
 #
-# We can implement this using simple python code:
+# We can implement this using simple Python code:
 #
 # .. code:: python
 #
@@ -239,23 +252,26 @@ def num_flat_features(self, x):
 # update rules such as SGD, Nesterov-SGD, Adam, RMSProp, etc.
 # To enable this, we built a small package: ``torch.optim`` that
 # implements all these methods. Using it is very simple:
-
-import torch.optim as optim
-
-# create your optimizer
-optimizer = optim.SGD(net.parameters(), lr=0.01)
-
-# in your training loop:
-optimizer.zero_grad()   # zero the gradient buffers
-output = net(input)
-loss = criterion(output, target)
-loss.backward()
-optimizer.step()    # Does the update
+#
+# .. code:: python
+#
+#     import torch.optim as optim
+#
+#     # create your optimizer
+#     optimizer = optim.SGD(net.parameters(), lr=0.01)
+#
+#     # in your training loop:
+#     optimizer.zero_grad()   # zero the gradient buffers
+#     output = net(input)
+#     loss = criterion(output, target)
+#     loss.backward()
+#     optimizer.step()    # Does the update
+#
 
 
 ###############################################################
-# .. Note::
+# .. note::
 #
 #       Observe how gradient buffers had to be manually set to zero using
 #       ``optimizer.zero_grad()``. This is because gradients are accumulated
-#       as explained in `Backprop`_ section.
+#       as explained in the `Backprop`_ section.
diff --git a/beginner_source/blitz/tensor_tutorial.py b/beginner_source/blitz/tensor_tutorial.py
index d1e17f1f08b..ac54945bc3a 100644
--- a/beginner_source/blitz/tensor_tutorial.py
+++ b/beginner_source/blitz/tensor_tutorial.py
@@ -1,186 +1,201 @@
-# -*- coding: utf-8 -*-
 """
-What is PyTorch?
-================
-
-It’s a Python-based scientific computing package targeted at two sets of
-audiences:
-
--  A replacement for NumPy to use the power of GPUs
--  a deep learning research platform that provides maximum flexibility
-   and speed
+Tensors
+========
 
-Getting Started
----------------
+Tensors are a specialized data structure that are very similar to arrays
+and matrices. In PyTorch, we use tensors to encode the inputs and
+outputs of a model, as well as the model’s parameters.
 
-Tensors
-^^^^^^^
+Tensors are similar to NumPy’s ndarrays, except that tensors can run on
+GPUs or other specialized hardware to accelerate computing. If you’re familiar with ndarrays, you’ll
+be right at home with the Tensor API. If not, follow along in this quick
+API walkthrough.
 
-Tensors are similar to NumPy’s ndarrays, with the addition being that
-Tensors can also be used on a GPU to accelerate computing.
 """
 
-from __future__ import print_function
 import torch
+import numpy as np
 
-###############################################################
-# Construct a 5x3 matrix, uninitialized:
-
-x = torch.empty(5, 3)
-print(x)
 
-###############################################################
-# Construct a randomly initialized matrix:
+######################################################################
+# Tensor Initialization
+# ~~~~~~~~~~~~~~~~~~~~~
+#
+# Tensors can be initialized in various ways. Take a look at the following examples:
+#
+# **Directly from data**
+#
+# Tensors can be created directly from data. The data type is automatically inferred.
 
-x = torch.rand(5, 3)
-print(x)
+data = [[1, 2], [3, 4]]
+x_data = torch.tensor(data)
 
-###############################################################
-# Construct a matrix filled zeros and of dtype long:
+######################################################################
+# **From a NumPy array**
+#
+# Tensors can be created from NumPy arrays (and vice versa - see :ref:`bridge-to-np-label`).
+np_array = np.array(data)
+x_np = torch.from_numpy(np_array)
 
-x = torch.zeros(5, 3, dtype=torch.long)
-print(x)
 
 ###############################################################
-# Construct a tensor directly from data:
-
-x = torch.tensor([5.5, 3])
-print(x)
+# **From another tensor:**
+#
+# The new tensor retains the properties (shape, datatype) of the argument tensor, unless explicitly overridden.
 
-###############################################################
-# or create a tensor based on an existing tensor. These methods
-# will reuse properties of the input tensor, e.g. dtype, unless
-# new values are provided by user
+x_ones = torch.ones_like(x_data) # retains the properties of x_data
+print(f"Ones Tensor: \n {x_ones} \n")
 
-x = x.new_ones(5, 3, dtype=torch.double)      # new_* methods take in sizes
-print(x)
+x_rand = torch.rand_like(x_data, dtype=torch.float) # overrides the datatype of x_data
+print(f"Random Tensor: \n {x_rand} \n")
 
-x = torch.randn_like(x, dtype=torch.float)    # override dtype!
-print(x)                                      # result has the same size
 
-###############################################################
-# Get its size:
+######################################################################
+# **With random or constant values:**
+#
+# ``shape`` is a tuple of tensor dimensions. In the functions below, it determines the dimensionality of the output tensor.
 
-print(x.size())
+shape = (2, 3,)
+rand_tensor = torch.rand(shape)
+ones_tensor = torch.ones(shape)
+zeros_tensor = torch.zeros(shape)
 
-###############################################################
-# .. note::
-#     ``torch.Size`` is in fact a tuple, so it supports all tuple operations.
-#
-# Operations
-# ^^^^^^^^^^
-# There are multiple syntaxes for operations. In the following
-# example, we will take a look at the addition operation.
-#
-# Addition: syntax 1
-y = torch.rand(5, 3)
-print(x + y)
+print(f"Random Tensor: \n {rand_tensor} \n")
+print(f"Ones Tensor: \n {ones_tensor} \n")
+print(f"Zeros Tensor: \n {zeros_tensor}")
 
-###############################################################
-# Addition: syntax 2
 
-print(torch.add(x, y))
 
-###############################################################
-# Addition: providing an output tensor as argument
-result = torch.empty(5, 3)
-torch.add(x, y, out=result)
-print(result)
 
-###############################################################
-# Addition: in-place
+######################################################################
+# --------------
+#
 
-# adds x to y
-y.add_(x)
-print(y)
 
-###############################################################
-# .. note::
-#     Any operation that mutates a tensor in-place is post-fixed with an ``_``.
-#     For example: ``x.copy_(y)``, ``x.t_()``, will change ``x``.
+######################################################################
+# Tensor Attributes
+# ~~~~~~~~~~~~~~~~~
 #
-# You can use standard NumPy-like indexing with all bells and whistles!
+# Tensor attributes describe their shape, datatype, and the device on which they are stored.
 
-print(x[:, 1])
+tensor = torch.rand(3, 4)
 
-###############################################################
-# Resizing: If you want to resize/reshape tensor, you can use ``torch.view``:
-x = torch.randn(4, 4)
-y = x.view(16)
-z = x.view(-1, 8)  # the size -1 is inferred from other dimensions
-print(x.size(), y.size(), z.size())
+print(f"Shape of tensor: {tensor.shape}")
+print(f"Datatype of tensor: {tensor.dtype}")
+print(f"Device tensor is stored on: {tensor.device}")
 
-###############################################################
-# If you have a one element tensor, use ``.item()`` to get the value as a
-# Python number
-x = torch.randn(1)
-print(x)
-print(x.item())
 
-###############################################################
-# **Read later:**
+######################################################################
+# --------------
 #
+
+
+######################################################################
+# Tensor Operations
+# ~~~~~~~~~~~~~~~~~
 #
-#   100+ Tensor operations, including transposing, indexing, slicing,
-#   mathematical operations, linear algebra, random numbers, etc.,
-#   are described
-#   `here <https://pytorch.org/docs/torch>`_.
+# Over 100 tensor operations, including transposing, indexing, slicing,
+# mathematical operations, linear algebra, random sampling, and more are
+# comprehensively described
+# `here <https://pytorch.org/docs/stable/torch.html>`__.
 #
-# NumPy Bridge
-# ------------
+# Each of them can be run on the GPU (at typically higher speeds than on a
+# CPU). If you’re using Colab, allocate a GPU by going to Edit > Notebook
+# Settings.
 #
-# Converting a Torch Tensor to a NumPy array and vice versa is a breeze.
+
+# We move our tensor to the GPU if available
+if torch.cuda.is_available():
+  tensor = tensor.to('cuda')
+  print(f"Device tensor is stored on: {tensor.device}")
+
+
+######################################################################
+# Try out some of the operations from the list.
+# If you're familiar with the NumPy API, you'll find the Tensor API a breeze to use.
 #
-# The Torch Tensor and NumPy array will share their underlying memory
-# locations (if the Torch Tensor is on CPU), and changing one will change
-# the other.
+
+###############################################################
+# **Standard numpy-like indexing and slicing:**
+
+tensor = torch.ones(4, 4)
+tensor[:,1] = 0
+print(tensor)
+
+######################################################################
+# **Joining tensors** You can use ``torch.cat`` to concatenate a sequence of tensors along a given dimension.
+# See also `torch.stack <https://pytorch.org/docs/stable/generated/torch.stack.html>`__,
+# another tensor joining op that is subtly different from ``torch.cat``.
+t1 = torch.cat([tensor, tensor, tensor], dim=1)
+print(t1)
+
+######################################################################
+# **Multiplying tensors**
+
+# This computes the element-wise product
+print(f"tensor.mul(tensor) \n {tensor.mul(tensor)} \n")
+# Alternative syntax:
+print(f"tensor * tensor \n {tensor * tensor}")
+
+######################################################################
 #
-# Converting a Torch Tensor to a NumPy Array
-# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+# This computes the matrix multiplication between two tensors
+print(f"tensor.matmul(tensor.T) \n {tensor.matmul(tensor.T)} \n")
+# Alternative syntax:
+print(f"tensor @ tensor.T \n {tensor @ tensor.T}")
 
-a = torch.ones(5)
-print(a)
 
-###############################################################
+######################################################################
+# **In-place operations**
+# Operations that have a ``_`` suffix are in-place. For example: ``x.copy_(y)``, ``x.t_()``, will change ``x``.
+
+print(tensor, "\n")
+tensor.add_(5)
+print(tensor)
+
+######################################################################
+# .. note::
+#      In-place operations save some memory, but can be problematic when computing derivatives because of an immediate loss
+#      of history. Hence, their use is discouraged.
+
+######################################################################
+# --------------
 #
 
-b = a.numpy()
-print(b)
 
-###############################################################
-# See how the numpy array changed in value.
+######################################################################
+# .. _bridge-to-np-label:
+#
+# Bridge with NumPy
+# ~~~~~~~~~~~~~~~~~
+# Tensors on the CPU and NumPy arrays can share their underlying memory
+# locations, and changing one will change	the other.
 
-a.add_(1)
-print(a)
-print(b)
 
-###############################################################
-# Converting NumPy Array to Torch Tensor
+######################################################################
+# Tensor to NumPy array
 # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-# See how changing the np array changed the Torch Tensor automatically
+t = torch.ones(5)
+print(f"t: {t}")
+n = t.numpy()
+print(f"n: {n}")
 
-import numpy as np
-a = np.ones(5)
-b = torch.from_numpy(a)
-np.add(a, 1, out=a)
-print(a)
-print(b)
+######################################################################
+# A change in the tensor reflects in the NumPy array.
 
-###############################################################
-# All the Tensors on the CPU except a CharTensor support converting to
-# NumPy and back.
-#
-# CUDA Tensors
-# ------------
-#
-# Tensors can be moved onto any device using the ``.to`` method.
+t.add_(1)
+print(f"t: {t}")
+print(f"n: {n}")
 
-# let us run this cell only if CUDA is available
-# We will use ``torch.device`` objects to move tensors in and out of GPU
-if torch.cuda.is_available():
-    device = torch.device("cuda")          # a CUDA device object
-    y = torch.ones_like(x, device=device)  # directly create a tensor on GPU
-    x = x.to(device)                       # or just use strings ``.to("cuda")``
-    z = x + y
-    print(z)
-    print(z.to("cpu", torch.double))       # ``.to`` can also change dtype together!
+
+######################################################################
+# NumPy array to Tensor
+# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+n = np.ones(5)
+t = torch.from_numpy(n)
+
+######################################################################
+# Changes in the NumPy array reflects in the tensor.
+np.add(n, 1, out=n)
+print(f"t: {t}")
+print(f"n: {n}")
diff --git a/beginner_source/chatbot_tutorial.py b/beginner_source/chatbot_tutorial.py
index 838a1c1aeda..520c934d965 100644
--- a/beginner_source/chatbot_tutorial.py
+++ b/beginner_source/chatbot_tutorial.py
@@ -31,28 +31,28 @@
 #    :align: center
 #    :alt: bot
 #
-# .. code:: python
-#
-#   > hello?
-#   Bot: hello .
-#   > where am I?
-#   Bot: you re in a hospital .
-#   > who are you?
-#   Bot: i m a lawyer .
-#   > how are you doing?
-#   Bot: i m fine .
-#   > are you my friend?
-#   Bot: no .
-#   > you're under arrest
-#   Bot: i m trying to help you !
-#   > i'm just kidding
-#   Bot: i m sorry .
-#   > where are you from?
-#   Bot: san francisco .
-#   > it's time for me to leave
-#   Bot: i know .
-#   > goodbye
-#   Bot: goodbye .
+# .. code-block:: python
+#
+#    > hello?
+#    Bot: hello .
+#    > where am I?
+#    Bot: you re in a hospital .
+#    > who are you?
+#    Bot: i m a lawyer .
+#    > how are you doing?
+#    Bot: i m fine .
+#    > are you my friend?
+#    Bot: no .
+#    > you're under arrest
+#    Bot: i m trying to help you !
+#    > i'm just kidding
+#    Bot: i m sorry .
+#    > where are you from?
+#    Bot: san francisco .
+#    > it's time for me to leave
+#    Bot: i know .
+#    > goodbye
+#    Bot: goodbye .
 #
 # **Tutorial Highlights**
 #
@@ -65,7 +65,7 @@
 # -  Implement greedy-search decoding module
 # -  Interact with trained chatbot
 #
-# **Acknowledgements**
+# **Acknowledgments**
 #
 # This tutorial borrows code from the following sources:
 #
@@ -75,7 +75,7 @@
 # 2) Sean Robertson’s practical-pytorch seq2seq-translation example:
 #    https://github.com/spro/practical-pytorch/tree/master/seq2seq-translation
 #
-# 3) FloydHub’s Cornell Movie Corpus preprocessing code:
+# 3) FloydHub Cornell Movie Corpus preprocessing code:
 #    https://github.com/floydhub/textutil-preprocess-cornell-movie-corpus
 #
 
@@ -84,18 +84,13 @@
 # Preparations
 # ------------
 #
-# To start, Download the data ZIP file
-# `here <https://www.cs.cornell.edu/~cristian/Cornell_Movie-Dialogs_Corpus.html>`__
+# To get started, `download <https://zissou.infosci.cornell.edu/convokit/datasets/movie-corpus/movie-corpus.zip>`__ the Movie-Dialogs Corpus zip file.
+
 # and put in a ``data/`` directory under the current directory.
 #
 # After that, let’s import some necessities.
 #
 
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-from __future__ import unicode_literals
-
 import torch
 from torch.jit import script, trace
 import torch.nn as nn
@@ -110,10 +105,13 @@
 from io import open
 import itertools
 import math
+import json
 
 
-USE_CUDA = torch.cuda.is_available()
-device = torch.device("cuda" if USE_CUDA else "cpu")
+# If the current `accelerator <https://pytorch.org/docs/stable/torch.html#accelerators>`__ is available,
+# we will use it. Otherwise, we use the CPU.
+device = torch.accelerator.current_accelerator().type if torch.accelerator.is_available() else "cpu"
+print(f"Using {device} device")
 
 
 ######################################################################
@@ -140,7 +138,7 @@
 # original format.
 #
 
-corpus_name = "cornell movie-dialogs corpus"
+corpus_name = "movie-corpus"
 corpus = os.path.join("data", corpus_name)
 
 def printLines(file, n=10):
@@ -149,7 +147,7 @@ def printLines(file, n=10):
     for line in lines[:n]:
         print(line)
 
-printLines(os.path.join(corpus, "movie_lines.txt"))
+printLines(os.path.join(corpus, "utterances.jsonl"))
 
 
 ######################################################################
@@ -160,54 +158,47 @@ def printLines(file, n=10):
 # contains a tab-separated *query sentence* and a *response sentence* pair.
 #
 # The following functions facilitate the parsing of the raw
-# *movie_lines.txt* data file.
+# ``utterances.jsonl`` data file.
 #
-# -  ``loadLines`` splits each line of the file into a dictionary of
-#    fields (lineID, characterID, movieID, character, text)
-# -  ``loadConversations`` groups fields of lines from ``loadLines`` into
-#    conversations based on *movie_conversations.txt*
+# -  ``loadLinesAndConversations`` splits each line of the file into a dictionary of
+#    lines with fields: ``lineID``, ``characterID``, and text and then groups them
+#    into conversations with fields: ``conversationID``, ``movieID``, and lines.
 # -  ``extractSentencePairs`` extracts pairs of sentences from
 #    conversations
 #
 
-# Splits each line of the file into a dictionary of fields
-def loadLines(fileName, fields):
+# Splits each line of the file to create lines and conversations
+def loadLinesAndConversations(fileName):
     lines = {}
+    conversations = {}
     with open(fileName, 'r', encoding='iso-8859-1') as f:
         for line in f:
-            values = line.split(" +++$+++ ")
-            # Extract fields
+            lineJson = json.loads(line)
+            # Extract fields for line object
             lineObj = {}
-            for i, field in enumerate(fields):
-                lineObj[field] = values[i]
+            lineObj["lineID"] = lineJson["id"]
+            lineObj["characterID"] = lineJson["speaker"]
+            lineObj["text"] = lineJson["text"]
             lines[lineObj['lineID']] = lineObj
-    return lines
 
+            # Extract fields for conversation object
+            if lineJson["conversation_id"] not in conversations:
+                convObj = {}
+                convObj["conversationID"] = lineJson["conversation_id"]
+                convObj["movieID"] = lineJson["meta"]["movie_id"]
+                convObj["lines"] = [lineObj]
+            else:
+                convObj = conversations[lineJson["conversation_id"]]
+                convObj["lines"].insert(0, lineObj)
+            conversations[convObj["conversationID"]] = convObj
 
-# Groups fields of lines from `loadLines` into conversations based on *movie_conversations.txt*
-def loadConversations(fileName, lines, fields):
-    conversations = []
-    with open(fileName, 'r', encoding='iso-8859-1') as f:
-        for line in f:
-            values = line.split(" +++$+++ ")
-            # Extract fields
-            convObj = {}
-            for i, field in enumerate(fields):
-                convObj[field] = values[i]
-            # Convert string to list (convObj["utteranceIDs"] == "['L598485', 'L598486', ...]")
-            lineIds = eval(convObj["utteranceIDs"])
-            # Reassemble lines
-            convObj["lines"] = []
-            for lineId in lineIds:
-                convObj["lines"].append(lines[lineId])
-            conversations.append(convObj)
-    return conversations
+    return lines, conversations
 
 
 # Extracts pairs of sentences from conversations
 def extractSentencePairs(conversations):
     qa_pairs = []
-    for conversation in conversations:
+    for conversation in conversations.values():
         # Iterate over all the lines of the conversation
         for i in range(len(conversation["lines"]) - 1):  # We ignore the last line (no answer for it)
             inputLine = conversation["lines"][i]["text"].strip()
@@ -220,7 +211,7 @@ def extractSentencePairs(conversations):
 
 ######################################################################
 # Now we’ll call these functions and create the file. We’ll call it
-# *formatted_movie_lines.txt*.
+# ``formatted_movie_lines.txt``.
 #
 
 # Define path to new file
@@ -230,18 +221,12 @@ def extractSentencePairs(conversations):
 # Unescape the delimiter
 delimiter = str(codecs.decode(delimiter, "unicode_escape"))
 
-# Initialize lines dict, conversations list, and field ids
+# Initialize lines dict and conversations dict
 lines = {}
-conversations = []
-MOVIE_LINES_FIELDS = ["lineID", "characterID", "movieID", "character", "text"]
-MOVIE_CONVERSATIONS_FIELDS = ["character1ID", "character2ID", "movieID", "utteranceIDs"]
-
-# Load lines and process conversations
-print("\nProcessing corpus...")
-lines = loadLines(os.path.join(corpus, "movie_lines.txt"), MOVIE_LINES_FIELDS)
-print("\nLoading conversations...")
-conversations = loadConversations(os.path.join(corpus, "movie_conversations.txt"),
-                                  lines, MOVIE_CONVERSATIONS_FIELDS)
+conversations = {}
+# Load lines and conversations
+print("\nProcessing corpus into lines and conversations...")
+lines, conversations = loadLinesAndConversations(os.path.join(corpus, "utterances.jsonl"))
 
 # Write new csv file
 print("\nWriting newly formatted file...")
@@ -370,12 +355,12 @@ def readVocs(datafile, corpus_name):
     voc = Voc(corpus_name)
     return voc, pairs
 
-# Returns True iff both sentences in a pair 'p' are under the MAX_LENGTH threshold
+# Returns True if both sentences in a pair 'p' are under the MAX_LENGTH threshold
 def filterPair(p):
     # Input sequences need to preserve the last word for EOS token
     return len(p[0].split(' ')) < MAX_LENGTH and len(p[1].split(' ')) < MAX_LENGTH
 
-# Filter pairs using filterPair condition
+# Filter pairs using the ``filterPair`` condition
 def filterPairs(pairs):
     return [pair for pair in pairs if filterPair(pair)]
 
@@ -470,7 +455,7 @@ def trimRareWords(voc, pairs, MIN_COUNT):
 # with mini-batches.
 #
 # Using mini-batches also means that we must be mindful of the variation
-# of sentence length in our batches. To accomodate sentences of different
+# of sentence length in our batches. To accommodate sentences of different
 # sizes in the same batch, we will make our batched input tensor of shape
 # *(max_length, batch_size)*, where sentences shorter than the
 # *max_length* are zero padded after an *EOS_token*.
@@ -536,7 +521,7 @@ def outputVar(l, voc):
     max_target_len = max([len(indexes) for indexes in indexes_batch])
     padList = zeroPadding(indexes_batch)
     mask = binaryMatrix(padList)
-    mask = torch.ByteTensor(mask)
+    mask = torch.BoolTensor(mask)
     padVar = torch.LongTensor(padList)
     return padVar, mask, max_target_len
 
@@ -614,7 +599,7 @@ def batch2TrainData(voc, pair_batch):
 # in normal sequential order, and one that is fed the input sequence in
 # reverse order. The outputs of each network are summed at each time step.
 # Using a bidirectional GRU will give us the advantage of encoding both
-# past and future context.
+# past and future contexts.
 #
 # Bidirectional RNN:
 #
@@ -670,7 +655,7 @@ def __init__(self, hidden_size, embedding, n_layers=1, dropout=0):
         self.hidden_size = hidden_size
         self.embedding = embedding
 
-        # Initialize GRU; the input_size and hidden_size params are both set to 'hidden_size'
+        # Initialize GRU; the input_size and hidden_size parameters are both set to 'hidden_size'
         #   because our input size is a word embedding with number of features == hidden_size
         self.gru = nn.GRU(hidden_size, hidden_size, n_layers,
                           dropout=(0 if n_layers == 1 else dropout), bidirectional=True)
@@ -699,7 +684,7 @@ def forward(self, input_seq, input_lengths, hidden=None):
 # states to generate the next word in the sequence. It continues
 # generating words until it outputs an *EOS_token*, representing the end
 # of the sentence. A common problem with a vanilla seq2seq decoder is that
-# if we rely soley on the context vector to encode the entire input
+# if we rely solely on the context vector to encode the entire input
 # sequence’s meaning, it is likely that we will have information loss.
 # This is especially the case when dealing with long input sequences,
 # greatly limiting the capability of our decoder.
@@ -949,7 +934,7 @@ def maskNLLLoss(inp, target, mask):
 #   sequence (or batch of sequences). We use the ``GRU`` layer like this in
 #   the ``encoder``. The reality is that under the hood, there is an
 #   iterative process looping over each time step calculating hidden states.
-#   Alternatively, you ran run these modules one time-step at a time. In
+#   Alternatively, you can run these modules one time-step at a time. In
 #   this case, we manually loop over the sequences during the training
 #   process like we must do for the ``decoder`` model. As long as you
 #   maintain the correct conceptual model of these modules, implementing
@@ -967,9 +952,10 @@ def train(input_variable, lengths, target_variable, mask, max_target_len, encode
 
     # Set device options
     input_variable = input_variable.to(device)
-    lengths = lengths.to(device)
     target_variable = target_variable.to(device)
     mask = mask.to(device)
+    # Lengths for RNN packing should always be on the CPU
+    lengths = lengths.to("cpu")
 
     # Initialize variables
     loss = 0
@@ -1017,7 +1003,7 @@ def train(input_variable, lengths, target_variable, mask, max_target_len, encode
             print_losses.append(mask_loss.item() * nTotal)
             n_totals += nTotal
 
-    # Perform backpropatation
+    # Perform backpropagation
     loss.backward()
 
     # Clip gradients: gradients are modified in place
@@ -1042,8 +1028,8 @@ def train(input_variable, lengths, target_variable, mask, max_target_len, encode
 # lifting with the ``train`` function.
 #
 # One thing to note is that when we save our model, we save a tarball
-# containing the encoder and decoder state_dicts (parameters), the
-# optimizers’ state_dicts, the loss, the iteration, etc. Saving the model
+# containing the encoder and decoder ``state_dicts`` (parameters), the
+# optimizers’ ``state_dicts``, the loss, the iteration, etc. Saving the model
 # in this way will give us the ultimate flexibility with the checkpoint.
 # After loading a checkpoint, we will be able to use the model parameters
 # to run inference, or we can continue training right where we left off.
@@ -1113,7 +1099,7 @@ def trainIters(model_name, voc, pairs, encoder, decoder, encoder_optimizer, deco
 # softmax value. This decoding method is optimal on a single time-step
 # level.
 #
-# To facilite the greedy decoding operation, we define a
+# To facilitate the greedy decoding operation, we define a
 # ``GreedySearchDecoder`` class. When run, an object of this class takes
 # an input sequence (``input_seq``) of shape *(input_seq length, 1)*, a
 # scalar input length (``input_length``) tensor, and a ``max_length`` to
@@ -1144,7 +1130,7 @@ def forward(self, input_seq, input_length, max_length):
         # Forward input through encoder model
         encoder_outputs, encoder_hidden = self.encoder(input_seq, input_length)
         # Prepare encoder's final hidden layer to be first hidden input to the decoder
-        decoder_hidden = encoder_hidden[:decoder.n_layers]
+        decoder_hidden = encoder_hidden[:self.decoder.n_layers]
         # Initialize decoder input with SOS_token
         decoder_input = torch.ones(1, 1, device=device, dtype=torch.long) * SOS_token
         # Initialize tensors to append decoded words to
@@ -1205,7 +1191,7 @@ def evaluate(encoder, decoder, searcher, voc, sentence, max_length=MAX_LENGTH):
     input_batch = torch.LongTensor(indexes_batch).transpose(0, 1)
     # Use appropriate device
     input_batch = input_batch.to(device)
-    lengths = lengths.to(device)
+    lengths = lengths.to("cpu")
     # Decode sentence with searcher
     tokens, scores = searcher(input_batch, lengths, max_length)
     # indexes -> words
@@ -1250,8 +1236,8 @@ def evaluateInput(encoder, decoder, searcher, voc):
 # Configure models
 model_name = 'cb_model'
 attn_model = 'dot'
-#attn_model = 'general'
-#attn_model = 'concat'
+#``attn_model = 'general'``
+#``attn_model = 'concat'``
 hidden_size = 500
 encoder_n_layers = 2
 decoder_n_layers = 2
@@ -1261,12 +1247,17 @@ def evaluateInput(encoder, decoder, searcher, voc):
 # Set checkpoint to load from; set to None if starting from scratch
 loadFilename = None
 checkpoint_iter = 4000
-#loadFilename = os.path.join(save_dir, model_name, corpus_name,
-#                            '{}-{}_{}'.format(encoder_n_layers, decoder_n_layers, hidden_size),
-#                            '{}_checkpoint.tar'.format(checkpoint_iter))
 
+#############################################################
+# Sample code to load from a checkpoint:
+#
+# .. code-block:: python
+#
+#    loadFilename = os.path.join(save_dir, model_name, corpus_name,
+#                        '{}-{}_{}'.format(encoder_n_layers, decoder_n_layers, hidden_size),
+#                        '{}_checkpoint.tar'.format(checkpoint_iter))
 
-# Load model if a loadFilename is provided
+# Load model if a ``loadFilename`` is provided
 if loadFilename:
     # If loading on same machine the model was trained on
     checkpoint = torch.load(loadFilename)
@@ -1329,6 +1320,17 @@ def evaluateInput(encoder, decoder, searcher, voc):
     encoder_optimizer.load_state_dict(encoder_optimizer_sd)
     decoder_optimizer.load_state_dict(decoder_optimizer_sd)
 
+# If you have an accelerator, configure it to call
+for state in encoder_optimizer.state.values():
+    for k, v in state.items():
+        if isinstance(v, torch.Tensor):
+            state[k] = v.to(device)
+
+for state in decoder_optimizer.state.values():
+    for k, v in state.items():
+        if isinstance(v, torch.Tensor):
+            state[k] = v.to(device)
+
 # Run training iterations
 print("Starting Training!")
 trainIters(model_name, voc, pairs, encoder, decoder, encoder_optimizer, decoder_optimizer,
@@ -1343,7 +1345,7 @@ def evaluateInput(encoder, decoder, searcher, voc):
 # To chat with your model, run the following block.
 #
 
-# Set dropout layers to eval mode
+# Set dropout layers to ``eval`` mode
 encoder.eval()
 decoder.eval()
 
diff --git a/beginner_source/colab.rst b/beginner_source/colab.rst
index 3f20f9ffd68..e5106a2c81a 100644
--- a/beginner_source/colab.rst
+++ b/beginner_source/colab.rst
@@ -1,5 +1,30 @@
+Running Tutorials in Google Colab
+=================================
+
+When you run a tutorial in Google Colab, there might be additional
+requirements and dependencies that you need to meet in order
+for the tutorial to work properly. This section contains notes on how to
+configure various settings in order to successfully
+run PyTorch tutorials in Google Colab.
+
+PyTorch Version in Google Colab
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Wen you are running a tutorial that requires a version of PyTorch that has
+just been released, that version might not be yet available in Google Colab.
+To check that you have the required ``torch`` and compatible domain libraries
+installed, run ``!pip list``.
+
+If the installed version of PyTorch is lower than required,
+uninstall it and reinstall again by running the following commands:
+
+.. code-block:: python
+
+   !pip3 uninstall --yes torch torchaudio torchvision torchtext torchdata
+   !pip3 install torch torchaudio torchvision torchtext torchdata
+
 Using Tutorial Data from Google Drive in Colab
-==============================================
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 We've added a new feature to tutorials that allows users to open the
 notebook associated with a tutorial in Google Colab. You may need to
@@ -20,24 +45,24 @@ At the top of the page click **Run in Google Colab**.
 
 The file will open in Colab.
 
-If you choose, **Runtime** then **Run All**, you'll get an error as the
+If you select **Runtime**, and then **Run All**, you'll get an error as the
 file can't be found.
 
 To fix this, we'll copy the required file into our Google Drive account.
 
 1. Log into Google Drive.
-2. In Google Drive, make a folder named **data**, with a subfolder named
-   **cornell**.
-3. Visit the Cornell Movie Dialogs Corpus and download the ZIP file.
+2. In Google Drive, make a folder named ``data``, with a subfolder named
+   ``cornell``.
+3. Visit the Cornell Movie Dialogs Corpus and download the movie-corpus ZIP file.
 4. Unzip the file on your local machine.
-5. Copy the file **movie\_lines.txt** to **data/cornell** folder you
+5. Copy the file ``utterances.jsonl`` to the ``data/cornell`` folder that you
    created in Google Drive.
 
 Now we'll need to edit the file in\_ \_Colab to point to the file on
 Google Drive.
 
 In Colab, add the following to top of the code section over the line
-that begins *corpus\_name*:
+that begins ``corpus\_name``:
 
 ::
 
@@ -46,8 +71,8 @@ that begins *corpus\_name*:
 
 Change the two lines that follow:
 
-1. Change the **corpus\_name** value to **"cornell"**.
-2. Change the line that begins with **corpus** to this:
+1. Change the ``corpus\_name`` value to ``"cornell"``.
+2. Change the line that begins with ``corpus`` to this:
 
 ::
 
@@ -55,12 +80,12 @@ Change the two lines that follow:
 
 We're now pointing to the file we uploaded to Drive.
 
-Now when you click on the **Run cell** button for the code section,
+Now when you click the **Run cell** button for the code section,
 you'll be prompted to authorize Google Drive and you'll get an
 authorization code. Paste the code into the prompt in Colab and you
 should be set.
 
-Rerun the notebook from **Runtime** / **Run All** menu command and
+Rerun the notebook from the **Runtime** / **Run All** menu command and
 you'll see it process. (Note that this tutorial takes a long time to
 run.)
 
@@ -68,3 +93,11 @@ Hopefully this example will give you a good starting point for running
 some of the more complex tutorials in Colab. As we evolve our use of
 Colab on the PyTorch tutorials site, we'll look at ways to make this
 easier for users.
+
+Enabling CUDA
+~~~~~~~~~~~~~~~~
+Some tutorials require a CUDA-enabled device (NVIDIA GPU), which involves
+changing the Runtime type prior to executing the tutorial.
+To change the Runtime in Google Colab, on the top drop-down menu select **Runtime**,
+then select **Change runtime type**. Under **Hardware accelerator**, select ``T4 GPU``,
+then click ``Save``.
diff --git a/beginner_source/data_loading_tutorial.py b/beginner_source/data_loading_tutorial.py
index b31de5088c4..8f21bb7bff6 100644
--- a/beginner_source/data_loading_tutorial.py
+++ b/beginner_source/data_loading_tutorial.py
@@ -1,10 +1,10 @@
 # -*- coding: utf-8 -*-
 """
-Data Loading and Processing Tutorial
-====================================
+Writing Custom Datasets, DataLoaders and Transforms
+===================================================
 **Author**: `Sasank Chilamkurthy <https://chsasank.github.io>`_
 
-A lot of effort in solving any machine learning problem goes in to
+A lot of effort in solving any machine learning problem goes into
 preparing the data. PyTorch provides many tools to make data loading
 easy and hopefully, to make your code more readable. In this tutorial,
 we will see how to load and preprocess/augment data from a non trivial
@@ -18,7 +18,6 @@
 
 """
 
-from __future__ import print_function, division
 import os
 import torch
 import pandas as pd
@@ -51,24 +50,25 @@
 #     estimation <https://blog.dlib.net/2014/08/real-time-face-pose-estimation.html>`__
 #     on a few images from imagenet tagged as 'face'.
 #
-# Dataset comes with a csv file with annotations which looks like this:
+# Dataset comes with a ``.csv`` file with annotations which looks like this:
 #
-# ::
+# .. code-block:: sh
 #
 #     image_name,part_0_x,part_0_y,part_1_x,part_1_y,part_2_x, ... ,part_67_x,part_67_y
 #     0805personali01.jpg,27,83,27,98, ... 84,134
 #     1084239450_e76e00b7e7.jpg,70,236,71,257, ... ,128,312
 #
-# Let's quickly read the CSV and get the annotations in an (N, 2) array where N
-# is the number of landmarks.
+# Let's take a single image name and its annotations from the CSV, in this case row index number 65
+# for person-7.jpg just as an example. Read it, store the image name in ``img_name`` and store its
+# annotations in an (L, 2) array ``landmarks`` where L is the number of landmarks in that row.
 #
 
 landmarks_frame = pd.read_csv('data/faces/face_landmarks.csv')
 
 n = 65
 img_name = landmarks_frame.iloc[n, 0]
-landmarks = landmarks_frame.iloc[n, 1:].as_matrix()
-landmarks = landmarks.astype('float').reshape(-1, 2)
+landmarks = landmarks_frame.iloc[n, 1:]
+landmarks = np.asarray(landmarks, dtype=float).reshape(-1, 2)
 
 print('Image name: {}'.format(img_name))
 print('Landmarks shape: {}'.format(landmarks.shape))
@@ -103,7 +103,7 @@ def show_landmarks(image, landmarks):
 #
 # -  ``__len__`` so that ``len(dataset)`` returns the size of the dataset.
 # -  ``__getitem__`` to support the indexing such that ``dataset[i]`` can
-#    be used to get :math:`i`\ th sample
+#    be used to get :math:`i`\ th sample.
 #
 # Let's create a dataset class for our face landmarks dataset. We will
 # read the csv in ``__init__`` but leave the reading of images to
@@ -122,7 +122,7 @@ class FaceLandmarksDataset(Dataset):
 
     def __init__(self, csv_file, root_dir, transform=None):
         """
-        Args:
+        Arguments:
             csv_file (string): Path to the csv file with annotations.
             root_dir (string): Directory with all the images.
             transform (callable, optional): Optional transform to be applied
@@ -136,11 +136,14 @@ def __len__(self):
         return len(self.landmarks_frame)
 
     def __getitem__(self, idx):
+        if torch.is_tensor(idx):
+            idx = idx.tolist()
+
         img_name = os.path.join(self.root_dir,
                                 self.landmarks_frame.iloc[idx, 0])
         image = io.imread(img_name)
-        landmarks = self.landmarks_frame.iloc[idx, 1:].as_matrix()
-        landmarks = landmarks.astype('float').reshape(-1, 2)
+        landmarks = self.landmarks_frame.iloc[idx, 1:]
+        landmarks = np.array([landmarks], dtype=float).reshape(-1, 2)
         sample = {'image': image, 'landmarks': landmarks}
 
         if self.transform:
@@ -159,9 +162,7 @@ def __getitem__(self, idx):
 
 fig = plt.figure()
 
-for i in range(len(face_dataset)):
-    sample = face_dataset[i]
-
+for i, sample in enumerate(face_dataset):
     print(i, sample['image'].shape, sample['landmarks'].shape)
 
     ax = plt.subplot(1, 4, i + 1)
@@ -181,7 +182,7 @@ def __getitem__(self, idx):
 #
 # One issue we can see from the above is that the samples are not of the
 # same size. Most neural networks expect the images of a fixed size.
-# Therefore, we will need to write some prepocessing code.
+# Therefore, we will need to write some preprocessing code.
 # Let's create three transforms:
 #
 # -  ``Rescale``: to scale the image
@@ -191,11 +192,11 @@ def __getitem__(self, idx):
 #    swap axes).
 #
 # We will write them as callable classes instead of simple functions so
-# that parameters of the transform need not be passed everytime it's
+# that parameters of the transform need not be passed every time it's
 # called. For this, we just need to implement ``__call__`` method and
 # if required, ``__init__`` method. We can then use a transform like this:
 #
-# ::
+# .. code-block:: python
 #
 #     tsfm = Transform(params)
 #     transformed_sample = tsfm(sample)
@@ -262,8 +263,8 @@ def __call__(self, sample):
         h, w = image.shape[:2]
         new_h, new_w = self.output_size
 
-        top = np.random.randint(0, h - new_h)
-        left = np.random.randint(0, w - new_w)
+        top = np.random.randint(0, h - new_h + 1)
+        left = np.random.randint(0, w - new_w + 1)
 
         image = image[top: top + new_h,
                       left: left + new_w]
@@ -281,17 +282,23 @@ def __call__(self, sample):
 
         # swap color axis because
         # numpy image: H x W x C
-        # torch image: C X H X W
+        # torch image: C x H x W
         image = image.transpose((2, 0, 1))
         return {'image': torch.from_numpy(image),
                 'landmarks': torch.from_numpy(landmarks)}
 
+######################################################################
+# .. note::
+#     In the example above, `RandomCrop` uses an external library's random number generator
+#     (in this case, Numpy's `np.random.int`). This can result in unexpected behavior with `DataLoader`
+#     (see `here <https://pytorch.org/docs/stable/notes/faq.html#my-data-loader-workers-return-identical-random-numbers>`_).
+#     In practice, it is safer to stick to PyTorch's random number generator, e.g. by using `torch.randint` instead.
 
 ######################################################################
 # Compose transforms
 # ~~~~~~~~~~~~~~~~~~
 #
-# Now, we apply the transforms on an sample.
+# Now, we apply the transforms on a sample.
 #
 # Let's say we want to rescale the shorter side of the image to 256 and
 # then randomly crop a square of size 224 from it. i.e, we want to compose
@@ -329,7 +336,7 @@ def __call__(self, sample):
 #
 # -  An image is read from the file on the fly
 # -  Transforms are applied on the read image
-# -  Since one of the transforms is random, data is augmentated on
+# -  Since one of the transforms is random, data is augmented on
 #    sampling
 #
 # We can iterate over the created dataset with a ``for i in range``
@@ -344,9 +351,7 @@ def __call__(self, sample):
                                                ToTensor()
                                            ]))
 
-for i in range(len(transformed_dataset)):
-    sample = transformed_dataset[i]
-
+for i, sample in enumerate(transformed_dataset):
     print(i, sample['image'].size(), sample['landmarks'].size())
 
     if i == 3:
@@ -369,7 +374,7 @@ def __call__(self, sample):
 #
 
 dataloader = DataLoader(transformed_dataset, batch_size=4,
-                        shuffle=True, num_workers=4)
+                        shuffle=True, num_workers=0)
 
 
 # Helper function to show a batch
@@ -391,6 +396,10 @@ def show_landmarks_batch(sample_batched):
 
         plt.title('Batch from dataloader')
 
+# if you are using Windows, uncomment the next line and indent the for loop.
+# you might need to go back and change ``num_workers`` to 0.
+
+# if __name__ == '__main__':
 for i_batch, sample_batched in enumerate(dataloader):
     print(i_batch, sample_batched['image'].size(),
           sample_batched['landmarks'].size())
@@ -412,7 +421,9 @@ def show_landmarks_batch(sample_batched):
 # and dataloader. ``torchvision`` package provides some common datasets and
 # transforms. You might not even have to write custom classes. One of the
 # more generic datasets available in torchvision is ``ImageFolder``.
-# It assumes that images are organized in the following way: ::
+# It assumes that images are organized in the following way:
+#
+# .. code-block:: sh
 #
 #     root/ants/xxx.png
 #     root/ants/xxy.jpeg
@@ -426,23 +437,25 @@ def show_landmarks_batch(sample_batched):
 #
 # where 'ants', 'bees' etc. are class labels. Similarly generic transforms
 # which operate on ``PIL.Image`` like  ``RandomHorizontalFlip``, ``Scale``,
-# are also available. You can use these to write a dataloader like this: ::
-#
-#   import torch
-#   from torchvision import transforms, datasets
-#
-#   data_transform = transforms.Compose([
-#           transforms.RandomSizedCrop(224),
-#           transforms.RandomHorizontalFlip(),
-#           transforms.ToTensor(),
-#           transforms.Normalize(mean=[0.485, 0.456, 0.406],
-#                                std=[0.229, 0.224, 0.225])
-#       ])
-#   hymenoptera_dataset = datasets.ImageFolder(root='hymenoptera_data/train',
-#                                              transform=data_transform)
-#   dataset_loader = torch.utils.data.DataLoader(hymenoptera_dataset,
-#                                                batch_size=4, shuffle=True,
-#                                                num_workers=4)
+# are also available. You can use these to write a dataloader like this:
+#
+# .. code-block:: pytorch
+#
+#    import torch
+#    from torchvision import transforms, datasets
+#
+#    data_transform = transforms.Compose([
+#            transforms.RandomResizedCrop(224),
+#            transforms.RandomHorizontalFlip(),
+#            transforms.ToTensor(),
+#            transforms.Normalize(mean=[0.485, 0.456, 0.406],
+#                                 std=[0.229, 0.224, 0.225])
+#        ])
+#    hymenoptera_dataset = datasets.ImageFolder(root='hymenoptera_data/train',
+#                                               transform=data_transform)
+#    dataset_loader = torch.utils.data.DataLoader(hymenoptera_dataset,
+#                                                 batch_size=4, shuffle=True,
+#                                                 num_workers=4)
 #
 # For an example with training code, please see
 # :doc:`transfer_learning_tutorial`.
diff --git a/beginner_source/dcgan_faces_tutorial.py b/beginner_source/dcgan_faces_tutorial.py
index 018d67a3705..e9ac3fdd504 100644
--- a/beginner_source/dcgan_faces_tutorial.py
+++ b/beginner_source/dcgan_faces_tutorial.py
@@ -15,7 +15,7 @@
 # This tutorial will give an introduction to DCGANs through an example. We
 # will train a generative adversarial network (GAN) to generate new
 # celebrities after showing it pictures of many real celebrities. Most of
-# the code here is from the dcgan implementation in
+# the code here is from the DCGAN implementation in
 # `pytorch/examples <https://github.com/pytorch/examples>`__, and this
 # document will give a thorough explanation of the implementation and shed
 # light on how and why this model works. But don’t worry, no prior
@@ -30,8 +30,8 @@
 # What is a GAN?
 # ~~~~~~~~~~~~~~
 # 
-# GANs are a framework for teaching a DL model to capture the training
-# data’s distribution so we can generate new data from that same
+# GANs are a framework for teaching a deep learning model to capture the training
+# data distribution so we can generate new data from that same
 # distribution. GANs were invented by Ian Goodfellow in 2014 and first
 # described in the paper `Generative Adversarial
 # Nets <https://papers.nips.cc/paper/5423-generative-adversarial-nets.pdf>`__.
@@ -52,8 +52,8 @@
 # with the discriminator. Let :math:`x` be data representing an image.
 # :math:`D(x)` is the discriminator network which outputs the (scalar)
 # probability that :math:`x` came from training data rather than the
-# generator. Here, since we are dealing with images the input to
-# :math:`D(x)` is an image of HWC size 3x64x64. Intuitively, :math:`D(x)`
+# generator. Here, since we are dealing with images, the input to
+# :math:`D(x)` is an image of CHW size 3x64x64. Intuitively, :math:`D(x)`
 # should be HIGH when :math:`x` comes from training data and LOW when
 # :math:`x` comes from the generator. :math:`D(x)` can also be thought of
 # as a traditional binary classifier.
@@ -71,7 +71,7 @@
 # :math:`D` and :math:`G` play a minimax game in which :math:`D` tries to
 # maximize the probability it correctly classifies reals and fakes
 # (:math:`logD(x)`), and :math:`G` tries to minimize the probability that
-# :math:`D` will predict its outputs are fake (:math:`log(1-D(G(x)))`).
+# :math:`D` will predict its outputs are fake (:math:`log(1-D(G(z)))`).
 # From the paper, the GAN loss function is
 # 
 # .. math:: \underset{G}{\text{min}} \underset{D}{\text{max}}V(D,G) = \mathbb{E}_{x\sim p_{data}(x)}\big[logD(x)\big] + \mathbb{E}_{z\sim p_{z}(z)}\big[log(1-D(G(z)))\big]
@@ -112,7 +112,6 @@
 # will be explained in the coming sections.
 # 
 
-from __future__ import print_function
 #%matplotlib inline
 import argparse
 import os
@@ -120,7 +119,6 @@
 import torch
 import torch.nn as nn
 import torch.nn.parallel
-import torch.backends.cudnn as cudnn
 import torch.optim as optim
 import torch.utils.data
 import torchvision.datasets as dset
@@ -131,12 +129,13 @@
 import matplotlib.animation as animation
 from IPython.display import HTML
 
-# Set random seem for reproducibility
+# Set random seed for reproducibility
 manualSeed = 999
 #manualSeed = random.randint(1, 10000) # use if you want new results
 print("Random Seed: ", manualSeed)
 random.seed(manualSeed)
 torch.manual_seed(manualSeed)
+torch.use_deterministic_algorithms(True) # Needed for reproducible results
 
 
 ######################################################################
@@ -145,35 +144,35 @@
 # 
 # Let’s define some inputs for the run:
 # 
-# -  **dataroot** - the path to the root of the dataset folder. We will
-#    talk more about the dataset in the next section
-# -  **workers** - the number of worker threads for loading the data with
-#    the DataLoader
-# -  **batch_size** - the batch size used in training. The DCGAN paper
-#    uses a batch size of 128
-# -  **image_size** - the spatial size of the images used for training.
+# -  ``dataroot`` - the path to the root of the dataset folder. We will
+#    talk more about the dataset in the next section.
+# -  ``workers`` - the number of worker threads for loading the data with
+#    the ``DataLoader``.
+# -  ``batch_size`` - the batch size used in training. The DCGAN paper
+#    uses a batch size of 128.
+# -  ``image_size`` - the spatial size of the images used for training.
 #    This implementation defaults to 64x64. If another size is desired,
 #    the structures of D and G must be changed. See
 #    `here <https://github.com/pytorch/examples/issues/70>`__ for more
-#    details
-# -  **nc** - number of color channels in the input images. For color
-#    images this is 3
-# -  **nz** - length of latent vector
-# -  **ngf** - relates to the depth of feature maps carried through the
-#    generator
-# -  **ndf** - sets the depth of feature maps propagated through the
-#    discriminator
-# -  **num_epochs** - number of training epochs to run. Training for
+#    details.
+# -  ``nc`` - number of color channels in the input images. For color
+#    images this is 3.
+# -  ``nz`` - length of latent vector.
+# -  ``ngf`` - relates to the depth of feature maps carried through the
+#    generator.
+# -  ``ndf`` - sets the depth of feature maps propagated through the
+#    discriminator.
+# -  ``num_epochs`` - number of training epochs to run. Training for
 #    longer will probably lead to better results but will also take much
-#    longer
-# -  **lr** - learning rate for training. As described in the DCGAN paper,
-#    this number should be 0.0002
-# -  **beta1** - beta1 hyperparameter for Adam optimizers. As described in
-#    paper, this number should be 0.5
-# -  **ngpu** - number of GPUs available. If this is 0, code will run in
+#    longer.
+# -  ``lr`` - learning rate for training. As described in the DCGAN paper,
+#    this number should be 0.0002.
+# -  ``beta1`` - beta1 hyperparameter for Adam optimizers. As described in
+#    paper, this number should be 0.5.
+# -  ``ngpu`` - number of GPUs available. If this is 0, code will run in
 #    CPU mode. If this number is greater than 0 it will run on that number
-#    of GPUs
-# 
+#    of GPUs.
+#
 
 # Root directory for dataset
 dataroot = "data/celeba"
@@ -206,7 +205,7 @@
 # Learning rate for optimizers
 lr = 0.0002
 
-# Beta1 hyperparam for Adam optimizers
+# Beta1 hyperparameter for Adam optimizers
 beta1 = 0.5
 
 # Number of GPUs available. Use 0 for CPU mode.
@@ -221,13 +220,13 @@
 # dataset <http://mmlab.ie.cuhk.edu.hk/projects/CelebA.html>`__ which can
 # be downloaded at the linked site, or in `Google
 # Drive <https://drive.google.com/drive/folders/0B7EVK8r0v71pTUZsaXdaSnZBZzg>`__.
-# The dataset will download as a file named *img_align_celeba.zip*. Once
-# downloaded, create a directory named *celeba* and extract the zip file
-# into that directory. Then, set the *dataroot* input for this notebook to
-# the *celeba* directory you just created. The resulting directory
+# The dataset will download as a file named ``img_align_celeba.zip``. Once
+# downloaded, create a directory named ``celeba`` and extract the zip file
+# into that directory. Then, set the ``dataroot`` input for this notebook to
+# the ``celeba`` directory you just created. The resulting directory
 # structure should be:
 # 
-# ::
+# .. code-block:: sh
 # 
 #    /path/to/celeba
 #        -> img_align_celeba  
@@ -237,9 +236,9 @@
 #            -> 537394.jpg
 #               ...
 # 
-# This is an important step because we will be using the ImageFolder
+# This is an important step because we will be using the ``ImageFolder``
 # dataset class, which requires there to be subdirectories in the
-# dataset’s root folder. Now, we can create the dataset, create the
+# dataset root folder. Now, we can create the dataset, create the
 # dataloader, set the device to run on, and finally visualize some of the
 # training data.
 # 
@@ -266,7 +265,7 @@
 plt.axis("off")
 plt.title("Training Images")
 plt.imshow(np.transpose(vutils.make_grid(real_batch[0].to(device)[:64], padding=2, normalize=True).cpu(),(1,2,0)))
-
+plt.show()
 
 
 ######################################################################
@@ -274,7 +273,7 @@
 # --------------
 # 
 # With our input parameters set and the dataset prepared, we can now get
-# into the implementation. We will start with the weigth initialization
+# into the implementation. We will start with the weight initialization
 # strategy, then talk about the generator, discriminator, loss functions,
 # and training loop in detail.
 # 
@@ -282,14 +281,14 @@
 # ~~~~~~~~~~~~~~~~~~~~~
 # 
 # From the DCGAN paper, the authors specify that all model weights shall
-# be randomly initialized from a Normal distribution with mean=0,
-# stdev=0.02. The ``weights_init`` function takes an initialized model as
+# be randomly initialized from a Normal distribution with ``mean=0``,
+# ``stdev=0.02``. The ``weights_init`` function takes an initialized model as
 # input and reinitializes all convolutional, convolutional-transpose, and
 # batch normalization layers to meet this criteria. This function is
 # applied to the models immediately after initialization.
 # 
 
-# custom weights initialization called on netG and netD
+# custom weights initialization called on ``netG`` and ``netD``
 def weights_init(m):
     classname = m.__class__.__name__
     if classname.find('Conv') != -1:
@@ -319,10 +318,10 @@ def weights_init(m):
 # .. figure:: /_static/img/dcgan_generator.png
 #    :alt: dcgan_generator
 #
-# Notice, the how the inputs we set in the input section (*nz*, *ngf*, and
-# *nc*) influence the generator architecture in code. *nz* is the length
-# of the z input vector, *ngf* relates to the size of the feature maps
-# that are propagated through the generator, and *nc* is the number of
+# Notice, how the inputs we set in the input section (``nz``, ``ngf``, and
+# ``nc``) influence the generator architecture in code. ``nz`` is the length
+# of the z input vector, ``ngf`` relates to the size of the feature maps
+# that are propagated through the generator, and ``nc`` is the number of
 # channels in the output image (set to 3 for RGB images). Below is the
 # code for the generator.
 # 
@@ -338,22 +337,22 @@ def __init__(self, ngpu):
             nn.ConvTranspose2d( nz, ngf * 8, 4, 1, 0, bias=False),
             nn.BatchNorm2d(ngf * 8),
             nn.ReLU(True),
-            # state size. (ngf*8) x 4 x 4
+            # state size. ``(ngf*8) x 4 x 4``
             nn.ConvTranspose2d(ngf * 8, ngf * 4, 4, 2, 1, bias=False),
             nn.BatchNorm2d(ngf * 4),
             nn.ReLU(True),
-            # state size. (ngf*4) x 8 x 8
+            # state size. ``(ngf*4) x 8 x 8``
             nn.ConvTranspose2d( ngf * 4, ngf * 2, 4, 2, 1, bias=False),
             nn.BatchNorm2d(ngf * 2),
             nn.ReLU(True),
-            # state size. (ngf*2) x 16 x 16
+            # state size. ``(ngf*2) x 16 x 16``
             nn.ConvTranspose2d( ngf * 2, ngf, 4, 2, 1, bias=False),
             nn.BatchNorm2d(ngf),
             nn.ReLU(True),
-            # state size. (ngf) x 32 x 32
+            # state size. ``(ngf) x 32 x 32``
             nn.ConvTranspose2d( ngf, nc, 4, 2, 1, bias=False),
             nn.Tanh()
-            # state size. (nc) x 64 x 64
+            # state size. ``(nc) x 64 x 64``
         )
 
     def forward(self, input):
@@ -369,12 +368,12 @@ def forward(self, input):
 # Create the generator
 netG = Generator(ngpu).to(device)
 
-# Handle multi-gpu if desired
+# Handle multi-GPU if desired
 if (device.type == 'cuda') and (ngpu > 1):
     netG = nn.DataParallel(netG, list(range(ngpu)))
 
-# Apply the weights_init function to randomly initialize all weights
-#  to mean=0, stdev=0.2.
+# Apply the ``weights_init`` function to randomly initialize all weights
+#  to ``mean=0``, ``stdev=0.02``.
 netG.apply(weights_init)
 
 # Print the model
@@ -408,22 +407,22 @@ def __init__(self, ngpu):
         super(Discriminator, self).__init__()
         self.ngpu = ngpu
         self.main = nn.Sequential(
-            # input is (nc) x 64 x 64
+            # input is ``(nc) x 64 x 64``
             nn.Conv2d(nc, ndf, 4, 2, 1, bias=False),
             nn.LeakyReLU(0.2, inplace=True),
-            # state size. (ndf) x 32 x 32
+            # state size. ``(ndf) x 32 x 32``
             nn.Conv2d(ndf, ndf * 2, 4, 2, 1, bias=False),
             nn.BatchNorm2d(ndf * 2),
             nn.LeakyReLU(0.2, inplace=True),
-            # state size. (ndf*2) x 16 x 16
+            # state size. ``(ndf*2) x 16 x 16``
             nn.Conv2d(ndf * 2, ndf * 4, 4, 2, 1, bias=False),
             nn.BatchNorm2d(ndf * 4),
             nn.LeakyReLU(0.2, inplace=True),
-            # state size. (ndf*4) x 8 x 8
+            # state size. ``(ndf*4) x 8 x 8``
             nn.Conv2d(ndf * 4, ndf * 8, 4, 2, 1, bias=False),
             nn.BatchNorm2d(ndf * 8),
             nn.LeakyReLU(0.2, inplace=True),
-            # state size. (ndf*8) x 4 x 4
+            # state size. ``(ndf*8) x 4 x 4``
             nn.Conv2d(ndf * 8, 1, 4, 1, 0, bias=False),
             nn.Sigmoid()
         )
@@ -440,12 +439,12 @@ def forward(self, input):
 # Create the Discriminator
 netD = Discriminator(ngpu).to(device)
 
-# Handle multi-gpu if desired
+# Handle multi-GPU if desired
 if (device.type == 'cuda') and (ngpu > 1):
     netD = nn.DataParallel(netD, list(range(ngpu)))
     
-# Apply the weights_init function to randomly initialize all weights
-#  to mean=0, stdev=0.2.
+# Apply the ``weights_init`` function to randomly initialize all weights
+# like this: ``to mean=0, stdev=0.2``.
 netD.apply(weights_init)
 
 # Print the model
@@ -459,7 +458,7 @@ def forward(self, input):
 # With :math:`D` and :math:`G` setup, we can specify how they learn
 # through the loss functions and optimizers. We will use the Binary Cross
 # Entropy loss
-# (`BCELoss <https://pytorch.org/docs/stable/nn.html#torch.nn.BCELoss>`__)
+# (`BCELoss <https://pytorch.org/docs/stable/generated/torch.nn.BCELoss.html#torch.nn.BCELoss>`__)
 # function which is defined in PyTorch as:
 # 
 # .. math:: \ell(x, y) = L = \{l_1,\dots,l_N\}^\top, \quad l_n = - \left[ y_n \cdot \log x_n + (1 - y_n) \cdot \log (1 - x_n) \right]
@@ -485,7 +484,7 @@ def forward(self, input):
 # images form out of the noise.
 # 
 
-# Initialize BCELoss function
+# Initialize the ``BCELoss`` function
 criterion = nn.BCELoss()
 
 # Create batch of latent vectors that we will use to visualize
@@ -493,8 +492,8 @@ def forward(self, input):
 fixed_noise = torch.randn(64, nz, 1, 1, device=device)
 
 # Establish convention for real and fake labels during training
-real_label = 1
-fake_label = 0
+real_label = 1.
+fake_label = 0.
 
 # Setup Adam optimizers for both G and D
 optimizerD = optim.Adam(netD.parameters(), lr=lr, betas=(beta1, 0.999))
@@ -509,11 +508,12 @@ def forward(self, input):
 # we can train it. Be mindful that training GANs is somewhat of an art
 # form, as incorrect hyperparameter settings lead to mode collapse with
 # little explanation of what went wrong. Here, we will closely follow
-# Algorithm 1 from Goodfellow’s paper, while abiding by some of the best
+# Algorithm 1 from the `Goodfellow’s paper <https://papers.nips.cc/paper/5423-generative-adversarial-nets.pdf>`__, 
+# while abiding by some of the best
 # practices shown in `ganhacks <https://github.com/soumith/ganhacks>`__.
 # Namely, we will “construct different mini-batches for real and fake”
 # images, and also adjust G’s objective function to maximize
-# :math:`logD(G(z))`. Training is split up into two main parts. Part 1
+# :math:`log(D(G(z)))`. Training is split up into two main parts. Part 1
 # updates the Discriminator and Part 2 updates the Generator.
 # 
 # **Part 1 - Train the Discriminator**
@@ -523,7 +523,8 @@ def forward(self, input):
 # terms of Goodfellow, we wish to “update the discriminator by ascending
 # its stochastic gradient”. Practically, we want to maximize
 # :math:`log(D(x)) + log(1-D(G(z)))`. Due to the separate mini-batch
-# suggestion from ganhacks, we will calculate this in two steps. First, we
+# suggestion from `ganhacks <https://github.com/soumith/ganhacks>`__,
+# we will calculate this in two steps. First, we
 # will construct a batch of real samples from the training set, forward
 # pass through :math:`D`, calculate the loss (:math:`log(D(x))`), then
 # calculate the gradients in a backward pass. Secondly, we will construct
@@ -545,7 +546,7 @@ def forward(self, input):
 # G’s gradients in a backward pass, and finally updating G’s parameters
 # with an optimizer step. It may seem counter-intuitive to use the real
 # labels as GT labels for the loss function, but this allows us to use the
-# :math:`log(x)` part of the BCELoss (rather than the :math:`log(1-x)`
+# :math:`log(x)` part of the ``BCELoss`` (rather than the :math:`log(1-x)`
 # part) which is exactly what we want.
 # 
 # Finally, we will do some statistic reporting and at the end of each
@@ -554,7 +555,7 @@ def forward(self, input):
 # reported are:
 # 
 # -  **Loss_D** - discriminator loss calculated as the sum of losses for
-#    the all real and all fake batches (:math:`log(D(x)) + log(D(G(z)))`).
+#    the all real and all fake batches (:math:`log(D(x)) + log(1 - D(G(z)))`).
 # -  **Loss_G** - generator loss calculated as :math:`log(D(G(z)))`
 # -  **D(x)** - the average output (across the batch) of the discriminator
 #    for the all real batch. This should start close to 1 then
@@ -591,7 +592,7 @@ def forward(self, input):
         # Format batch
         real_cpu = data[0].to(device)
         b_size = real_cpu.size(0)
-        label = torch.full((b_size,), real_label, device=device)
+        label = torch.full((b_size,), real_label, dtype=torch.float, device=device)
         # Forward pass real batch through D
         output = netD(real_cpu).view(-1)
         # Calculate loss on all-real batch
@@ -610,10 +611,10 @@ def forward(self, input):
         output = netD(fake.detach()).view(-1)
         # Calculate D's loss on the all-fake batch
         errD_fake = criterion(output, label)
-        # Calculate the gradients for this batch
+        # Calculate the gradients for this batch, accumulated (summed) with previous gradients
         errD_fake.backward()
         D_G_z1 = output.mean().item()
-        # Add the gradients from the all-real and all-fake batches
+        # Compute error of D as sum over the fake and the real batches
         errD = errD_real + errD_fake
         # Update D
         optimizerD.step()
@@ -733,6 +734,6 @@ def forward(self, input):
 # -  Check out some other cool GAN projects
 #    `here <https://github.com/nashory/gans-awesome-applications>`__
 # -  Create GANs that generate
-#    `music <https://deepmind.com/blog/wavenet-generative-model-raw-audio/>`__
+#    `music <https://www.deepmind.com/blog/wavenet-a-generative-model-for-raw-audio/>`__
 # 
 
diff --git a/beginner_source/ddp_series_fault_tolerance.rst b/beginner_source/ddp_series_fault_tolerance.rst
new file mode 100644
index 00000000000..27fe7e273e7
--- /dev/null
+++ b/beginner_source/ddp_series_fault_tolerance.rst
@@ -0,0 +1,212 @@
+`Introduction <ddp_series_intro.html>`__ \|\|
+`What is DDP <ddp_series_theory.html>`__ \|\|
+`Single-Node Multi-GPU Training <ddp_series_multigpu.html>`__ \|\|
+**Fault Tolerance** \|\|
+`Multi-Node training <../intermediate/ddp_series_multinode.html>`__ \|\|
+`minGPT Training <../intermediate/ddp_series_minGPT.html>`__
+
+
+Fault-tolerant Distributed Training with ``torchrun``
+=====================================================
+
+Authors: `Suraj Subramanian <https://github.com/subramen>`__
+
+.. grid:: 2
+
+   .. grid-item-card:: :octicon:`mortar-board;1em;` What you will learn
+      :class-card: card-prerequisites
+      :margin: 0
+      
+      - Launching multi-GPU training jobs with ``torchrun``
+      - Saving and loading snapshots of your training job
+      - Structuring your training script for graceful restarts
+
+      .. 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_torchrun.py>`__
+
+   .. grid-item-card:: :octicon:`list-unordered;1em;` Prerequisites
+      :class-card: card-prerequisites
+      :margin: 0
+
+      * High-level `overview <ddp_series_theory.html>`__ of DDP
+      * Familiarity with `DDP code <ddp_series_multigpu.html>`__
+      * A machine with multiple GPUs (this tutorial uses an AWS p3.8xlarge instance)
+      * PyTorch `installed <https://pytorch.org/get-started/locally/>`__ with CUDA
+
+Follow along with the video below or on `youtube <https://www.youtube.com/watch/9kIvQOiwYzg>`__.
+
+.. raw:: html
+
+   <div style="margin-top:10px; margin-bottom:10px;">
+     <iframe width="560" height="315" src="https://www.youtube.com/embed/9kIvQOiwYzg" frameborder="0" allow="accelerometer; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
+   </div>
+
+In distributed training, a single process failure can
+disrupt the entire training job. Since the susceptibility for failure can be higher here, making your training
+script robust is particularly important here. You might also prefer your training job to be *elastic*, for example,
+compute resources can join and leave dynamically over the course of the job.
+
+PyTorch offers a utility called ``torchrun`` that provides fault-tolerance and 
+elastic training. When a failure occurs, ``torchrun`` logs the errors and
+attempts to automatically restart all the processes from the last saved
+“snapshot” of the training job. 
+
+The snapshot saves more than just the model state; it can include
+details about the number of epochs run, optimizer states or any other
+stateful attribute of the training job necessary for its continuity.
+
+Why use ``torchrun``
+~~~~~~~~~~~~~~~~~~~~
+
+``torchrun`` handles the minutiae of distributed training so that you
+don't need to. For instance,
+
+-  You don't need to set environment variables or explicitly pass the ``rank`` and ``world_size``; ``torchrun`` assigns this along with several other `environment variables <https://pytorch.org/docs/stable/elastic/run.html#environment-variables>`__.
+-  No need to call ``mp.spawn`` in your script; you only need a generic ``main()`` entry point, and launch the script with ``torchrun``. This way the same script can be run in non-distributed as well as single-node and multinode setups.
+-  Gracefully restarting training from the last saved training snapshot.
+
+
+Graceful restarts
+~~~~~~~~~~~~~~~~~~~~~
+For graceful restarts, you should structure your train script like:
+
+.. code:: python
+
+   def main():
+     load_snapshot(snapshot_path)
+     initialize()
+     train()
+
+   def train():
+     for batch in iter(dataset):
+       train_step(batch)
+
+       if should_checkpoint:
+         save_snapshot(snapshot_path)
+
+If a failure occurs, ``torchrun`` will terminate all the processes and restart them. 
+Each process entry point first loads and initializes the last saved snapshot, and continues training from there.
+So at any failure, you only lose the training progress from the last saved snapshot. 
+
+In elastic training, whenever there are any membership changes (adding or removing nodes), ``torchrun`` will terminate and spawn processes
+on available devices. Having this structure ensures your training job can continue without manual intervention.
+
+
+Diff for `multigpu.py <https://github.com/pytorch/examples/blob/main/distributed/ddp-tutorial-series/multigpu.py>`__ v/s `multigpu_torchrun.py <https://github.com/pytorch/examples/blob/main/distributed/ddp-tutorial-series/multigpu_torchrun.py>`__
+
+Process group initialization
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+-  ``torchrun`` assigns ``RANK`` and ``WORLD_SIZE`` automatically,
+   among `other envvariables <https://pytorch.org/docs/stable/elastic/run.html#environment-variables>`__
+
+.. code-block:: diff
+
+    - def ddp_setup(rank, world_size):
+    + def ddp_setup():
+    -     """
+    -     Args:
+    -         rank: Unique identifier of each process
+    -         world_size: Total number of processes
+    -     """
+    -     os.environ["MASTER_ADDR"] = "localhost"
+    -     os.environ["MASTER_PORT"] = "12355"
+    -     init_process_group(backend="nccl", rank=rank, world_size=world_size)
+    +     init_process_group(backend="nccl")
+         torch.cuda.set_device(int(os.environ["LOCAL_RANK"]))
+
+Use torchrun-provided environment variables
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. code-block:: diff
+
+    - self.gpu_id = gpu_id
+    + self.gpu_id = int(os.environ["LOCAL_RANK"])
+
+Saving and loading snapshots
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Regularly storing all the relevant information in snapshots allows our
+training job to seamlessly resume after an interruption.
+
+.. code-block:: diff
+
+    + def _save_snapshot(self, epoch):
+    +     snapshot = {}
+    +     snapshot["MODEL_STATE"] = self.model.module.state_dict()
+    +     snapshot["EPOCHS_RUN"] = epoch
+    +     torch.save(snapshot, "snapshot.pt")
+    +     print(f"Epoch {epoch} | Training snapshot saved at snapshot.pt")
+
+    + def _load_snapshot(self, snapshot_path):
+    +     snapshot = torch.load(snapshot_path)
+    +     self.model.load_state_dict(snapshot["MODEL_STATE"])
+    +     self.epochs_run = snapshot["EPOCHS_RUN"]
+    +     print(f"Resuming training from snapshot at Epoch {self.epochs_run}")
+
+
+Loading a snapshot in the Trainer constructor
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+When restarting an interrupted training job, your script will first try
+to load a snapshot to resume training from.
+
+.. code-block:: diff
+
+    class Trainer:
+       def __init__(self, snapshot_path, ...):
+       ...
+    +  if os.path.exists(snapshot_path):
+    +     self._load_snapshot(snapshot_path)
+       ...
+
+
+Resuming training
+~~~~~~~~~~~~~~~~~
+
+Training can resume from the last epoch run, instead of starting all
+over from scratch.
+
+.. code-block:: diff
+
+    def train(self, max_epochs: int):
+    -  for epoch in range(max_epochs):
+    +  for epoch in range(self.epochs_run, max_epochs):
+          self._run_epoch(epoch)
+
+
+Running the script
+~~~~~~~~~~~~~~~~~~
+
+Simply call your entry point function as you would for a non-multiprocessing script; ``torchrun`` automatically
+spawns the processes.
+
+.. code-block:: diff
+
+    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)
+    +  main(save_every, total_epochs)
+
+
+.. code-block:: diff
+
+    - python multigpu.py 50 10
+    + torchrun --standalone --nproc_per_node=4 multigpu_torchrun.py 50 10
+
+Further Reading
+---------------
+
+-  `Multi-Node training with DDP <../intermediate/ddp_series_multinode.html>`__  (next tutorial in this series)
+-  `Multi-GPU Training with DDP <ddp_series_multigpu.html>`__ (previous tutorial in this series)
+-  `torchrun <https://pytorch.org/docs/stable/elastic/run.html>`__
+-  `Torchrun launch
+   options <https://github.com/pytorch/pytorch/blob/bbe803cb35948df77b46a2d38372910c96693dcd/torch/distributed/run.py#L401>`__
+-  `Migrating from torch.distributed.launch to
+   torchrun <https://pytorch.org/docs/stable/elastic/train_script.html#elastic-train-script>`__
diff --git a/beginner_source/ddp_series_intro.rst b/beginner_source/ddp_series_intro.rst
new file mode 100644
index 00000000000..9aee5d8a5df
--- /dev/null
+++ b/beginner_source/ddp_series_intro.rst
@@ -0,0 +1,56 @@
+**Introduction** \|\| `What is DDP <ddp_series_theory.html>`__ \|\|
+`Single-Node Multi-GPU Training <ddp_series_multigpu.html>`__ \|\|
+`Fault Tolerance <ddp_series_fault_tolerance.html>`__ \|\|
+`Multi-Node training <../intermediate/ddp_series_multinode.html>`__ \|\|
+`minGPT Training <../intermediate/ddp_series_minGPT.html>`__
+
+Distributed Data Parallel in PyTorch - Video Tutorials
+======================================================
+
+Authors: `Suraj Subramanian <https://github.com/subramen>`__
+
+Follow along with the video below or on `youtube <https://www.youtube.com/watch/-K3bZYHYHEA>`__.
+
+.. raw:: html
+
+   <div style="margin-top:10px; margin-bottom:10px;">
+     <iframe width="560" height="315" src="https://www.youtube.com/embed/-K3bZYHYHEA" frameborder="0" allow="accelerometer; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
+   </div>
+
+This series of video tutorials walks you through distributed training in
+PyTorch via DDP.
+
+The series starts with a simple non-distributed training job, and ends
+with deploying a training job across several machines in a cluster.
+Along the way, you will also learn about
+`torchrun <https://pytorch.org/docs/stable/elastic/run.html>`__ for
+fault-tolerant distributed training.
+
+The tutorial assumes a basic familiarity with model training in PyTorch.
+
+Running the code
+----------------
+
+You will need multiple CUDA GPUs to run the tutorial code. Typically,
+this can be done on a cloud instance with multiple GPUs (the tutorials
+use an Amazon EC2 P3 instance with 4 GPUs).
+
+The tutorial code is hosted in this
+`github repo <https://github.com/pytorch/examples/tree/main/distributed/ddp-tutorial-series>`__.
+Clone the repository and follow along!
+
+Tutorial sections
+-----------------
+
+0. Introduction (this page)
+1. `What is DDP? <ddp_series_theory.html>`__ Gently introduces what DDP is doing
+   under the hood
+2. `Single-Node Multi-GPU Training <ddp_series_multigpu.html>`__ Training models
+   using multiple GPUs on a single machine
+3. `Fault-tolerant distributed training <ddp_series_fault_tolerance.html>`__
+   Making your distributed training job robust with torchrun
+4. `Multi-Node training <../intermediate/ddp_series_multinode.html>`__ Training models using
+   multiple GPUs on multiple machines
+5. `Training a GPT model with DDP <../intermediate/ddp_series_minGPT.html>`__ “Real-world”
+   example of training a `minGPT <https://github.com/karpathy/minGPT>`__
+   model with DDP
diff --git a/beginner_source/ddp_series_multigpu.rst b/beginner_source/ddp_series_multigpu.rst
new file mode 100644
index 00000000000..ef6549d4de0
--- /dev/null
+++ b/beginner_source/ddp_series_multigpu.rst
@@ -0,0 +1,229 @@
+`Introduction <ddp_series_intro.html>`__ \|\|
+`What is DDP <ddp_series_theory.html>`__ \|\|
+**Single-Node Multi-GPU Training** \|\|
+`Fault Tolerance <ddp_series_fault_tolerance.html>`__ \|\|
+`Multi-Node training <../intermediate/ddp_series_multinode.html>`__ \|\|
+`minGPT Training <../intermediate/ddp_series_minGPT.html>`__
+
+
+Multi GPU training with DDP
+===========================
+
+Authors: `Suraj Subramanian <https://github.com/subramen>`__
+
+.. grid:: 2
+
+   .. grid-item-card:: :octicon:`mortar-board;1em;` What you will learn
+      :class-card: card-prerequisites
+
+      -  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
+
+      * High-level overview of `how DDP works  <ddp_series_theory.html>`__
+      * A machine with multiple GPUs (this tutorial uses an AWS p3.8xlarge instance)
+      * PyTorch `installed <https://pytorch.org/get-started/locally/>`__ with CUDA
+
+Follow along with the video below or on `youtube <https://www.youtube.com/watch/-LAtx9Q6DA8>`__.
+
+.. raw:: html
+
+   <div style="margin-top:10px; margin-bottom:10px;">
+     <iframe width="560" height="315" src="https://www.youtube.com/embed/-LAtx9Q6DA8" frameborder="0" allow="accelerometer; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
+   </div>
+
+In the `previous tutorial <ddp_series_theory.html>`__, we got a high-level overview of how DDP works; now we see how to use DDP in code.
+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::
+   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
+   `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``.
+
+
+Diff for `single_gpu.py <https://github.com/pytorch/examples/blob/main/distributed/ddp-tutorial-series/single_gpu.py>`__ v/s `multigpu.py <https://github.com/pytorch/examples/blob/main/distributed/ddp-tutorial-series/multigpu.py>`__
+
+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:: python
+
+   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
+
+
+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`
+-  The process group can be initialized by TCP (default) or from a
+   shared file-system. Read more on `process group
+   initialization <https://pytorch.org/docs/stable/distributed.html#tcp-initialization>`__
+-  `init_process_group <https://pytorch.org/docs/stable/distributed.html?highlight=init_process_group#torch.distributed.init_process_group>`__
+   initializes the distributed process group.
+-  Read more about `choosing a DDP
+   backend <https://pytorch.org/docs/stable/distributed.html#which-backend-to-use>`__
+
+.. 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)
+
+
+
+Constructing the DDP model
+--------------------------
+
+.. code-block:: python
+
+   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:: python
+
+    train_data = torch.utils.data.DataLoader(
+        dataset=train_dataset,
+        batch_size=32,
+        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
+   properly across multiple epochs. Otherwise, the same ordering will be used in each epoch.
+
+.. code-block:: python
+
+    def _run_epoch(self, epoch):
+        b_sz = len(next(iter(self.train_data))[0])
+        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
+   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>`__
+
+.. code-block:: diff
+
+    - ckp = self.model.state_dict()
+    + ckp = self.model.module.state_dict()
+    ...
+    ...
+    - if epoch % self.save_every == 0:
+    + if self.gpu_id == 0 and epoch % self.save_every == 0:
+      self._save_checkpoint(epoch)
+
+.. 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.
+   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,
+   this corresponds to the number of GPUs in use, and each process works on a dedicated GPU.
+
+.. code-block:: diff
+
+   - def main(device, total_epochs, save_every):
+   + 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, device, save_every)
+   +  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])
+   -  device = 0      # shorthand for cuda:0
+   -  main(device, total_epochs, save_every)
+   +  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
+---------------
+
+-  `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>`__
+-  `Process Group
+   Initialization <https://pytorch.org/docs/stable/distributed.html#tcp-initialization>`__
diff --git a/beginner_source/ddp_series_theory.rst b/beginner_source/ddp_series_theory.rst
new file mode 100644
index 00000000000..ade98d9f01c
--- /dev/null
+++ b/beginner_source/ddp_series_theory.rst
@@ -0,0 +1,74 @@
+`Introduction <ddp_series_intro.html>`__ \|\| **What is DDP** \|\|
+`Single-Node Multi-GPU Training <ddp_series_multigpu.html>`__ \|\|
+`Fault Tolerance <ddp_series_fault_tolerance.html>`__ \|\|
+`Multi-Node training <../intermediate/ddp_series_multinode.html>`__ \|\|
+`minGPT Training <../intermediate/ddp_series_minGPT.html>`__
+
+What is Distributed Data Parallel (DDP)
+=======================================
+
+Authors: `Suraj Subramanian <https://github.com/subramen>`__
+
+.. grid:: 2
+
+   .. grid-item-card:: :octicon:`mortar-board;1em;` What you will learn
+      :class-card: card-prerequisites
+
+      *  How DDP works under the hood
+      *  What is ``DistributedSampler``
+      *  How gradients are synchronized across GPUs
+
+
+   .. grid-item-card:: :octicon:`list-unordered;1em;` Prerequisites
+      :class-card: card-prerequisites
+
+      * Familiarity with `basic non-distributed training  <https://pytorch.org/tutorials/beginner/basics/quickstart_tutorial.html>`__ in PyTorch
+
+Follow along with the video below or on `youtube <https://www.youtube.com/watch/Cvdhwx-OBBo>`__.
+
+.. raw:: html
+
+   <div style="margin-top:10px; margin-bottom:10px;">
+     <iframe width="560" height="315" src="https://www.youtube.com/embed/Cvdhwx-OBBo" frameborder="0" allow="accelerometer; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
+   </div>
+
+This tutorial is a gentle introduction to PyTorch `DistributedDataParallel <https://pytorch.org/docs/stable/generated/torch.nn.parallel.DistributedDataParallel.html>`__ (DDP)
+which enables data parallel training in PyTorch. Data parallelism is a way to
+process multiple data batches across multiple devices simultaneously
+to achieve better performance. In PyTorch, the `DistributedSampler <https://pytorch.org/docs/stable/data.html#torch.utils.data.distributed.DistributedSampler>`__
+ensures each device gets a non-overlapping input batch. The model is replicated on all the devices;
+each replica calculates gradients and simultaneously synchronizes with the others using the `ring all-reduce
+algorithm <https://tech.preferred.jp/en/blog/technologies-behind-distributed-deep-learning-allreduce/>`__.
+
+This `illustrative tutorial <https://pytorch.org/tutorials/intermediate/dist_tuto.html#>`__ provides a more in-depth python view of the mechanics of DDP.
+
+Why you should prefer DDP over ``DataParallel`` (DP)
+----------------------------------------------------
+
+`DataParallel <https://pytorch.org/docs/stable/generated/torch.nn.DataParallel.html>`__ 
+is an older approach to data parallelism. DP is trivially simple (with just one extra line of code) but it is much less performant.
+DDP improves upon the architecture in a few ways:
+
++---------------------------------------+------------------------------+
+| ``DataParallel``                      | ``DistributedDataParallel``  |
++=======================================+==============================+
+| More overhead; model is replicated    | Model is replicated only     |
+| and destroyed at each forward pass    | once                         |
++---------------------------------------+------------------------------+
+| Only supports single-node parallelism | Supports scaling to multiple |
+|                                       | machines                     |
++---------------------------------------+------------------------------+
+| Slower; uses multithreading on a      | Faster (no GIL contention)   |
+| single process and runs into Global   | because it uses              |
+| Interpreter Lock (GIL) contention     | multiprocessing              |
++---------------------------------------+------------------------------+
+
+Further Reading
+---------------
+
+-  `Multi-GPU training with DDP <ddp_series_multigpu.html>`__ (next tutorial in this series)
+-  `DDP
+   API <https://pytorch.org/docs/stable/generated/torch.nn.parallel.DistributedDataParallel.html>`__
+-  `DDP Internal
+   Design <https://pytorch.org/docs/master/notes/ddp.html#internal-design>`__
+-  `DDP Mechanics Tutorial <https://pytorch.org/tutorials/intermediate/dist_tuto.html#>`__
diff --git a/beginner_source/deep_learning_60min_blitz.rst b/beginner_source/deep_learning_60min_blitz.rst
index 1ed208d9b59..6c96c403455 100644
--- a/beginner_source/deep_learning_60min_blitz.rst
+++ b/beginner_source/deep_learning_60min_blitz.rst
@@ -2,20 +2,30 @@ Deep Learning with PyTorch: A 60 Minute Blitz
 ---------------------------------------------
 **Author**: `Soumith Chintala <http://soumith.ch>`_
 
-Goal of this tutorial:
+.. raw:: html
+
+   <div style="margin-top:10px; margin-bottom:10px;">
+     <iframe width="560" height="315" src="https://www.youtube.com/embed/u7x8RXwLKcA" frameborder="0" allow="accelerometer; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
+   </div>
 
--  Understand PyTorch’s Tensor library and neural networks at a high
-   level.
--  Train a small neural network to classify images
+What is PyTorch?
+~~~~~~~~~~~~~~~~~~~~~
+PyTorch is a Python-based scientific computing package serving two broad purposes:
 
-*This tutorial assumes that you have a basic familiarity of numpy*
+-  A replacement for NumPy to use the power of GPUs and other accelerators.
+-  An automatic differentiation library that is useful to implement neural networks.
+
+Goal of this tutorial:
+~~~~~~~~~~~~~~~~~~~~~~~~
+- Understand PyTorch’s Tensor library and neural networks at a high level.
+- Train a small neural network to classify images
 
-.. Note::
-    Make sure you have the `torch`_ and `torchvision`_ packages installed.
+To run the tutorials below, make sure you have the `torch`_, `torchvision`_,
+and `matplotlib`_ packages installed.
 
 .. _torch: https://github.com/pytorch/pytorch
 .. _torchvision: https://github.com/pytorch/vision
-
+.. _matplotlib: https://github.com/matplotlib/matplotlib
 
 .. toctree::
    :hidden:
@@ -24,23 +34,34 @@ Goal of this tutorial:
    /beginner/blitz/autograd_tutorial
    /beginner/blitz/neural_networks_tutorial
    /beginner/blitz/cifar10_tutorial
-   /beginner/blitz/data_parallel_tutorial
 
-.. galleryitem:: /beginner/blitz/tensor_tutorial.py
-    :figure: /_static/img/tensor_illustration_flat.png
+.. grid:: 4
 
-.. galleryitem:: /beginner/blitz/autograd_tutorial.py
-    :figure: /_static/img/autodiff.png
+   .. grid-item-card::  :octicon:`file-code;1em` Tensors
+      :link: blitz/tensor_tutorial.html
 
-.. galleryitem:: /beginner/blitz/neural_networks_tutorial.py
-    :figure: /_static/img/mnist.png
+      In this tutorial, you will learn the basics of PyTorch tensors.
+      +++
+      :octicon:`code;1em` Code
 
-.. galleryitem:: /beginner/blitz/cifar10_tutorial.py
-    :figure: /_static/img/cifar10.png
+   .. grid-item-card::  :octicon:`file-code;1em` A Gentle Introduction to torch.autograd
+      :link: blitz/autograd_tutorial.html
 
-.. galleryitem:: /beginner/blitz/data_parallel_tutorial.py
-    :figure: /_static/img/data_parallel.png
+      Learn about autograd.
+      +++
+      :octicon:`code;1em` Code
 
-.. raw:: html
+   .. grid-item-card::  :octicon:`file-code;1em` Neural Networks
+      :link: blitz/neural_networks_tutorial.html
+
+      This tutorial demonstrates how you can train neural networks in PyTorch.
+      +++
+      :octicon:`code;1em` Code
+
+   .. grid-item-card::  :octicon:`file-code;1em` Training a Classifier
+      :link: blitz/cifar10_tutorial.html
 
-    <div style='clear:both'></div>
+      Learn how to train an image classifier in PyTorch by using the
+      CIFAR10 dataset.
+      +++
+      :octicon:`code;1em` Code
diff --git a/beginner_source/deep_learning_nlp_tutorial.rst b/beginner_source/deep_learning_nlp_tutorial.rst
deleted file mode 100644
index 1d65ad18dcd..00000000000
--- a/beginner_source/deep_learning_nlp_tutorial.rst
+++ /dev/null
@@ -1,56 +0,0 @@
-Deep Learning for NLP with Pytorch
-**********************************
-**Author**: `Robert Guthrie <https://github.com/rguthrie3/DeepLearningForNLPInPytorch>`_
-
-This tutorial will walk you through the key ideas of deep learning
-programming using Pytorch. Many of the concepts (such as the computation
-graph abstraction and autograd) are not unique to Pytorch and are
-relevant to any deep learning toolkit out there.
-
-I am writing this tutorial to focus specifically on NLP for people who
-have never written code in any deep learning framework (e.g, TensorFlow,
-Theano, Keras, Dynet). It assumes working knowledge of core NLP
-problems: part-of-speech tagging, language modeling, etc. It also
-assumes familiarity with neural networks at the level of an intro AI
-class (such as one from the Russel and Norvig book). Usually, these
-courses cover the basic backpropagation algorithm on feed-forward neural
-networks, and make the point that they are chains of compositions of
-linearities and non-linearities. This tutorial aims to get you started
-writing deep learning code, given you have this prerequisite knowledge.
-
-Note this is about *models*, not data. For all of the models, I just
-create a few test examples with small dimensionality so you can see how
-the weights change as it trains. If you have some real data you want to
-try, you should be able to rip out any of the models from this notebook
-and use them on it.
-
-
-.. toctree::
-    :hidden:
-
-    /beginner/nlp/pytorch_tutorial
-    /beginner/nlp/deep_learning_tutorial
-    /beginner/nlp/word_embeddings_tutorial
-    /beginner/nlp/sequence_models_tutorial
-    /beginner/nlp/advanced_tutorial
-
-
-.. galleryitem:: /beginner/nlp/pytorch_tutorial.py
-    :intro: All of deep learning is computations on tensors, which are generalizations of a matrix that can be
-
-.. galleryitem:: /beginner/nlp/deep_learning_tutorial.py
-    :intro: Deep learning consists of composing linearities with non-linearities in clever ways. The introduction of non-linearities allows
-
-.. galleryitem:: /beginner/nlp/word_embeddings_tutorial.py
-    :intro: Word embeddings are dense vectors of real numbers, one per word in your vocabulary. In NLP, it is almost always the case that your features are
-
-.. galleryitem:: /beginner/nlp/sequence_models_tutorial.py
-    :intro: At this point, we have seen various feed-forward networks. That is, there is no state maintained by the network at all.
-
-.. galleryitem:: /beginner/nlp/advanced_tutorial.py
-    :intro: Dynamic versus Static Deep Learning Toolkits. Pytorch is a *dynamic* neural network kit.
-
-
-.. raw:: html
-
-    <div style='clear:both'></div>
diff --git a/beginner_source/deeplabv3_on_android.rst b/beginner_source/deeplabv3_on_android.rst
new file mode 100644
index 00000000000..7ec83477373
--- /dev/null
+++ b/beginner_source/deeplabv3_on_android.rst
@@ -0,0 +1,10 @@
+Image Segmentation DeepLabV3 on Android
+=================================================
+
+PyTorch Mobile is no longer actively supported. Please check out `ExecuTorch <https://github.com/pytorch/executorch>`__.
+
+Redirecting in 3 seconds...
+
+.. raw:: html
+
+    <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
new file mode 100644
index 00000000000..66c052419fc
--- /dev/null
+++ b/beginner_source/deeplabv3_on_ios.rst
@@ -0,0 +1,10 @@
+Image Segmentation DeepLabV3 on iOS
+==============================================
+
+PyTorch Mobile is no longer actively supported. Please check out `ExecuTorch <https://github.com/pytorch/executorch>`__.
+
+Redirecting in 3 seconds...
+
+.. raw:: html
+
+    <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
deleted file mode 100644
index c8273b24d7b..00000000000
--- a/beginner_source/deploy_seq2seq_hybrid_frontend_tutorial.py
+++ /dev/null
@@ -1,878 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-Deploying a Seq2Seq Model with the Hybrid Frontend
-==================================================
-**Author:** `Matthew Inkawhich <https://github.com/MatthewInkawhich>`_
-"""
-
-
-######################################################################
-# This tutorial will walk through the process of transitioning a
-# sequence-to-sequence model to Torch Script using PyTorch’s Hybrid
-# Frontend. The model that we will convert is the chatbot model from the
-# `Chatbot tutorial <https://pytorch.org/tutorials/beginner/chatbot_tutorial.html>`__. 
-# You can either treat this tutorial as a “Part 2” to the Chatbot tutorial
-# and deploy your own pretrained model, or you can start with this
-# document and use a pretrained model that we host. In the latter case,
-# you can reference the original Chatbot tutorial for details
-# regarding data preprocessing, model theory and definition, and model
-# training.
-#
-# What is the Hybrid Frontend?
-# ----------------------------
-#
-# During the research and development phase of a deep learning-based
-# project, it is advantageous to interact with an **eager**, imperative
-# interface like PyTorch’s. This gives users the ability to write
-# familiar, idiomatic Python, allowing for the use of Python data
-# structures, control flow operations, print statements, and debugging
-# utilities. Although the eager interface is a beneficial tool for
-# research and experimentation applications, when it comes time to deploy
-# the model in a production environment, having a **graph**-based model
-# representation is very beneficial. A deferred graph representation
-# allows for optimizations such as out-of-order execution, and the ability
-# to target highly optimized hardware architectures. Also, a graph-based
-# representation enables framework-agnostic model exportation. PyTorch
-# provides mechanisms for incrementally converting eager-mode code into
-# Torch Script, a statically analyzable and optimizable subset of Python
-# that Torch uses to represent deep learning programs independently from
-# the Python runtime.
-#
-# The API for converting eager-mode PyTorch programs into Torch Script is
-# found in the torch.jit module. This module has two core modalities for
-# converting an eager-mode model to a Torch Script graph representation:
-# **tracing** and **scripting**. The ``torch.jit.trace`` function takes a
-# module or function and a set of example inputs. It then runs the example
-# input through the function or module while tracing the computational
-# steps that are encountered, and outputs a graph-based function that
-# performs the traced operations. **Tracing** is great for straightforward
-# modules and functions that do not involve data-dependent control flow,
-# such as standard convolutional neural networks. However, if a function
-# with data-dependent if statements and loops is traced, only the
-# operations called along the execution route taken by the example input
-# will be recorded. In other words, the control flow itself is not
-# captured. To convert modules and functions containing data-dependent
-# control flow, a **scripting** mechanism is provided. Scripting
-# explicitly converts the module or function code to Torch Script,
-# including all possible control flow routes. To use script mode, be sure
-# to inherit from the the ``torch.jit.ScriptModule`` base class (instead
-# of ``torch.nn.Module``) and add a ``torch.jit.script`` decorator to your
-# Python function or a ``torch.jit.script_method`` decorator to your
-# module’s methods. The one caveat with using scripting is that it only
-# supports a restricted subset of Python. For all details relating to the
-# supported features, see the Torch Script `language
-# reference <https://pytorch.org/docs/master/jit.html>`__. To provide the
-# maximum flexibility, the modes of Torch Script can be composed to
-# represent your whole program, and these techniques can be applied
-# incrementally.
-#
-# .. figure:: /_static/img/chatbot/pytorch_workflow.png
-#    :align: center
-#    :alt: workflow
-#
-
-
-
-######################################################################
-# Acknowledgements
-# ----------------
-#
-# This tutorial was inspired by the following sources:
-#
-# 1) Yuan-Kuei Wu’s pytorch-chatbot implementation:
-#    https://github.com/ywk991112/pytorch-chatbot
-#
-# 2) Sean Robertson’s practical-pytorch seq2seq-translation example:
-#    https://github.com/spro/practical-pytorch/tree/master/seq2seq-translation
-#
-# 3) FloydHub’s Cornell Movie Corpus preprocessing code:
-#    https://github.com/floydhub/textutil-preprocess-cornell-movie-corpus
-#
-
-
-######################################################################
-# Prepare Environment
-# -------------------
-#
-# First, we will import the required modules and set some constants. If
-# you are planning on using your own model, be sure that the
-# ``MAX_LENGTH`` constant is set correctly. As a reminder, this constant
-# defines the maximum allowed sentence length during training and the
-# maximum length output that the model is capable of producing.
-#
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-from __future__ import unicode_literals
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-import re
-import os
-import unicodedata
-import numpy as np
-
-device = torch.device("cpu")
-
-
-MAX_LENGTH = 10  # Maximum sentence length
-
-# Default word tokens
-PAD_token = 0  # Used for padding short sentences
-SOS_token = 1  # Start-of-sentence token
-EOS_token = 2  # End-of-sentence token
-
-
-######################################################################
-# Model Overview
-# --------------
-#
-# As mentioned, the model that we are using is a
-# `sequence-to-sequence <https://arxiv.org/abs/1409.3215>`__ (seq2seq)
-# model. This type of model is used in cases when our input is a
-# variable-length sequence, and our output is also a variable length
-# sequence that is not necessarily a one-to-one mapping of the input. A
-# seq2seq model is comprised of two recurrent neural networks (RNNs) that
-# work cooperatively: an **encoder** and a **decoder**.
-#
-# .. figure:: /_static/img/chatbot/seq2seq_ts.png
-#    :align: center
-#    :alt: model
-#
-#
-# Image source:
-# https://jeddy92.github.io/JEddy92.github.io/ts_seq2seq_intro/
-#
-# Encoder
-# ~~~~~~~
-#
-# The encoder RNN iterates through the input sentence one token
-# (e.g. word) at a time, at each time step outputting an “output” vector
-# and a “hidden state” vector. The hidden state vector is then passed to
-# the next time step, while the output vector is recorded. The encoder
-# transforms the context it saw at each point in the sequence into a set
-# of points in a high-dimensional space, which the decoder will use to
-# generate a meaningful output for the given task.
-#
-# Decoder
-# ~~~~~~~
-#
-# The decoder RNN generates the response sentence in a token-by-token
-# fashion. It uses the encoder’s context vectors, and internal hidden
-# states to generate the next word in the sequence. It continues
-# generating words until it outputs an *EOS_token*, representing the end
-# of the sentence. We use an `attention
-# mechanism <https://arxiv.org/abs/1409.0473>`__ in our decoder to help it
-# to “pay attention” to certain parts of the input when generating the
-# output. For our model, we implement `Luong et
-# al. <https://arxiv.org/abs/1508.04025>`__\ ’s “Global attention” module,
-# and use it as a submodule in our decode model.
-#
-
-
-######################################################################
-# Data Handling
-# -------------
-#
-# Although our models conceptually deal with sequences of tokens, in
-# reality, they deal with numbers like all machine learning models do. In
-# this case, every word in the model’s vocabulary, which was established
-# before training, is mapped to an integer index. We use a ``Voc`` object
-# to contain the mappings from word to index, as well as the total number
-# of words in the vocabulary. We will load the object later before we run
-# the model.
-#
-# Also, in order for us to be able to run evaluations, we must provide a
-# tool for processing our string inputs. The ``normalizeString`` function
-# converts all characters in a string to lowercase and removes all
-# non-letter characters. The ``indexesFromSentence`` function takes a
-# sentence of words and returns the corresponding sequence of word
-# indexes.
-#
-
-class Voc:
-    def __init__(self, name):
-        self.name = name
-        self.trimmed = False
-        self.word2index = {}
-        self.word2count = {}
-        self.index2word = {PAD_token: "PAD", SOS_token: "SOS", EOS_token: "EOS"}
-        self.num_words = 3  # Count SOS, EOS, PAD
-
-    def addSentence(self, sentence):
-        for word in sentence.split(' '):
-            self.addWord(word)
-
-    def addWord(self, word):
-        if word not in self.word2index:
-            self.word2index[word] = self.num_words
-            self.word2count[word] = 1
-            self.index2word[self.num_words] = word
-            self.num_words += 1
-        else:
-            self.word2count[word] += 1
-
-    # Remove words below a certain count threshold
-    def trim(self, min_count):
-        if self.trimmed:
-            return
-        self.trimmed = True
-        keep_words = []
-        for k, v in self.word2count.items():
-            if v >= min_count:
-                keep_words.append(k)
-
-        print('keep_words {} / {} = {:.4f}'.format(
-            len(keep_words), len(self.word2index), len(keep_words) / len(self.word2index)
-        ))
-        # Reinitialize dictionaries
-        self.word2index = {}
-        self.word2count = {}
-        self.index2word = {PAD_token: "PAD", SOS_token: "SOS", EOS_token: "EOS"}
-        self.num_words = 3 # Count default tokens
-        for word in keep_words:
-            self.addWord(word)
-
-
-# Lowercase and remove non-letter characters
-def normalizeString(s):
-    s = s.lower()
-    s = re.sub(r"([.!?])", r" \1", s)
-    s = re.sub(r"[^a-zA-Z.!?]+", r" ", s)
-    return s
-
-
-# Takes string sentence, returns sentence of word indexes
-def indexesFromSentence(voc, sentence):
-    return [voc.word2index[word] for word in sentence.split(' ')] + [EOS_token]
-
-
-######################################################################
-# Define Encoder
-# --------------
-#
-# We implement our encoder’s RNN with the ``torch.nn.GRU`` module which we
-# feed a batch of sentences (vectors of word embeddings) and it internally
-# iterates through the sentences one token at a time calculating the
-# hidden states. We initialize this module to be bidirectional, meaning
-# that we have two independent GRUs: one that iterates through the
-# sequences in chronological order, and another that iterates in reverse
-# order. We ultimately return the sum of these two GRUs’ outputs. Since
-# our model was trained using batching, our ``EncoderRNN`` model’s
-# ``forward`` function expects a padded input batch. To batch
-# variable-length sentences, we allow a maximum of *MAX_LENGTH* tokens in
-# a sentence, and all sentences in the batch that have less than
-# *MAX_LENGTH* tokens are padded at the end with our dedicated *PAD_token*
-# tokens. To use padded batches with a PyTorch RNN module, we must wrap
-# the forward pass call with ``torch.nn.utils.rnn.pack_padded_sequence``
-# and ``torch.nn.utils.rnn.pad_packed_sequence`` data transformations.
-# Note that the ``forward`` function also takes an ``input_lengths`` list,
-# which contains the length of each sentence in the batch. This input is
-# used by the ``torch.nn.utils.rnn.pack_padded_sequence`` function when
-# padding.
-#
-# Hybrid Frontend Notes:
-# ~~~~~~~~~~~~~~~~~~~~~~
-#
-# Since the encoder’s ``forward`` function does not contain any
-# data-dependent control flow, we will use **tracing** to convert it to
-# script mode. When tracing a module, we can leave the module definition
-# as-is. We will initialize all models towards the end of this document
-# before we run evaluations.
-#
-
-class EncoderRNN(nn.Module):
-    def __init__(self, hidden_size, embedding, n_layers=1, dropout=0):
-        super(EncoderRNN, self).__init__()
-        self.n_layers = n_layers
-        self.hidden_size = hidden_size
-        self.embedding = embedding
-
-        # Initialize GRU; the input_size and hidden_size params are both set to 'hidden_size'
-        #   because our input size is a word embedding with number of features == hidden_size
-        self.gru = nn.GRU(hidden_size, hidden_size, n_layers,
-                          dropout=(0 if n_layers == 1 else dropout), bidirectional=True)
-
-    def forward(self, input_seq, input_lengths, hidden=None):
-        # Convert word indexes to embeddings
-        embedded = self.embedding(input_seq)
-        # Pack padded batch of sequences for RNN module
-        packed = torch.nn.utils.rnn.pack_padded_sequence(embedded, input_lengths)
-        # Forward pass through GRU
-        outputs, hidden = self.gru(packed, hidden)
-        # Unpack padding
-        outputs, _ = torch.nn.utils.rnn.pad_packed_sequence(outputs)
-        # Sum bidirectional GRU outputs
-        outputs = outputs[:, :, :self.hidden_size] + outputs[:, : ,self.hidden_size:]
-        # Return output and final hidden state
-        return outputs, hidden
-
-
-######################################################################
-# Define Decoder’s Attention Module
-# ---------------------------------
-#
-# Next, we’ll define our attention module (``Attn``). Note that this
-# module will be used as a submodule in our decoder model. Luong et
-# al. consider various “score functions”, which take the current decoder
-# RNN output and the entire encoder output, and return attention
-# “energies”. This attention energies tensor is the same size as the
-# encoder output, and the two are ultimately multiplied, resulting in a
-# weighted tensor whose largest values represent the most important parts
-# of the query sentence at a particular time-step of decoding.
-#
-
-# Luong attention layer
-class Attn(torch.nn.Module):
-    def __init__(self, method, hidden_size):
-        super(Attn, self).__init__()
-        self.method = method
-        if self.method not in ['dot', 'general', 'concat']:
-            raise ValueError(self.method, "is not an appropriate attention method.")
-        self.hidden_size = hidden_size
-        if self.method == 'general':
-            self.attn = torch.nn.Linear(self.hidden_size, hidden_size)
-        elif self.method == 'concat':
-            self.attn = torch.nn.Linear(self.hidden_size * 2, hidden_size)
-            self.v = torch.nn.Parameter(torch.FloatTensor(hidden_size))
-
-    def dot_score(self, hidden, encoder_output):
-        return torch.sum(hidden * encoder_output, dim=2)
-
-    def general_score(self, hidden, encoder_output):
-        energy = self.attn(encoder_output)
-        return torch.sum(hidden * energy, dim=2)
-
-    def concat_score(self, hidden, encoder_output):
-        energy = self.attn(torch.cat((hidden.expand(encoder_output.size(0), -1, -1), encoder_output), 2)).tanh()
-        return torch.sum(self.v * energy, dim=2)
-
-    def forward(self, hidden, encoder_outputs):
-        # Calculate the attention weights (energies) based on the given method
-        if self.method == 'general':
-            attn_energies = self.general_score(hidden, encoder_outputs)
-        elif self.method == 'concat':
-            attn_energies = self.concat_score(hidden, encoder_outputs)
-        elif self.method == 'dot':
-            attn_energies = self.dot_score(hidden, encoder_outputs)
-
-        # Transpose max_length and batch_size dimensions
-        attn_energies = attn_energies.t()
-
-        # Return the softmax normalized probability scores (with added dimension)
-        return F.softmax(attn_energies, dim=1).unsqueeze(1)
-
-
-######################################################################
-# Define Decoder
-# --------------
-#
-# Similarly to the ``EncoderRNN``, we use the ``torch.nn.GRU`` module for
-# our decoder’s RNN. This time, however, we use a unidirectional GRU. It
-# is important to note that unlike the encoder, we will feed the decoder
-# RNN one word at a time. We start by getting the embedding of the current
-# word and applying a
-# `dropout <https://pytorch.org/docs/stable/nn.html?highlight=dropout#torch.nn.Dropout>`__.
-# Next, we forward the embedding and the last hidden state to the GRU and
-# obtain a current GRU output and hidden state. We then use our ``Attn``
-# module as a layer to obtain the attention weights, which we multiply by
-# the encoder’s output to obtain our attended encoder output. We use this
-# attended encoder output as our ``context`` tensor, which represents a
-# weighted sum indicating what parts of the encoder’s output to pay
-# attention to. From here, we use a linear layer and softmax normalization
-# to select the next word in the output sequence.
-#
-# Hybrid Frontend Notes:
-# ~~~~~~~~~~~~~~~~~~~~~~
-#
-# Similarly to the ``EncoderRNN``, this module does not contain any
-# data-dependent control flow. Therefore, we can once again use
-# **tracing** to convert this model to Torch Script after it is
-# initialized and its parameters are loaded.
-#
-
-class LuongAttnDecoderRNN(nn.Module):
-    def __init__(self, attn_model, embedding, hidden_size, output_size, n_layers=1, dropout=0.1):
-        super(LuongAttnDecoderRNN, self).__init__()
-
-        # Keep for reference
-        self.attn_model = attn_model
-        self.hidden_size = hidden_size
-        self.output_size = output_size
-        self.n_layers = n_layers
-        self.dropout = dropout
-
-        # Define layers
-        self.embedding = embedding
-        self.embedding_dropout = nn.Dropout(dropout)
-        self.gru = nn.GRU(hidden_size, hidden_size, n_layers, dropout=(0 if n_layers == 1 else dropout))
-        self.concat = nn.Linear(hidden_size * 2, hidden_size)
-        self.out = nn.Linear(hidden_size, output_size)
-
-        self.attn = Attn(attn_model, hidden_size)
-
-    def forward(self, input_step, last_hidden, encoder_outputs):
-        # Note: we run this one step (word) at a time
-        # Get embedding of current input word
-        embedded = self.embedding(input_step)
-        embedded = self.embedding_dropout(embedded)
-        # Forward through unidirectional GRU
-        rnn_output, hidden = self.gru(embedded, last_hidden)
-        # Calculate attention weights from the current GRU output
-        attn_weights = self.attn(rnn_output, encoder_outputs)
-        # Multiply attention weights to encoder outputs to get new "weighted sum" context vector
-        context = attn_weights.bmm(encoder_outputs.transpose(0, 1))
-        # Concatenate weighted context vector and GRU output using Luong eq. 5
-        rnn_output = rnn_output.squeeze(0)
-        context = context.squeeze(1)
-        concat_input = torch.cat((rnn_output, context), 1)
-        concat_output = torch.tanh(self.concat(concat_input))
-        # Predict next word using Luong eq. 6
-        output = self.out(concat_output)
-        output = F.softmax(output, dim=1)
-        # Return output and final hidden state
-        return output, hidden
-
-
-######################################################################
-# Define Evaluation
-# -----------------
-#
-# Greedy Search Decoder
-# ~~~~~~~~~~~~~~~~~~~~~
-#
-# As in the chatbot tutorial, we use a ``GreedySearchDecoder`` module to
-# facilitate the actual decoding process. This module has the trained
-# encoder and decoder models as attributes, and drives the process of
-# encoding an input sentence (a vector of word indexes), and iteratively
-# decoding an output response sequence one word (word index) at a time.
-#
-# Encoding the input sequence is straightforward: simply forward the
-# entire sequence tensor and its corresponding lengths vector to the
-# ``encoder``. It is important to note that this module only deals with
-# one input sequence at a time, **NOT** batches of sequences. Therefore,
-# when the constant **1** is used for declaring tensor sizes, this
-# corresponds to a batch size of 1. To decode a given decoder output, we
-# must iteratively run forward passes through our decoder model, which
-# outputs softmax scores corresponding to the probability of each word
-# being the correct next word in the decoded sequence. We initialize the
-# ``decoder_input`` to a tensor containing an *SOS_token*. After each pass
-# through the ``decoder``, we *greedily* append the word with the highest
-# softmax probability to the ``decoded_words`` list. We also use this word
-# as the ``decoder_input`` for the next iteration. The decoding process
-# terminates either if the ``decoded_words`` list has reached a length of
-# *MAX_LENGTH* or if the predicted word is the *EOS_token*.
-#
-# Hybrid Frontend Notes:
-# ~~~~~~~~~~~~~~~~~~~~~~
-#
-# The ``forward`` method of this module involves iterating over the range
-# of :math:`[0, max\_length)` when decoding an output sequence one word at
-# a time. Because of this, we should use **scripting** to convert this
-# module to Torch Script. Unlike with our encoder and decoder models,
-# which we can trace, we must make some necessary changes to the
-# ``GreedySearchDecoder`` module in order to initialize an object without
-# error. In other words, we must ensure that our module adheres to the
-# rules of the scripting mechanism, and does not utilize any language
-# features outside of the subset of Python that Torch Script includes.
-#
-# To get an idea of some manipulations that may be required, we will go
-# over the diffs between the ``GreedySearchDecoder`` implementation from
-# the chatbot tutorial and the implementation that we use in the cell
-# below. Note that the lines highlighted in red are lines removed from the
-# original implementation and the lines highlighted in green are new.
-#
-# .. figure:: /_static/img/chatbot/diff.png
-#    :align: center
-#    :alt: diff
-#
-# Changes:
-# ^^^^^^^^
-#
-# -  ``nn.Module`` -> ``torch.jit.ScriptModule``
-#
-#    -  In order to use PyTorch’s scripting mechanism on a module, that
-#       module must inherit from the ``torch.jit.ScriptModule``.
-#
-#
-# -  Added ``decoder_n_layers`` to the constructor arguments
-#
-#    -  This change stems from the fact that the encoder and decoder
-#       models that we pass to this module will be a child of
-#       ``TracedModule`` (not ``Module``). Therefore, we cannot access the
-#       decoder’s number of layers with ``decoder.n_layers``. Instead, we
-#       plan for this, and pass this value in during module construction.
-#
-#
-# -  Store away new attributes as constants
-#
-#    -  In the original implementation, we were free to use variables from
-#       the surrounding (global) scope in our ``GreedySearchDecoder``\ ’s
-#       ``forward`` method. However, now that we are using scripting, we
-#       do not have this freedom, as the assumption with scripting is that
-#       we cannot necessarily hold on to Python objects, especially when
-#       exporting. An easy solution to this is to store these values from
-#       the global scope as attributes to the module in the constructor,
-#       and add them to a special list called ``__constants__`` so that
-#       they can be used as literal values when constructing the graph in
-#       the ``forward`` method. An example of this usage is on NEW line
-#       19, where instead of using the ``device`` and ``SOS_token`` global
-#       values, we use our constant attributes ``self._device`` and
-#       ``self._SOS_token``.
-#
-#
-# -  Add the ``torch.jit.script_method`` decorator to the ``forward``
-#    method
-#
-#    -  Adding this decorator lets the JIT compiler know that the function
-#       that it is decorating should be scripted.
-#
-#
-# -  Enforce types of ``forward`` method arguments
-#
-#    -  By default, all parameters to a Torch Script function are assumed
-#       to be Tensor. If we need to pass an argument of a different type,
-#       we can use function type annotations as introduced in `PEP
-#       3107 <https://www.python.org/dev/peps/pep-3107/>`__. In addition,
-#       it is possible to declare arguments of different types using
-#       MyPy-style type annotations (see
-#       `doc <https://pytorch.org/docs/master/jit.html#types>`__).
-#
-#
-# -  Change initialization of ``decoder_input``
-#
-#    -  In the original implementation, we initialized our
-#       ``decoder_input`` tensor with ``torch.LongTensor([[SOS_token]])``.
-#       When scripting, we are not allowed to initialize tensors in a
-#       literal fashion like this. Instead, we can initialize our tensor
-#       with an explicit torch function such as ``torch.ones``. In this
-#       case, we can easily replicate the scalar ``decoder_input`` tensor
-#       by multiplying 1 by our SOS_token value stored in the constant
-#       ``self._SOS_token``.
-#
-
-class GreedySearchDecoder(torch.jit.ScriptModule):
-    def __init__(self, encoder, decoder, decoder_n_layers):
-        super(GreedySearchDecoder, self).__init__()
-        self.encoder = encoder
-        self.decoder = decoder
-        self._device = device
-        self._SOS_token = SOS_token
-        self._decoder_n_layers = decoder_n_layers
-
-    __constants__ = ['_device', '_SOS_token', '_decoder_n_layers']
-
-    @torch.jit.script_method
-    def forward(self, input_seq : torch.Tensor, input_length : torch.Tensor, max_length : int):
-        # Forward input through encoder model
-        encoder_outputs, encoder_hidden = self.encoder(input_seq, input_length)
-        # Prepare encoder's final hidden layer to be first hidden input to the decoder
-        decoder_hidden = encoder_hidden[:self._decoder_n_layers]
-        # Initialize decoder input with SOS_token
-        decoder_input = torch.ones(1, 1, device=self._device, dtype=torch.long) * self._SOS_token
-        # Initialize tensors to append decoded words to
-        all_tokens = torch.zeros([0], device=self._device, dtype=torch.long)
-        all_scores = torch.zeros([0], device=self._device)
-        # Iteratively decode one word token at a time
-        for _ in range(max_length):
-            # Forward pass through decoder
-            decoder_output, decoder_hidden = self.decoder(decoder_input, decoder_hidden, encoder_outputs)
-            # Obtain most likely word token and its softmax score
-            decoder_scores, decoder_input = torch.max(decoder_output, dim=1)
-            # Record token and score
-            all_tokens = torch.cat((all_tokens, decoder_input), dim=0)
-            all_scores = torch.cat((all_scores, decoder_scores), dim=0)
-            # Prepare current token to be next decoder input (add a dimension)
-            decoder_input = torch.unsqueeze(decoder_input, 0)
-        # Return collections of word tokens and scores
-        return all_tokens, all_scores
-
-
-
-######################################################################
-# Evaluating an Input
-# ~~~~~~~~~~~~~~~~~~~
-#
-# Next, we define some functions for evaluating an input. The ``evaluate``
-# function takes a normalized string sentence, processes it to a tensor of
-# its corresponding word indexes (with batch size of 1), and passes this
-# tensor to a ``GreedySearchDecoder`` instance called ``searcher`` to
-# handle the encoding/decoding process. The searcher returns the output
-# word index vector and a scores tensor corresponding to the softmax
-# scores for each decoded word token. The final step is to convert each
-# word index back to its string representation using ``voc.index2word``.
-#
-# We also define two functions for evaluating an input sentence. The
-# ``evaluateInput`` function prompts a user for an input, and evaluates
-# it. It will continue to ask for another input until the user enters ‘q’
-# or ‘quit’.
-#
-# The ``evaluateExample`` function simply takes a string input sentence as
-# an argument, normalizes it, evaluates it, and prints the response.
-#
-
-def evaluate(encoder, decoder, searcher, voc, sentence, max_length=MAX_LENGTH):
-    ### Format input sentence as a batch
-    # words -> indexes
-    indexes_batch = [indexesFromSentence(voc, sentence)]
-    # Create lengths tensor
-    lengths = torch.tensor([len(indexes) for indexes in indexes_batch])
-    # Transpose dimensions of batch to match models' expectations
-    input_batch = torch.LongTensor(indexes_batch).transpose(0, 1)
-    # Use appropriate device
-    input_batch = input_batch.to(device)
-    lengths = lengths.to(device)
-    # Decode sentence with searcher
-    tokens, scores = searcher(input_batch, lengths, max_length)
-    # indexes -> words
-    decoded_words = [voc.index2word[token.item()] for token in tokens]
-    return decoded_words
-
-
-# Evaluate inputs from user input (stdin)
-def evaluateInput(encoder, decoder, searcher, voc):
-    input_sentence = ''
-    while(1):
-        try:
-            # Get input sentence
-            input_sentence = input('> ')
-            # Check if it is quit case
-            if input_sentence == 'q' or input_sentence == 'quit': break
-            # Normalize sentence
-            input_sentence = normalizeString(input_sentence)
-            # Evaluate sentence
-            output_words = evaluate(encoder, decoder, searcher, voc, input_sentence)
-            # Format and print response sentence
-            output_words[:] = [x for x in output_words if not (x == 'EOS' or x == 'PAD')]
-            print('Bot:', ' '.join(output_words))
-
-        except KeyError:
-            print("Error: Encountered unknown word.")
-
-# Normalize input sentence and call evaluate()
-def evaluateExample(sentence, encoder, decoder, searcher, voc):
-    print("> " + sentence)
-    # Normalize sentence
-    input_sentence = normalizeString(sentence)
-    # Evaluate sentence
-    output_words = evaluate(encoder, decoder, searcher, voc, input_sentence)
-    output_words[:] = [x for x in output_words if not (x == 'EOS' or x == 'PAD')]
-    print('Bot:', ' '.join(output_words))
-
-
-######################################################################
-# Load Pretrained Parameters
-# --------------------------
-#
-# Ok, its time to load our model!
-#
-# Use hosted model
-# ~~~~~~~~~~~~~~~~
-#
-# To load the hosted model:
-#
-# 1) Download the model `here <https://download.pytorch.org/models/tutorials/4000_checkpoint.tar>`__.
-#
-# 2) Set the ``loadFilename`` variable to the path to the downloaded
-#    checkpoint file.
-#
-# 3) Leave the ``checkpoint = torch.load(loadFilename)`` line uncommented,
-#    as the hosted model was trained on CPU.
-#
-# Use your own model
-# ~~~~~~~~~~~~~~~~~~
-#
-# To load your own pre-trained model:
-#
-# 1) Set the ``loadFilename`` variable to the path to the checkpoint file
-#    that you wish to load. Note that if you followed the convention for
-#    saving the model from the chatbot tutorial, this may involve changing
-#    the ``model_name``, ``encoder_n_layers``, ``decoder_n_layers``,
-#    ``hidden_size``, and ``checkpoint_iter`` (as these values are used in
-#    the model path).
-#
-# 2) If you trained the model on a CPU, make sure that you are opening the
-#    checkpoint with the ``checkpoint = torch.load(loadFilename)`` line.
-#    If you trained the model on a GPU and are running this tutorial on a
-#    CPU, uncomment the
-#    ``checkpoint = torch.load(loadFilename, map_location=torch.device('cpu'))``
-#    line.
-#
-# Hybrid Frontend Notes:
-# ~~~~~~~~~~~~~~~~~~~~~~
-#
-# Notice that we initialize and load parameters into our encoder and
-# decoder models as usual. Also, we must call ``.to(device)`` to set the
-# device options of the models and ``.eval()`` to set the dropout layers
-# to test mode **before** we trace the models. ``TracedModule`` objects do
-# not inherit the ``to`` or ``eval`` methods.
-#
-
-save_dir = os.path.join("data", "save")
-corpus_name = "cornell movie-dialogs corpus"
-
-# Configure models
-model_name = 'cb_model'
-attn_model = 'dot'
-#attn_model = 'general'
-#attn_model = 'concat'
-hidden_size = 500
-encoder_n_layers = 2
-decoder_n_layers = 2
-dropout = 0.1
-batch_size = 64
-
-# If you're loading your own model
-# Set checkpoint to load from
-checkpoint_iter = 4000
-# loadFilename = os.path.join(save_dir, model_name, corpus_name,
-#                             '{}-{}_{}'.format(encoder_n_layers, decoder_n_layers, hidden_size),
-#                             '{}_checkpoint.tar'.format(checkpoint_iter))
-
-# If you're loading the hosted model
-loadFilename = 'data/4000_checkpoint.tar'
-
-# Load model
-# Force CPU device options (to match tensors in this tutorial)
-checkpoint = torch.load(loadFilename, map_location=torch.device('cpu'))
-encoder_sd = checkpoint['en']
-decoder_sd = checkpoint['de']
-encoder_optimizer_sd = checkpoint['en_opt']
-decoder_optimizer_sd = checkpoint['de_opt']
-embedding_sd = checkpoint['embedding']
-voc = Voc(corpus_name)
-voc.__dict__ = checkpoint['voc_dict']
-
-
-print('Building encoder and decoder ...')
-# Initialize word embeddings
-embedding = nn.Embedding(voc.num_words, hidden_size)
-embedding.load_state_dict(embedding_sd)
-# Initialize encoder & decoder models
-encoder = EncoderRNN(hidden_size, embedding, encoder_n_layers, dropout)
-decoder = LuongAttnDecoderRNN(attn_model, embedding, hidden_size, voc.num_words, decoder_n_layers, dropout)
-# Load trained model params
-encoder.load_state_dict(encoder_sd)
-decoder.load_state_dict(decoder_sd)
-# Use appropriate device
-encoder = encoder.to(device)
-decoder = decoder.to(device)
-# Set dropout layers to eval mode
-encoder.eval()
-decoder.eval()
-print('Models built and ready to go!')
-
-
-######################################################################
-# Convert Model to Torch Script
-# -----------------------------
-#
-# Encoder
-# ~~~~~~~
-#
-# As previously mentioned, to convert the encoder model to Torch Script,
-# we use **tracing**. Tracing any module requires running an example input
-# through the model’s ``forward`` method and trace the computational graph
-# that the data encounters. The encoder model takes an input sequence and
-# a corresponding lengths tensor. Therefore, we create an example input
-# sequence tensor ``test_seq``, which is of appropriate size (MAX_LENGTH,
-# 1), contains numbers in the appropriate range
-# :math:`[0, voc.num\_words)`, and is of the appropriate type (int64). We
-# also create a ``test_seq_length`` scalar which realistically contains
-# the value corresponding to how many words are in the ``test_seq``. The
-# next step is to use the ``torch.jit.trace`` function to trace the model.
-# Notice that the first argument we pass is the module that we want to
-# trace, and the second is a tuple of arguments to the module’s
-# ``forward`` method.
-#
-# Decoder
-# ~~~~~~~
-#
-# We perform the same process for tracing the decoder as we did for the
-# encoder. Notice that we call forward on a set of random inputs to the
-# traced_encoder to get the output that we need for the decoder. This is
-# not required, as we could also simply manufacture a tensor of the
-# correct shape, type, and value range. This method is possible because in
-# our case we do not have any constraints on the values of the tensors
-# because we do not have any operations that could fault on out-of-range
-# inputs.
-#
-# GreedySearchDecoder
-# ~~~~~~~~~~~~~~~~~~~
-#
-# Recall that we scripted our searcher module due to the presence of
-# data-dependent control flow. In the case of scripting, we do the
-# conversion work up front by adding the decorator and making sure the
-# implementation complies with scripting rules. We initialize the scripted
-# searcher the same way that we would initialize an un-scripted variant.
-#
-
-### Convert encoder model
-# Create artificial inputs
-test_seq = torch.LongTensor(MAX_LENGTH, 1).random_(0, voc.num_words).to(device)
-test_seq_length = torch.LongTensor([test_seq.size()[0]]).to(device)
-# Trace the model
-traced_encoder = torch.jit.trace(encoder, (test_seq, test_seq_length))
-
-### Convert decoder model
-# Create and generate artificial inputs
-test_encoder_outputs, test_encoder_hidden = traced_encoder(test_seq, test_seq_length)
-test_decoder_hidden = test_encoder_hidden[:decoder.n_layers]
-test_decoder_input = torch.LongTensor(1, 1).random_(0, voc.num_words)
-# Trace the model
-traced_decoder = torch.jit.trace(decoder, (test_decoder_input, test_decoder_hidden, test_encoder_outputs))
-
-### Initialize searcher module
-scripted_searcher = GreedySearchDecoder(traced_encoder, traced_decoder, decoder.n_layers)
-
-
-######################################################################
-# Print Graphs
-# ------------
-#
-# Now that our models are in Torch Script form, we can print the graphs of
-# each to ensure that we captured the computational graph appropriately.
-# Since our ``scripted_searcher`` contains our ``traced_encoder`` and
-# ``traced_decoder``, these graphs will print inline.
-#
-
-print('scripted_searcher graph:\n', scripted_searcher.graph)
-
-
-######################################################################
-# Run Evaluation
-# --------------
-#
-# Finally, we will run evaluation of the chatbot model using the Torch
-# Script models. If converted correctly, the models will behave exactly as
-# they would in their eager-mode representation.
-#
-# By default, we evaluate a few common query sentences. If you want to
-# chat with the bot yourself, uncomment the ``evaluateInput`` line and
-# give it a spin.
-#
-
-# Evaluate examples
-sentences = ["hello", "what's up?", "who are you?", "where am I?", "where are you from?"]
-for s in sentences:
-    evaluateExample(s, traced_encoder, traced_decoder, scripted_searcher, voc)
-
-# Evaluate your input
-#evaluateInput(traced_encoder, traced_decoder, scripted_searcher, voc)
-
-
-######################################################################
-# Save Model
-# ----------
-#
-# Now that we have successfully converted our model to Torch Script, we
-# will serialize it for use in a non-Python deployment environment. To do
-# this, we can simply save our ``scripted_searcher`` module, as this is
-# the user-facing interface for running inference against the chatbot
-# model. When saving a Script module, use script_module.save(PATH) instead
-# of torch.save(model, PATH).
-#
-
-scripted_searcher.save("scripted_chatbot.pth")
diff --git a/beginner_source/dist_overview.rst b/beginner_source/dist_overview.rst
new file mode 100644
index 00000000000..9088434bf2f
--- /dev/null
+++ b/beginner_source/dist_overview.rst
@@ -0,0 +1,94 @@
+PyTorch Distributed Overview
+============================
+**Author**: `Will Constable <https://github.com/wconstab/>`_, `Wei Feng <https://github.com/weifengpy>`_
+
+.. note::
+   |edit| View and edit this tutorial in `github <https://github.com/pytorch/tutorials/blob/main/beginner_source/dist_overview.rst>`__.
+
+This is the overview page for the ``torch.distributed`` package. The goal of
+this page is to categorize documents into different topics and briefly
+describe each of them. If this is your first time building distributed training
+applications using PyTorch, it is recommended to use this document to navigate
+to the technology that can best serve your use case.
+
+
+Introduction
+------------
+
+The PyTorch Distributed library includes a collective of parallelism modules,
+a communications layer, and infrastructure for launching and
+debugging large training jobs.
+
+
+Parallelism APIs
+****************
+
+These Parallelism Modules offer high-level functionality and compose with existing models:
+
+- `Distributed Data-Parallel (DDP) <https://pytorch.org/docs/stable/generated/torch.nn.parallel.DistributedDataParallel.html>`__
+- `Fully Sharded Data-Parallel Training (FSDP2) <https://pytorch.org/docs/stable/distributed.fsdp.fully_shard.html>`__
+- `Tensor Parallel (TP) <https://pytorch.org/docs/stable/distributed.tensor.parallel.html>`__
+- `Pipeline Parallel (PP) <https://pytorch.org/docs/main/distributed.pipelining.html>`__
+
+Sharding primitives
+*******************
+
+``DTensor`` and ``DeviceMesh`` are primitives used to build parallelism in terms of sharded or replicated tensors on N-dimensional process groups.
+
+- `DTensor <https://github.com/pytorch/pytorch/blob/main/torch/distributed/tensor/README.md>`__ represents a tensor that is sharded and/or replicated, and communicates automatically to reshard tensors as needed by operations.
+- `DeviceMesh <https://pytorch.org/docs/stable/distributed.html#devicemesh>`__ abstracts the accelerator device communicators into a multi-dimensional array, which manages the underlying ``ProcessGroup`` instances for collective communications in multi-dimensional parallelisms.  Try out our `Device Mesh Recipe <https://pytorch.org/tutorials/recipes/distributed_device_mesh.html>`__ to learn more.
+
+Communications APIs
+*******************
+
+The `PyTorch distributed communication layer (C10D) <https://pytorch.org/docs/stable/distributed.html>`__ offers both collective communication APIs (e.g., `all_reduce <https://pytorch.org/docs/stable/distributed.html#torch.distributed.all_reduce>`__
+  and `all_gather <https://pytorch.org/docs/stable/distributed.html#torch.distributed.all_gather>`__)
+  and P2P communication APIs (e.g.,
+  `send <https://pytorch.org/docs/stable/distributed.html#torch.distributed.send>`__
+  and `isend <https://pytorch.org/docs/stable/distributed.html#torch.distributed.isend>`__),
+  which are used under the hood in all of the parallelism implementations.
+  `Writing Distributed Applications with PyTorch <../intermediate/dist_tuto.html>`__
+  shows examples of using c10d communication APIs.
+
+Launcher
+********
+
+`torchrun <https://pytorch.org/docs/stable/elastic/run.html>`__ is a widely-used launcher script, which spawns processes on the local and remote machines for running distributed PyTorch programs.
+
+
+Applying Parallelism To Scale Your Model
+----------------------------------------
+
+Data Parallelism is a widely adopted single-program multiple-data training paradigm
+where the model is replicated on every process, every model replica computes local gradients for
+a different set of input data samples, gradients are averaged within the data-parallel communicator group before each optimizer step.
+
+Model Parallelism techniques (or Sharded Data Parallelism) are required when a model doesn't fit in GPU, and can be combined together to form multi-dimensional (N-D) parallelism techniques.
+
+When deciding what parallelism techniques to choose for your model, use these common guidelines:
+
+#. Use `DistributedDataParallel (DDP) <https://pytorch.org/docs/stable/notes/ddp.html>`__,
+   if your model fits in a single GPU but you want to easily scale up training using multiple GPUs.
+
+   * Use `torchrun <https://pytorch.org/docs/stable/elastic/run.html>`__, to launch multiple pytorch processes if you are using more than one node.
+
+   * See also: `Getting Started with Distributed Data Parallel <../intermediate/ddp_tutorial.html>`__
+
+#. Use `FullyShardedDataParallel (FSDP2) <https://pytorch.org/docs/stable/distributed.fsdp.fully_shard.html>`__ when your model cannot fit on one GPU.
+
+   * See also: `Getting Started with FSDP2 <https://pytorch.org/tutorials/intermediate/FSDP_tutorial.html>`__
+
+#. Use `Tensor Parallel (TP) <https://pytorch.org/docs/stable/distributed.tensor.parallel.html>`__ and/or `Pipeline Parallel (PP) <https://pytorch.org/docs/main/distributed.pipelining.html>`__ if you reach scaling limitations with FSDP2.
+
+   * Try our `Tensor Parallelism Tutorial <https://pytorch.org/tutorials/intermediate/TP_tutorial.html>`__
+
+   * See also: `TorchTitan end to end example of 3D parallelism <https://github.com/pytorch/torchtitan>`__
+
+.. note:: Data-parallel training also works with `Automatic Mixed Precision (AMP) <https://pytorch.org/docs/stable/notes/amp_examples.html#working-with-multiple-gpus>`__.
+
+
+PyTorch Distributed Developers
+------------------------------
+
+If you'd like to contribute to PyTorch Distributed, refer to our
+`Developer Guide <https://github.com/pytorch/pytorch/blob/master/torch/distributed/CONTRIBUTING.md>`_.
diff --git a/beginner_source/examples_autograd/polynomial_autograd.py b/beginner_source/examples_autograd/polynomial_autograd.py
new file mode 100755
index 00000000000..d33ca8bcb90
--- /dev/null
+++ b/beginner_source/examples_autograd/polynomial_autograd.py
@@ -0,0 +1,81 @@
+r"""
+PyTorch: Tensors and autograd
+-------------------------------
+
+A third order polynomial, trained to predict :math:`y=\sin(x)` from :math:`-\pi`
+to :math:`\pi` by minimizing squared Euclidean distance.
+
+This implementation computes the forward pass using operations on PyTorch
+Tensors, and uses PyTorch autograd to compute gradients.
+
+
+A PyTorch Tensor represents a node in a computational graph. If ``x`` is a
+Tensor that has ``x.requires_grad=True`` then ``x.grad`` is another Tensor
+holding the gradient of ``x`` with respect to some scalar value.
+"""
+import torch
+import math
+
+# We want to be able to train our model on an `accelerator <https://pytorch.org/docs/stable/torch.html#accelerators>`__
+# such as CUDA, MPS, MTIA, or XPU. If the current accelerator is available, we will use it. Otherwise, we use the CPU.
+
+dtype = torch.float
+device = torch.accelerator.current_accelerator().type if torch.accelerator.is_available() else "cpu"
+print(f"Using {device} device")
+torch.set_default_device(device)
+
+# Create Tensors to hold input and outputs.
+# By default, requires_grad=False, which indicates that we do not need to
+# compute gradients with respect to these Tensors during the backward pass.
+x = torch.linspace(-1, 1, 2000, dtype=dtype)
+y = torch.exp(x) # A Taylor expansion would be 1 + x + (1/2) x**2 + (1/3!) x**3 + ...
+
+# Create random Tensors for weights. For a third order polynomial, we need
+# 4 weights: y = a + b x + c x^2 + d x^3
+# Setting requires_grad=True indicates that we want to compute gradients with
+# respect to these Tensors during the backward pass.
+a = torch.randn((), dtype=dtype, requires_grad=True)
+b = torch.randn((), dtype=dtype, requires_grad=True)
+c = torch.randn((), dtype=dtype, requires_grad=True)
+d = torch.randn((), dtype=dtype, requires_grad=True)
+
+initial_loss = 1.
+learning_rate = 1e-5
+for t in range(5000):
+    # Forward pass: compute predicted y using operations on Tensors.
+    y_pred = a + b * x + c * x ** 2 + d * x ** 3
+
+    # Compute and print loss using operations on Tensors.
+    # Now loss is a Tensor of shape (1,)
+    # loss.item() gets the scalar value held in the loss.
+    loss = (y_pred - y).pow(2).sum()
+
+    # Calculare initial loss, so we can report loss relative to it
+    if t==0:
+        initial_loss=loss.item()
+
+    if t % 100 == 99:
+        print(f'Iteration t = {t:4d}  loss(t)/loss(0) = {round(loss.item()/initial_loss, 6):10.6f}  a = {a.item():10.6f}  b = {b.item():10.6f}  c = {c.item():10.6f}  d = {d.item():10.6f}')
+
+    # Use autograd to compute the backward pass. This call will compute the
+    # gradient of loss with respect to all Tensors with requires_grad=True.
+    # After this call a.grad, b.grad. c.grad and d.grad will be Tensors holding
+    # the gradient of the loss with respect to a, b, c, d respectively.
+    loss.backward()
+
+    # Manually update weights using gradient descent. Wrap in torch.no_grad()
+    # because weights have requires_grad=True, but we don't need to track this
+    # in autograd.
+    with torch.no_grad():
+        a -= learning_rate * a.grad
+        b -= learning_rate * b.grad
+        c -= learning_rate * c.grad
+        d -= learning_rate * d.grad
+
+        # Manually zero the gradients after updating weights
+        a.grad = None
+        b.grad = None
+        c.grad = None
+        d.grad = None
+
+print(f'Result: y = {a.item()} + {b.item()} x + {c.item()} x^2 + {d.item()} x^3')
diff --git a/beginner_source/examples_autograd/polynomial_custom_function.py b/beginner_source/examples_autograd/polynomial_custom_function.py
new file mode 100755
index 00000000000..39057c8fd7a
--- /dev/null
+++ b/beginner_source/examples_autograd/polynomial_custom_function.py
@@ -0,0 +1,106 @@
+"""
+PyTorch: Defining New autograd Functions
+----------------------------------------
+
+A third order polynomial, trained to predict :math:`y=\sin(x)` from :math:`-\pi`
+to :math:`\pi` by minimizing squared Euclidean distance. Instead of writing the
+polynomial as :math:`y=a+bx+cx^2+dx^3`, we write the polynomial as
+:math:`y=a+b P_3(c+dx)` where :math:`P_3(x)=\\frac{1}{2}\\left(5x^3-3x\\right)` is
+the `Legendre polynomial`_ of degree three.
+
+.. _Legendre polynomial:
+    https://en.wikipedia.org/wiki/Legendre_polynomials
+
+This implementation computes the forward pass using operations on PyTorch
+Tensors, and uses PyTorch autograd to compute gradients.
+
+In this implementation we implement our own custom autograd function to perform
+:math:`P_3'(x)`. By mathematics, :math:`P_3'(x)=\\frac{3}{2}\\left(5x^2-1\\right)`
+"""
+import torch
+import math
+
+
+class LegendrePolynomial3(torch.autograd.Function):
+    """
+    We can implement our own custom autograd Functions by subclassing
+    torch.autograd.Function and implementing the forward and backward passes
+    which operate on Tensors.
+    """
+
+    @staticmethod
+    def forward(ctx, input):
+        """
+        In the forward pass we receive a Tensor containing the input and return
+        a Tensor containing the output. ctx is a context object that can be used
+        to stash information for backward computation. You can cache tensors for
+        use in the backward pass using the ``ctx.save_for_backward`` method. Other
+        objects can be stored directly as attributes on the ctx object, such as
+        ``ctx.my_object = my_object``. Check out `Extending torch.autograd <https://docs.pytorch.org/docs/stable/notes/extending.html#extending-torch-autograd>`_
+        for further details.
+        """
+        ctx.save_for_backward(input)
+        return 0.5 * (5 * input ** 3 - 3 * input)
+
+    @staticmethod
+    def backward(ctx, grad_output):
+        """
+        In the backward pass we receive a Tensor containing the gradient of the loss
+        with respect to the output, and we need to compute the gradient of the loss
+        with respect to the input.
+        """
+        input, = ctx.saved_tensors
+        return grad_output * 1.5 * (5 * input ** 2 - 1)
+
+
+dtype = torch.float
+device = torch.device("cpu")
+# device = torch.device("cuda:0")  # Uncomment this to run on GPU
+
+# Create Tensors to hold input and outputs.
+# By default, requires_grad=False, which indicates that we do not need to
+# compute gradients with respect to these Tensors during the backward pass.
+x = torch.linspace(-math.pi, math.pi, 2000, device=device, dtype=dtype)
+y = torch.sin(x)
+
+# Create random Tensors for weights. For this example, we need
+# 4 weights: y = a + b * P3(c + d * x), these weights need to be initialized
+# not too far from the correct result to ensure convergence.
+# Setting requires_grad=True indicates that we want to compute gradients with
+# respect to these Tensors during the backward pass.
+a = torch.full((), 0.0, device=device, dtype=dtype, requires_grad=True)
+b = torch.full((), -1.0, device=device, dtype=dtype, requires_grad=True)
+c = torch.full((), 0.0, device=device, dtype=dtype, requires_grad=True)
+d = torch.full((), 0.3, device=device, dtype=dtype, requires_grad=True)
+
+learning_rate = 5e-6
+for t in range(2000):
+    # To apply our Function, we use Function.apply method. We alias this as 'P3'.
+    P3 = LegendrePolynomial3.apply
+
+    # Forward pass: compute predicted y using operations; we compute
+    # P3 using our custom autograd operation.
+    y_pred = a + b * P3(c + d * x)
+
+    # Compute and print loss
+    loss = (y_pred - y).pow(2).sum()
+    if t % 100 == 99:
+        print(t, loss.item())
+
+    # Use autograd to compute the backward pass.
+    loss.backward()
+
+    # Update weights using gradient descent
+    with torch.no_grad():
+        a -= learning_rate * a.grad
+        b -= learning_rate * b.grad
+        c -= learning_rate * c.grad
+        d -= learning_rate * d.grad
+
+        # Manually zero the gradients after updating weights
+        a.grad = None
+        b.grad = None
+        c.grad = None
+        d.grad = None
+
+print(f'Result: y = {a.item()} + {b.item()} * P3({c.item()} + {d.item()} x)')
diff --git a/beginner_source/examples_autograd/tf_two_layer_net.py b/beginner_source/examples_autograd/tf_two_layer_net.py
deleted file mode 100755
index 6c2a1aa714b..00000000000
--- a/beginner_source/examples_autograd/tf_two_layer_net.py
+++ /dev/null
@@ -1,78 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-TensorFlow: Static Graphs
--------------------------
-
-A fully-connected ReLU network with one hidden layer and no biases, trained to
-predict y from x by minimizing squared Euclidean distance.
-
-This implementation uses basic TensorFlow operations to set up a computational
-graph, then executes the graph many times to actually train the network.
-
-One of the main differences between TensorFlow and PyTorch is that TensorFlow
-uses static computational graphs while PyTorch uses dynamic computational
-graphs.
-
-In TensorFlow we first set up the computational graph, then execute the same
-graph many times.
-"""
-import tensorflow as tf
-import numpy as np
-
-# First we set up the computational graph:
-
-# N is batch size; D_in is input dimension;
-# H is hidden dimension; D_out is output dimension.
-N, D_in, H, D_out = 64, 1000, 100, 10
-
-# Create placeholders for the input and target data; these will be filled
-# with real data when we execute the graph.
-x = tf.placeholder(tf.float32, shape=(None, D_in))
-y = tf.placeholder(tf.float32, shape=(None, D_out))
-
-# Create Variables for the weights and initialize them with random data.
-# A TensorFlow Variable persists its value across executions of the graph.
-w1 = tf.Variable(tf.random_normal((D_in, H)))
-w2 = tf.Variable(tf.random_normal((H, D_out)))
-
-# Forward pass: Compute the predicted y using operations on TensorFlow Tensors.
-# Note that this code does not actually perform any numeric operations; it
-# merely sets up the computational graph that we will later execute.
-h = tf.matmul(x, w1)
-h_relu = tf.maximum(h, tf.zeros(1))
-y_pred = tf.matmul(h_relu, w2)
-
-# Compute loss using operations on TensorFlow Tensors
-loss = tf.reduce_sum((y - y_pred) ** 2.0)
-
-# Compute gradient of the loss with respect to w1 and w2.
-grad_w1, grad_w2 = tf.gradients(loss, [w1, w2])
-
-# Update the weights using gradient descent. To actually update the weights
-# we need to evaluate new_w1 and new_w2 when executing the graph. Note that
-# in TensorFlow the the act of updating the value of the weights is part of
-# the computational graph; in PyTorch this happens outside the computational
-# graph.
-learning_rate = 1e-6
-new_w1 = w1.assign(w1 - learning_rate * grad_w1)
-new_w2 = w2.assign(w2 - learning_rate * grad_w2)
-
-# Now we have built our computational graph, so we enter a TensorFlow session to
-# actually execute the graph.
-with tf.Session() as sess:
-    # Run the graph once to initialize the Variables w1 and w2.
-    sess.run(tf.global_variables_initializer())
-
-    # Create numpy arrays holding the actual data for the inputs x and targets
-    # y
-    x_value = np.random.randn(N, D_in)
-    y_value = np.random.randn(N, D_out)
-    for _ in range(500):
-        # Execute the graph many times. Each time it executes we want to bind
-        # x_value to x and y_value to y, specified with the feed_dict argument.
-        # Each time we execute the graph we want to compute the values for loss,
-        # new_w1, and new_w2; the values of these Tensors are returned as numpy
-        # arrays.
-        loss_value, _, _ = sess.run([loss, new_w1, new_w2],
-                                    feed_dict={x: x_value, y: y_value})
-        print(loss_value)
diff --git a/beginner_source/examples_autograd/two_layer_net_autograd.py b/beginner_source/examples_autograd/two_layer_net_autograd.py
deleted file mode 100755
index beab57a9afb..00000000000
--- a/beginner_source/examples_autograd/two_layer_net_autograd.py
+++ /dev/null
@@ -1,72 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-PyTorch: Tensors and autograd
--------------------------------
-
-A fully-connected ReLU network with one hidden layer and no biases, trained to
-predict y from x by minimizing squared Euclidean distance.
-
-This implementation computes the forward pass using operations on PyTorch
-Tensors, and uses PyTorch autograd to compute gradients.
-
-
-A PyTorch Tensor represents a node in a computational graph. If ``x`` is a
-Tensor that has ``x.requires_grad=True`` then ``x.grad`` is another Tensor
-holding the gradient of ``x`` with respect to some scalar value.
-"""
-import torch
-
-dtype = torch.float
-device = torch.device("cpu")
-# device = torch.device("cuda:0") # Uncomment this to run on GPU
-
-# N is batch size; D_in is input dimension;
-# H is hidden dimension; D_out is output dimension.
-N, D_in, H, D_out = 64, 1000, 100, 10
-
-# Create random Tensors to hold input and outputs.
-# Setting requires_grad=False indicates that we do not need to compute gradients
-# with respect to these Tensors during the backward pass.
-x = torch.randn(N, D_in, device=device, dtype=dtype)
-y = torch.randn(N, D_out, device=device, dtype=dtype)
-
-# Create random Tensors for weights.
-# Setting requires_grad=True indicates that we want to compute gradients with
-# respect to these Tensors during the backward pass.
-w1 = torch.randn(D_in, H, device=device, dtype=dtype, requires_grad=True)
-w2 = torch.randn(H, D_out, device=device, dtype=dtype, requires_grad=True)
-
-learning_rate = 1e-6
-for t in range(500):
-    # Forward pass: compute predicted y using operations on Tensors; these
-    # are exactly the same operations we used to compute the forward pass using
-    # Tensors, but we do not need to keep references to intermediate values since
-    # we are not implementing the backward pass by hand.
-    y_pred = x.mm(w1).clamp(min=0).mm(w2)
-
-    # Compute and print loss using operations on Tensors.
-    # Now loss is a Tensor of shape (1,)
-    # loss.item() gets the a scalar value held in the loss.
-    loss = (y_pred - y).pow(2).sum()
-    print(t, loss.item())
-
-    # Use autograd to compute the backward pass. This call will compute the
-    # gradient of loss with respect to all Tensors with requires_grad=True.
-    # After this call w1.grad and w2.grad will be Tensors holding the gradient
-    # of the loss with respect to w1 and w2 respectively.
-    loss.backward()
-
-    # Manually update weights using gradient descent. Wrap in torch.no_grad()
-    # because weights have requires_grad=True, but we don't need to track this
-    # in autograd.
-    # An alternative way is to operate on weight.data and weight.grad.data.
-    # Recall that tensor.data gives a tensor that shares the storage with
-    # tensor, but doesn't track history.
-    # You can also use torch.optim.SGD to achieve this.
-    with torch.no_grad():
-        w1 -= learning_rate * w1.grad
-        w2 -= learning_rate * w2.grad
-
-        # Manually zero the gradients after updating weights
-        w1.grad.zero_()
-        w2.grad.zero_()
diff --git a/beginner_source/examples_autograd/two_layer_net_custom_function.py b/beginner_source/examples_autograd/two_layer_net_custom_function.py
deleted file mode 100755
index fc4452c53a0..00000000000
--- a/beginner_source/examples_autograd/two_layer_net_custom_function.py
+++ /dev/null
@@ -1,88 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-PyTorch: Defining New autograd Functions
-----------------------------------------
-
-A fully-connected ReLU network with one hidden layer and no biases, trained to
-predict y from x by minimizing squared Euclidean distance.
-
-This implementation computes the forward pass using operations on PyTorch
-Variables, and uses PyTorch autograd to compute gradients.
-
-In this implementation we implement our own custom autograd function to perform
-the ReLU function.
-"""
-import torch
-
-
-class MyReLU(torch.autograd.Function):
-    """
-    We can implement our own custom autograd Functions by subclassing
-    torch.autograd.Function and implementing the forward and backward passes
-    which operate on Tensors.
-    """
-
-    @staticmethod
-    def forward(ctx, input):
-        """
-        In the forward pass we receive a Tensor containing the input and return
-        a Tensor containing the output. ctx is a context object that can be used
-        to stash information for backward computation. You can cache arbitrary
-        objects for use in the backward pass using the ctx.save_for_backward method.
-        """
-        ctx.save_for_backward(input)
-        return input.clamp(min=0)
-
-    @staticmethod
-    def backward(ctx, grad_output):
-        """
-        In the backward pass we receive a Tensor containing the gradient of the loss
-        with respect to the output, and we need to compute the gradient of the loss
-        with respect to the input.
-        """
-        input, = ctx.saved_tensors
-        grad_input = grad_output.clone()
-        grad_input[input < 0] = 0
-        return grad_input
-
-
-dtype = torch.float
-device = torch.device("cpu")
-# device = torch.device("cuda:0") # Uncomment this to run on GPU
-
-# N is batch size; D_in is input dimension;
-# H is hidden dimension; D_out is output dimension.
-N, D_in, H, D_out = 64, 1000, 100, 10
-
-# Create random Tensors to hold input and outputs.
-x = torch.randn(N, D_in, device=device, dtype=dtype)
-y = torch.randn(N, D_out, device=device, dtype=dtype)
-
-# Create random Tensors for weights.
-w1 = torch.randn(D_in, H, device=device, dtype=dtype, requires_grad=True)
-w2 = torch.randn(H, D_out, device=device, dtype=dtype, requires_grad=True)
-
-learning_rate = 1e-6
-for t in range(500):
-    # To apply our Function, we use Function.apply method. We alias this as 'relu'.
-    relu = MyReLU.apply
-
-    # Forward pass: compute predicted y using operations; we compute
-    # ReLU using our custom autograd operation.
-    y_pred = relu(x.mm(w1)).mm(w2)
-
-    # Compute and print loss
-    loss = (y_pred - y).pow(2).sum()
-    print(t, loss.item())
-
-    # Use autograd to compute the backward pass.
-    loss.backward()
-
-    # Update weights using gradient descent
-    with torch.no_grad():
-        w1 -= learning_rate * w1.grad
-        w2 -= learning_rate * w2.grad
-
-        # Manually zero the gradients after updating weights
-        w1.grad.zero_()
-        w2.grad.zero_()
diff --git a/beginner_source/examples_nn/dynamic_net.py b/beginner_source/examples_nn/dynamic_net.py
index 5054432416f..b24ced1cc58 100755
--- a/beginner_source/examples_nn/dynamic_net.py
+++ b/beginner_source/examples_nn/dynamic_net.py
@@ -4,70 +4,74 @@
 --------------------------------------
 
 To showcase the power of PyTorch dynamic graphs, we will implement a very strange
-model: a fully-connected ReLU network that on each forward pass randomly chooses
-a number between 1 and 4 and has that many hidden layers, reusing the same
-weights multiple times to compute the innermost hidden layers.
+model: a third-fifth order polynomial that on each forward pass
+chooses a random number between 4 and 5 and uses that many orders, reusing
+the same weights multiple times to compute the fourth and fifth order.
 """
 import random
 import torch
+import math
 
 
 class DynamicNet(torch.nn.Module):
-    def __init__(self, D_in, H, D_out):
+    def __init__(self):
         """
-        In the constructor we construct three nn.Linear instances that we will use
-        in the forward pass.
+        In the constructor we instantiate five parameters and assign them as members.
         """
-        super(DynamicNet, self).__init__()
-        self.input_linear = torch.nn.Linear(D_in, H)
-        self.middle_linear = torch.nn.Linear(H, H)
-        self.output_linear = torch.nn.Linear(H, D_out)
+        super().__init__()
+        self.a = torch.nn.Parameter(torch.randn(()))
+        self.b = torch.nn.Parameter(torch.randn(()))
+        self.c = torch.nn.Parameter(torch.randn(()))
+        self.d = torch.nn.Parameter(torch.randn(()))
+        self.e = torch.nn.Parameter(torch.randn(()))
 
     def forward(self, x):
         """
-        For the forward pass of the model, we randomly choose either 0, 1, 2, or 3
-        and reuse the middle_linear Module that many times to compute hidden layer
-        representations.
+        For the forward pass of the model, we randomly choose either 4, 5
+        and reuse the e parameter to compute the contribution of these orders.
 
         Since each forward pass builds a dynamic computation graph, we can use normal
         Python control-flow operators like loops or conditional statements when
         defining the forward pass of the model.
 
-        Here we also see that it is perfectly safe to reuse the same Module many
-        times when defining a computational graph. This is a big improvement from Lua
-        Torch, where each Module could be used only once.
+        Here we also see that it is perfectly safe to reuse the same parameter many
+        times when defining a computational graph.
         """
-        h_relu = self.input_linear(x).clamp(min=0)
-        for _ in range(random.randint(0, 3)):
-            h_relu = self.middle_linear(h_relu).clamp(min=0)
-        y_pred = self.output_linear(h_relu)
-        return y_pred
+        y = self.a + self.b * x + self.c * x ** 2 + self.d * x ** 3
+        for exp in range(4, random.randint(4, 6)):
+            y = y + self.e * x ** exp
+        return y
 
+    def string(self):
+        """
+        Just like any class in Python, you can also define custom method on PyTorch modules
+        """
+        return f'y = {self.a.item()} + {self.b.item()} x + {self.c.item()} x^2 + {self.d.item()} x^3 + {self.e.item()} x^4 ? + {self.e.item()} x^5 ?'
 
-# N is batch size; D_in is input dimension;
-# H is hidden dimension; D_out is output dimension.
-N, D_in, H, D_out = 64, 1000, 100, 10
 
-# Create random Tensors to hold inputs and outputs
-x = torch.randn(N, D_in)
-y = torch.randn(N, D_out)
+# Create Tensors to hold input and outputs.
+x = torch.linspace(-math.pi, math.pi, 2000)
+y = torch.sin(x)
 
 # Construct our model by instantiating the class defined above
-model = DynamicNet(D_in, H, D_out)
+model = DynamicNet()
 
 # Construct our loss function and an Optimizer. Training this strange model with
 # vanilla stochastic gradient descent is tough, so we use momentum
 criterion = torch.nn.MSELoss(reduction='sum')
-optimizer = torch.optim.SGD(model.parameters(), lr=1e-4, momentum=0.9)
-for t in range(500):
+optimizer = torch.optim.SGD(model.parameters(), lr=1e-8, momentum=0.9)
+for t in range(30000):
     # Forward pass: Compute predicted y by passing x to the model
     y_pred = model(x)
 
     # Compute and print loss
     loss = criterion(y_pred, y)
-    print(t, loss.item())
+    if t % 2000 == 1999:
+        print(t, loss.item())
 
     # Zero gradients, perform a backward pass, and update the weights.
     optimizer.zero_grad()
     loss.backward()
     optimizer.step()
+
+print(f'Result: {model.string()}')
diff --git a/beginner_source/examples_nn/polynomial_module.py b/beginner_source/examples_nn/polynomial_module.py
new file mode 100755
index 00000000000..77b44ae1a5d
--- /dev/null
+++ b/beginner_source/examples_nn/polynomial_module.py
@@ -0,0 +1,70 @@
+# -*- coding: utf-8 -*-
+"""
+PyTorch: Custom nn Modules
+--------------------------
+
+A third order polynomial, trained to predict :math:`y=\sin(x)` from :math:`-\pi`
+to :math:`\pi` by minimizing squared Euclidean distance.
+
+This implementation defines the model as a custom Module subclass. Whenever you
+want a model more complex than a simple sequence of existing Modules you will
+need to define your model this way.
+"""
+import torch
+import math
+
+
+class Polynomial3(torch.nn.Module):
+    def __init__(self):
+        """
+        In the constructor we instantiate four parameters and assign them as
+        member parameters.
+        """
+        super().__init__()
+        self.a = torch.nn.Parameter(torch.randn(()))
+        self.b = torch.nn.Parameter(torch.randn(()))
+        self.c = torch.nn.Parameter(torch.randn(()))
+        self.d = torch.nn.Parameter(torch.randn(()))
+
+    def forward(self, x):
+        """
+        In the forward function we accept a Tensor of input data and we must return
+        a Tensor of output data. We can use Modules defined in the constructor as
+        well as arbitrary operators on Tensors.
+        """
+        return self.a + self.b * x + self.c * x ** 2 + self.d * x ** 3
+
+    def string(self):
+        """
+        Just like any class in Python, you can also define custom method on PyTorch modules
+        """
+        return f'y = {self.a.item()} + {self.b.item()} x + {self.c.item()} x^2 + {self.d.item()} x^3'
+
+
+# Create Tensors to hold input and outputs.
+x = torch.linspace(-math.pi, math.pi, 2000)
+y = torch.sin(x)
+
+# Construct our model by instantiating the class defined above
+model = Polynomial3()
+
+# Construct our loss function and an Optimizer. The call to model.parameters()
+# in the SGD constructor will contain the learnable parameters (defined 
+# with torch.nn.Parameter) which are members of the model.
+criterion = torch.nn.MSELoss(reduction='sum')
+optimizer = torch.optim.SGD(model.parameters(), lr=1e-6)
+for t in range(2000):
+    # Forward pass: Compute predicted y by passing x to the model
+    y_pred = model(x)
+
+    # Compute and print loss
+    loss = criterion(y_pred, y)
+    if t % 100 == 99:
+        print(t, loss.item())
+
+    # Zero gradients, perform a backward pass, and update the weights.
+    optimizer.zero_grad()
+    loss.backward()
+    optimizer.step()
+
+print(f'Result: {model.string()}')
diff --git a/beginner_source/examples_nn/two_layer_net_nn.py b/beginner_source/examples_nn/polynomial_nn.py
similarity index 58%
rename from beginner_source/examples_nn/two_layer_net_nn.py
rename to beginner_source/examples_nn/polynomial_nn.py
index 51bf623b01b..70e281ed365 100755
--- a/beginner_source/examples_nn/two_layer_net_nn.py
+++ b/beginner_source/examples_nn/polynomial_nn.py
@@ -3,53 +3,64 @@
 PyTorch: nn
 -----------
 
-A fully-connected ReLU network with one hidden layer, trained to predict y from x
-by minimizing squared Euclidean distance.
+A third order polynomial, trained to predict :math:`y=\sin(x)` from :math:`-\pi`
+to :math:`\pi` by minimizing squared Euclidean distance.
 
 This implementation uses the nn package from PyTorch to build the network.
 PyTorch autograd makes it easy to define computational graphs and take gradients,
 but raw autograd can be a bit too low-level for defining complex neural networks;
 this is where the nn package can help. The nn package defines a set of Modules,
-which you can think of as a neural network layer that has produces output from
+which you can think of as a neural network layer that produces output from
 input and may have some trainable weights.
 """
 import torch
+import math
 
-# N is batch size; D_in is input dimension;
-# H is hidden dimension; D_out is output dimension.
-N, D_in, H, D_out = 64, 1000, 100, 10
 
-# Create random Tensors to hold inputs and outputs
-x = torch.randn(N, D_in)
-y = torch.randn(N, D_out)
+# Create Tensors to hold input and outputs.
+x = torch.linspace(-math.pi, math.pi, 2000)
+y = torch.sin(x)
+
+# For this example, the output y is a linear function of (x, x^2, x^3), so
+# we can consider it as a linear layer neural network. Let's prepare the
+# tensor (x, x^2, x^3).
+p = torch.tensor([1, 2, 3])
+xx = x.unsqueeze(-1).pow(p)
+
+# In the above code, x.unsqueeze(-1) has shape (2000, 1), and p has shape
+# (3,), for this case, broadcasting semantics will apply to obtain a tensor
+# of shape (2000, 3) 
 
 # Use the nn package to define our model as a sequence of layers. nn.Sequential
 # is a Module which contains other Modules, and applies them in sequence to
-# produce its output. Each Linear Module computes output from input using a
+# produce its output. The Linear Module computes output from input using a
 # linear function, and holds internal Tensors for its weight and bias.
+# The Flatten layer flatens the output of the linear layer to a 1D tensor,
+# to match the shape of `y`.
 model = torch.nn.Sequential(
-    torch.nn.Linear(D_in, H),
-    torch.nn.ReLU(),
-    torch.nn.Linear(H, D_out),
+    torch.nn.Linear(3, 1),
+    torch.nn.Flatten(0, 1)
 )
 
 # The nn package also contains definitions of popular loss functions; in this
 # case we will use Mean Squared Error (MSE) as our loss function.
 loss_fn = torch.nn.MSELoss(reduction='sum')
 
-learning_rate = 1e-4
-for t in range(500):
+learning_rate = 1e-6
+for t in range(2000):
+
     # Forward pass: compute predicted y by passing x to the model. Module objects
     # override the __call__ operator so you can call them like functions. When
     # doing so you pass a Tensor of input data to the Module and it produces
     # a Tensor of output data.
-    y_pred = model(x)
+    y_pred = model(xx)
 
     # Compute and print loss. We pass Tensors containing the predicted and true
     # values of y, and the loss function returns a Tensor containing the
     # loss.
     loss = loss_fn(y_pred, y)
-    print(t, loss.item())
+    if t % 100 == 99:
+        print(t, loss.item())
 
     # Zero the gradients before running the backward pass.
     model.zero_grad()
@@ -65,3 +76,9 @@
     with torch.no_grad():
         for param in model.parameters():
             param -= learning_rate * param.grad
+
+# You can access the first layer of `model` like accessing the first item of a list
+linear_layer = model[0]
+
+# For linear layer, its parameters are stored as `weight` and `bias`.
+print(f'Result: y = {linear_layer.bias.item()} + {linear_layer.weight[:, 0].item()} x + {linear_layer.weight[:, 1].item()} x^2 + {linear_layer.weight[:, 2].item()} x^3')
diff --git a/beginner_source/examples_nn/two_layer_net_optim.py b/beginner_source/examples_nn/polynomial_optim.py
similarity index 60%
rename from beginner_source/examples_nn/two_layer_net_optim.py
rename to beginner_source/examples_nn/polynomial_optim.py
index 62c44cd0911..c0d4896c8f2 100755
--- a/beginner_source/examples_nn/two_layer_net_optim.py
+++ b/beginner_source/examples_nn/polynomial_optim.py
@@ -3,8 +3,8 @@
 PyTorch: optim
 --------------
 
-A fully-connected ReLU network with one hidden layer, trained to predict y from x
-by minimizing squared Euclidean distance.
+A third order polynomial, trained to predict :math:`y=\sin(x)` from :math:`-\pi`
+to :math:`\pi` by minimizing squared Euclidean distance.
 
 This implementation uses the nn package from PyTorch to build the network.
 
@@ -14,36 +14,38 @@
 used for deep learning, including SGD+momentum, RMSProp, Adam, etc.
 """
 import torch
+import math
 
-# N is batch size; D_in is input dimension;
-# H is hidden dimension; D_out is output dimension.
-N, D_in, H, D_out = 64, 1000, 100, 10
 
-# Create random Tensors to hold inputs and outputs
-x = torch.randn(N, D_in)
-y = torch.randn(N, D_out)
+# Create Tensors to hold input and outputs.
+x = torch.linspace(-math.pi, math.pi, 2000)
+y = torch.sin(x)
+
+# Prepare the input tensor (x, x^2, x^3).
+p = torch.tensor([1, 2, 3])
+xx = x.unsqueeze(-1).pow(p)
 
 # Use the nn package to define our model and loss function.
 model = torch.nn.Sequential(
-    torch.nn.Linear(D_in, H),
-    torch.nn.ReLU(),
-    torch.nn.Linear(H, D_out),
+    torch.nn.Linear(3, 1),
+    torch.nn.Flatten(0, 1)
 )
 loss_fn = torch.nn.MSELoss(reduction='sum')
 
 # Use the optim package to define an Optimizer that will update the weights of
-# the model for us. Here we will use Adam; the optim package contains many other
-# optimization algoriths. The first argument to the Adam constructor tells the
+# the model for us. Here we will use RMSprop; the optim package contains many other
+# optimization algorithms. The first argument to the RMSprop constructor tells the
 # optimizer which Tensors it should update.
-learning_rate = 1e-4
-optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
-for t in range(500):
+learning_rate = 1e-3
+optimizer = torch.optim.RMSprop(model.parameters(), lr=learning_rate)
+for t in range(2000):
     # Forward pass: compute predicted y by passing x to the model.
-    y_pred = model(x)
+    y_pred = model(xx)
 
     # Compute and print loss.
     loss = loss_fn(y_pred, y)
-    print(t, loss.item())
+    if t % 100 == 99:
+        print(t, loss.item())
 
     # Before the backward pass, use the optimizer object to zero all of the
     # gradients for the variables it will update (which are the learnable
@@ -59,3 +61,7 @@
     # Calling the step function on an Optimizer makes an update to its
     # parameters
     optimizer.step()
+
+
+linear_layer = model[0]
+print(f'Result: y = {linear_layer.bias.item()} + {linear_layer.weight[:, 0].item()} x + {linear_layer.weight[:, 1].item()} x^2 + {linear_layer.weight[:, 2].item()} x^3')
diff --git a/beginner_source/examples_nn/two_layer_net_module.py b/beginner_source/examples_nn/two_layer_net_module.py
deleted file mode 100755
index bf010efc05c..00000000000
--- a/beginner_source/examples_nn/two_layer_net_module.py
+++ /dev/null
@@ -1,64 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-PyTorch: Custom nn Modules
---------------------------
-
-A fully-connected ReLU network with one hidden layer, trained to predict y from x
-by minimizing squared Euclidean distance.
-
-This implementation defines the model as a custom Module subclass. Whenever you
-want a model more complex than a simple sequence of existing Modules you will
-need to define your model this way.
-"""
-import torch
-
-
-class TwoLayerNet(torch.nn.Module):
-    def __init__(self, D_in, H, D_out):
-        """
-        In the constructor we instantiate two nn.Linear modules and assign them as
-        member variables.
-        """
-        super(TwoLayerNet, self).__init__()
-        self.linear1 = torch.nn.Linear(D_in, H)
-        self.linear2 = torch.nn.Linear(H, D_out)
-
-    def forward(self, x):
-        """
-        In the forward function we accept a Tensor of input data and we must return
-        a Tensor of output data. We can use Modules defined in the constructor as
-        well as arbitrary operators on Tensors.
-        """
-        h_relu = self.linear1(x).clamp(min=0)
-        y_pred = self.linear2(h_relu)
-        return y_pred
-
-
-# N is batch size; D_in is input dimension;
-# H is hidden dimension; D_out is output dimension.
-N, D_in, H, D_out = 64, 1000, 100, 10
-
-# Create random Tensors to hold inputs and outputs
-x = torch.randn(N, D_in)
-y = torch.randn(N, D_out)
-
-# Construct our model by instantiating the class defined above
-model = TwoLayerNet(D_in, H, D_out)
-
-# Construct our loss function and an Optimizer. The call to model.parameters()
-# in the SGD constructor will contain the learnable parameters of the two
-# nn.Linear modules which are members of the model.
-criterion = torch.nn.MSELoss(reduction='sum')
-optimizer = torch.optim.SGD(model.parameters(), lr=1e-4)
-for t in range(500):
-    # Forward pass: Compute predicted y by passing x to the model
-    y_pred = model(x)
-
-    # Compute and print loss
-    loss = criterion(y_pred, y)
-    print(t, loss.item())
-
-    # Zero gradients, perform a backward pass, and update the weights.
-    optimizer.zero_grad()
-    loss.backward()
-    optimizer.step()
diff --git a/beginner_source/examples_tensor/polynomial_numpy.py b/beginner_source/examples_tensor/polynomial_numpy.py
new file mode 100755
index 00000000000..059ec286ee4
--- /dev/null
+++ b/beginner_source/examples_tensor/polynomial_numpy.py
@@ -0,0 +1,53 @@
+# -*- coding: utf-8 -*-
+"""
+Warm-up: numpy
+--------------
+
+A third order polynomial, trained to predict :math:`y=\sin(x)` from :math:`-\pi`
+to :math:`\pi` by minimizing squared Euclidean distance.
+
+This implementation uses numpy to manually compute the forward pass, loss, and
+backward pass.
+
+A numpy array is a generic n-dimensional array; it does not know anything about
+deep learning or gradients or computational graphs, and is just a way to perform
+generic numeric computations.
+"""
+import numpy as np
+import math
+
+# Create random input and output data
+x = np.linspace(-math.pi, math.pi, 2000)
+y = np.sin(x)
+
+# Randomly initialize weights
+a = np.random.randn()
+b = np.random.randn()
+c = np.random.randn()
+d = np.random.randn()
+
+learning_rate = 1e-6
+for t in range(2000):
+    # Forward pass: compute predicted y
+    # y = a + b x + c x^2 + d x^3
+    y_pred = a + b * x + c * x ** 2 + d * x ** 3
+
+    # Compute and print loss
+    loss = np.square(y_pred - y).sum()
+    if t % 100 == 99:
+        print(t, loss)
+
+    # Backprop to compute gradients of a, b, c, d with respect to loss
+    grad_y_pred = 2.0 * (y_pred - y)
+    grad_a = grad_y_pred.sum()
+    grad_b = (grad_y_pred * x).sum()
+    grad_c = (grad_y_pred * x ** 2).sum()
+    grad_d = (grad_y_pred * x ** 3).sum()
+
+    # Update weights
+    a -= learning_rate * grad_a
+    b -= learning_rate * grad_b
+    c -= learning_rate * grad_c
+    d -= learning_rate * grad_d
+
+print(f'Result: y = {a} + {b} x + {c} x^2 + {d} x^3')
diff --git a/beginner_source/examples_tensor/two_layer_net_tensor.py b/beginner_source/examples_tensor/polynomial_tensor.py
similarity index 50%
rename from beginner_source/examples_tensor/two_layer_net_tensor.py
rename to beginner_source/examples_tensor/polynomial_tensor.py
index e3cb4949bbf..260cf8d2849 100755
--- a/beginner_source/examples_tensor/two_layer_net_tensor.py
+++ b/beginner_source/examples_tensor/polynomial_tensor.py
@@ -3,8 +3,8 @@
 PyTorch: Tensors
 ----------------
 
-A fully-connected ReLU network with one hidden layer and no biases, trained to
-predict y from x by minimizing squared Euclidean distance.
+A third order polynomial, trained to predict :math:`y=\sin(x)` from :math:`-\pi`
+to :math:`\pi` by minimizing squared Euclidean distance.
 
 This implementation uses PyTorch tensors to manually compute the forward pass,
 loss, and backward pass.
@@ -19,43 +19,45 @@
 """
 
 import torch
+import math
 
 
 dtype = torch.float
 device = torch.device("cpu")
 # device = torch.device("cuda:0") # Uncomment this to run on GPU
 
-# N is batch size; D_in is input dimension;
-# H is hidden dimension; D_out is output dimension.
-N, D_in, H, D_out = 64, 1000, 100, 10
-
 # Create random input and output data
-x = torch.randn(N, D_in, device=device, dtype=dtype)
-y = torch.randn(N, D_out, device=device, dtype=dtype)
+x = torch.linspace(-math.pi, math.pi, 2000, device=device, dtype=dtype)
+y = torch.sin(x)
 
 # Randomly initialize weights
-w1 = torch.randn(D_in, H, device=device, dtype=dtype)
-w2 = torch.randn(H, D_out, device=device, dtype=dtype)
+a = torch.randn((), device=device, dtype=dtype)
+b = torch.randn((), device=device, dtype=dtype)
+c = torch.randn((), device=device, dtype=dtype)
+d = torch.randn((), device=device, dtype=dtype)
 
 learning_rate = 1e-6
-for t in range(500):
+for t in range(2000):
     # Forward pass: compute predicted y
-    h = x.mm(w1)
-    h_relu = h.clamp(min=0)
-    y_pred = h_relu.mm(w2)
+    y_pred = a + b * x + c * x ** 2 + d * x ** 3
 
     # Compute and print loss
     loss = (y_pred - y).pow(2).sum().item()
-    print(t, loss)
+    if t % 100 == 99:
+        print(t, loss)
 
-    # Backprop to compute gradients of w1 and w2 with respect to loss
+    # Backprop to compute gradients of a, b, c, d with respect to loss
     grad_y_pred = 2.0 * (y_pred - y)
-    grad_w2 = h_relu.t().mm(grad_y_pred)
-    grad_h_relu = grad_y_pred.mm(w2.t())
-    grad_h = grad_h_relu.clone()
-    grad_h[h < 0] = 0
-    grad_w1 = x.t().mm(grad_h)
+    grad_a = grad_y_pred.sum()
+    grad_b = (grad_y_pred * x).sum()
+    grad_c = (grad_y_pred * x ** 2).sum()
+    grad_d = (grad_y_pred * x ** 3).sum()
 
     # Update weights using gradient descent
-    w1 -= learning_rate * grad_w1
-    w2 -= learning_rate * grad_w2
+    a -= learning_rate * grad_a
+    b -= learning_rate * grad_b
+    c -= learning_rate * grad_c
+    d -= learning_rate * grad_d
+
+
+print(f'Result: y = {a.item()} + {b.item()} x + {c.item()} x^2 + {d.item()} x^3')
diff --git a/beginner_source/examples_tensor/two_layer_net_numpy.py b/beginner_source/examples_tensor/two_layer_net_numpy.py
deleted file mode 100755
index f003d0f002b..00000000000
--- a/beginner_source/examples_tensor/two_layer_net_numpy.py
+++ /dev/null
@@ -1,51 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-Warm-up: numpy
---------------
-
-A fully-connected ReLU network with one hidden layer and no biases, trained to
-predict y from x using Euclidean error.
-
-This implementation uses numpy to manually compute the forward pass, loss, and
-backward pass.
-
-A numpy array is a generic n-dimensional array; it does not know anything about
-deep learning or gradients or computational graphs, and is just a way to perform
-generic numeric computations.
-"""
-import numpy as np
-
-# N is batch size; D_in is input dimension;
-# H is hidden dimension; D_out is output dimension.
-N, D_in, H, D_out = 64, 1000, 100, 10
-
-# Create random input and output data
-x = np.random.randn(N, D_in)
-y = np.random.randn(N, D_out)
-
-# Randomly initialize weights
-w1 = np.random.randn(D_in, H)
-w2 = np.random.randn(H, D_out)
-
-learning_rate = 1e-6
-for t in range(500):
-    # Forward pass: compute predicted y
-    h = x.dot(w1)
-    h_relu = np.maximum(h, 0)
-    y_pred = h_relu.dot(w2)
-
-    # Compute and print loss
-    loss = np.square(y_pred - y).sum()
-    print(t, loss)
-
-    # Backprop to compute gradients of w1 and w2 with respect to loss
-    grad_y_pred = 2.0 * (y_pred - y)
-    grad_w2 = h_relu.T.dot(grad_y_pred)
-    grad_h_relu = grad_y_pred.dot(w2.T)
-    grad_h = grad_h_relu.copy()
-    grad_h[h < 0] = 0
-    grad_w1 = x.T.dot(grad_h)
-
-    # Update weights
-    w1 -= learning_rate * grad_w1
-    w2 -= learning_rate * grad_w2
diff --git a/beginner_source/fgsm_tutorial.py b/beginner_source/fgsm_tutorial.py
index a2d7fd47f15..a991fe85627 100644
--- a/beginner_source/fgsm_tutorial.py
+++ b/beginner_source/fgsm_tutorial.py
@@ -17,7 +17,7 @@
 machine learning. You may be surprised to find that adding imperceptible
 perturbations to an image *can* cause drastically different model
 performance. Given that this is a tutorial, we will explore the topic
-via example on an image classifier. Specifically we will use one of the
+via example on an image classifier. Specifically, we will use one of the
 first and most popular attack methods, the Fast Gradient Sign Attack
 (FGSM), to fool an MNIST classifier.
 
@@ -27,7 +27,7 @@
 ######################################################################
 # Threat Model
 # ------------
-# 
+#
 # For context, there are many categories of adversarial attacks, each with
 # a different goal and assumption of the attacker’s knowledge. However, in
 # general the overarching goal is to add the least amount of perturbation
@@ -45,14 +45,14 @@
 # misclassification* means the adversary wants to alter an image that is
 # originally of a specific source class so that it is classified as a
 # specific target class.
-# 
+#
 # In this case, the FGSM attack is a *white-box* attack with the goal of
 # *misclassification*. With this background information, we can now
 # discuss the attack in detail.
-# 
+#
 # Fast Gradient Sign Attack
 # -------------------------
-# 
+#
 # One of the first and most popular adversarial attacks to date is
 # referred to as the *Fast Gradient Sign Attack (FGSM)* and is described
 # by Goodfellow et. al. in `Explaining and Harnessing Adversarial
@@ -64,7 +64,7 @@
 # the loss* based on the same backpropagated gradients. In other words,
 # the attack uses the gradient of the loss w.r.t the input data, then
 # adjusts the input data to maximize the loss.
-# 
+#
 # Before we jump into the code, let’s look at the famous
 # `FGSM <https://arxiv.org/abs/1412.6572>`__ panda example and extract
 # some notation.
@@ -85,12 +85,11 @@
 # maximize the loss. The resulting perturbed image, :math:`x'`, is then
 # *misclassified* by the target network as a “gibbon” when it is still
 # clearly a “panda”.
-# 
+#
 # Hopefully now the motivation for this tutorial is clear, so lets jump
 # into the implementation.
-# 
+#
 
-from __future__ import print_function
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
@@ -103,43 +102,40 @@
 ######################################################################
 # Implementation
 # --------------
-# 
+#
 # In this section, we will discuss the input parameters for the tutorial,
 # define the model under attack, then code the attack and run some tests.
-# 
+#
 # Inputs
 # ~~~~~~
-# 
+#
 # There are only three inputs for this tutorial, and are defined as
 # follows:
-# 
-# -  **epsilons** - List of epsilon values to use for the run. It is
+#
+# -  ``epsilons`` - List of epsilon values to use for the run. It is
 #    important to keep 0 in the list because it represents the model
 #    performance on the original test set. Also, intuitively we would
 #    expect the larger the epsilon, the more noticeable the perturbations
 #    but the more effective the attack in terms of degrading model
 #    accuracy. Since the data range here is :math:`[0,1]`, no epsilon
 #    value should exceed 1.
-# 
-# -  **pretrained_model** - path to the pretrained MNIST model which was
+#
+# -  ``pretrained_model`` - path to the pretrained MNIST model which was
 #    trained with
 #    `pytorch/examples/mnist <https://github.com/pytorch/examples/tree/master/mnist>`__.
-#    For simplicity, download the pretrained model `here <https://drive.google.com/drive/folders/1fn83DF14tWmit0RTKWRhPq5uVXt73e0h?usp=sharing>`__.
-# 
-# -  **use_cuda** - boolean flag to use CUDA if desired and available.
-#    Note, a GPU with CUDA is not critical for this tutorial as a CPU will
-#    not take much time.
-# 
+#    For simplicity, download the pretrained model `here <https://drive.google.com/file/d/1HJV2nUHJqclXQ8flKvcWmjZ-OU5DGatl/view?usp=drive_link>`__.
+#
 
 epsilons = [0, .05, .1, .15, .2, .25, .3]
 pretrained_model = "data/lenet_mnist_model.pth"
-use_cuda=True
+# Set random seed for reproducibility
+torch.manual_seed(42)
 
 
 ######################################################################
 # Model Under Attack
 # ~~~~~~~~~~~~~~~~~~
-# 
+#
 # As mentioned, the model under attack is the same MNIST model from
 # `pytorch/examples/mnist <https://github.com/pytorch/examples/tree/master/mnist>`__.
 # You may train and save your own MNIST model or you can download and use
@@ -147,43 +143,52 @@
 # been copied from the MNIST example. The purpose of this section is to
 # define the model and dataloader, then initialize the model and load the
 # pretrained weights.
-# 
+#
 
 # LeNet Model definition
 class Net(nn.Module):
     def __init__(self):
         super(Net, self).__init__()
-        self.conv1 = nn.Conv2d(1, 10, kernel_size=5)
-        self.conv2 = nn.Conv2d(10, 20, kernel_size=5)
-        self.conv2_drop = nn.Dropout2d()
-        self.fc1 = nn.Linear(320, 50)
-        self.fc2 = nn.Linear(50, 10)
+        self.conv1 = nn.Conv2d(1, 32, 3, 1)
+        self.conv2 = nn.Conv2d(32, 64, 3, 1)
+        self.dropout1 = nn.Dropout(0.25)
+        self.dropout2 = nn.Dropout(0.5)
+        self.fc1 = nn.Linear(9216, 128)
+        self.fc2 = nn.Linear(128, 10)
 
     def forward(self, x):
-        x = F.relu(F.max_pool2d(self.conv1(x), 2))
-        x = F.relu(F.max_pool2d(self.conv2_drop(self.conv2(x)), 2))
-        x = x.view(-1, 320)
-        x = F.relu(self.fc1(x))
-        x = F.dropout(x, training=self.training)
+        x = self.conv1(x)
+        x = F.relu(x)
+        x = self.conv2(x)
+        x = F.relu(x)
+        x = F.max_pool2d(x, 2)
+        x = self.dropout1(x)
+        x = torch.flatten(x, 1)
+        x = self.fc1(x)
+        x = F.relu(x)
+        x = self.dropout2(x)
         x = self.fc2(x)
-        return F.log_softmax(x, dim=1)
+        output = F.log_softmax(x, dim=1)
+        return output
 
 # MNIST Test dataset and dataloader declaration
 test_loader = torch.utils.data.DataLoader(
     datasets.MNIST('../data', train=False, download=True, transform=transforms.Compose([
             transforms.ToTensor(),
-            ])), 
+            transforms.Normalize((0.1307,), (0.3081,)),
+            ])),
         batch_size=1, shuffle=True)
 
-# Define what device we are using
-print("CUDA Available: ",torch.cuda.is_available())
-device = torch.device("cuda" if (use_cuda and torch.cuda.is_available()) else "cpu")
+# We want to be able to train our model on an `accelerator <https://pytorch.org/docs/stable/torch.html#accelerators>`__
+# such as CUDA, MPS, MTIA, or XPU. If the current accelerator is available, we will use it. Otherwise, we use the CPU.
+device = torch.accelerator.current_accelerator().type if torch.accelerator.is_available() else "cpu"
+print(f"Using {device} device")
 
 # Initialize the network
 model = Net().to(device)
 
 # Load the pretrained model
-model.load_state_dict(torch.load(pretrained_model, map_location='cpu'))
+model.load_state_dict(torch.load(pretrained_model, map_location=device, weights_only=True))
 
 # Set the model in evaluation mode. In this case this is for the Dropout layers
 model.eval()
@@ -192,7 +197,7 @@ def forward(self, x):
 ######################################################################
 # FGSM Attack
 # ~~~~~~~~~~~
-# 
+#
 # Now, we can define the function that creates the adversarial examples by
 # perturbing the original inputs. The ``fgsm_attack`` function takes three
 # inputs, *image* is the original clean image (:math:`x`), *epsilon* is
@@ -200,12 +205,12 @@ def forward(self, x):
 # is gradient of the loss w.r.t the input image
 # (:math:`\nabla_{x} J(\mathbf{\theta}, \mathbf{x}, y)`). The function
 # then creates perturbed image as
-# 
+#
 # .. math:: perturbed\_image = image + epsilon*sign(data\_grad) = x + \epsilon * sign(\nabla_{x} J(\mathbf{\theta}, \mathbf{x}, y))
-# 
+#
 # Finally, in order to maintain the original range of the data, the
 # perturbed image is clipped to range :math:`[0,1]`.
-# 
+#
 
 # FGSM attack code
 def fgsm_attack(image, epsilon, data_grad):
@@ -218,11 +223,31 @@ def fgsm_attack(image, epsilon, data_grad):
     # Return the perturbed image
     return perturbed_image
 
+# restores the tensors to their original scale
+def denorm(batch, mean=[0.1307], std=[0.3081]):
+    """
+    Convert a batch of tensors to their original scale.
+
+    Args:
+        batch (torch.Tensor): Batch of normalized tensors.
+        mean (torch.Tensor or list): Mean used for normalization.
+        std (torch.Tensor or list): Standard deviation used for normalization.
+
+    Returns:
+        torch.Tensor: batch of tensors without normalization applied to them.
+    """
+    if isinstance(mean, list):
+        mean = torch.tensor(mean).to(device)
+    if isinstance(std, list):
+        std = torch.tensor(std).to(device)
+
+    return batch * std.view(1, -1, 1, 1) + mean.view(1, -1, 1, 1)
+
 
 ######################################################################
 # Testing Function
 # ~~~~~~~~~~~~~~~~
-# 
+#
 # Finally, the central result of this tutorial comes from the ``test``
 # function. Each call to this test function performs a full test step on
 # the MNIST test set and reports a final accuracy. However, notice that
@@ -235,7 +260,7 @@ def fgsm_attack(image, epsilon, data_grad):
 # if the perturbed example is adversarial. In addition to testing the
 # accuracy of the model, the function also saves and returns some
 # successful adversarial examples to be visualized later.
-# 
+#
 
 def test( model, device, test_loader, epsilon ):
 
@@ -256,7 +281,7 @@ def test( model, device, test_loader, epsilon ):
         output = model(data)
         init_pred = output.max(1, keepdim=True)[1] # get the index of the max log-probability
 
-        # If the initial prediction is wrong, dont bother attacking, just move on
+        # If the initial prediction is wrong, don't bother attacking, just move on
         if init_pred.item() != target.item():
             continue
 
@@ -269,21 +294,27 @@ def test( model, device, test_loader, epsilon ):
         # Calculate gradients of model in backward pass
         loss.backward()
 
-        # Collect datagrad
+        # Collect ``datagrad``
         data_grad = data.grad.data
 
+        # Restore the data to its original scale
+        data_denorm = denorm(data)
+
         # Call FGSM Attack
-        perturbed_data = fgsm_attack(data, epsilon, data_grad)
+        perturbed_data = fgsm_attack(data_denorm, epsilon, data_grad)
+
+        # Reapply normalization
+        perturbed_data_normalized = transforms.Normalize((0.1307,), (0.3081,))(perturbed_data)
 
         # Re-classify the perturbed image
-        output = model(perturbed_data)
+        output = model(perturbed_data_normalized)
 
         # Check for success
         final_pred = output.max(1, keepdim=True)[1] # get the index of the max log-probability
         if final_pred.item() == target.item():
             correct += 1
             # Special case for saving 0 epsilon examples
-            if (epsilon == 0) and (len(adv_examples) < 5):
+            if epsilon == 0 and len(adv_examples) < 5:
                 adv_ex = perturbed_data.squeeze().detach().cpu().numpy()
                 adv_examples.append( (init_pred.item(), final_pred.item(), adv_ex) )
         else:
@@ -294,7 +325,7 @@ def test( model, device, test_loader, epsilon ):
 
     # Calculate final accuracy for this epsilon
     final_acc = correct/float(len(test_loader))
-    print("Epsilon: {}\tTest Accuracy = {} / {} = {}".format(epsilon, correct, len(test_loader), final_acc))
+    print(f"Epsilon: {epsilon}\tTest Accuracy = {correct} / {len(test_loader)} = {final_acc}")
 
     # Return the accuracy and an adversarial example
     return final_acc, adv_examples
@@ -303,7 +334,7 @@ def test( model, device, test_loader, epsilon ):
 ######################################################################
 # Run Attack
 # ~~~~~~~~~~
-# 
+#
 # The last part of the implementation is to actually run the attack. Here,
 # we run a full test step for each epsilon value in the *epsilons* input.
 # For each epsilon we also save the final accuracy and some successful
@@ -311,7 +342,7 @@ def test( model, device, test_loader, epsilon ):
 # the printed accuracies decrease as the epsilon value increases. Also,
 # note the :math:`\epsilon=0` case represents the original test accuracy,
 # with no attack.
-# 
+#
 
 accuracies = []
 examples = []
@@ -326,10 +357,10 @@ def test( model, device, test_loader, epsilon ):
 ######################################################################
 # Results
 # -------
-# 
+#
 # Accuracy vs Epsilon
 # ~~~~~~~~~~~~~~~~~~~
-# 
+#
 # The first result is the accuracy versus epsilon plot. As alluded to
 # earlier, as epsilon increases we expect the test accuracy to decrease.
 # This is because larger epsilons mean we take a larger step in the
@@ -340,7 +371,7 @@ def test( model, device, test_loader, epsilon ):
 # lower than :math:`\epsilon=0.15`. Also, notice the accuracy of the model
 # hits random accuracy for a 10-class classifier between
 # :math:`\epsilon=0.25` and :math:`\epsilon=0.3`.
-# 
+#
 
 plt.figure(figsize=(5,5))
 plt.plot(epsilons, accuracies, "*-")
@@ -355,11 +386,11 @@ def test( model, device, test_loader, epsilon ):
 ######################################################################
 # Sample Adversarial Examples
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# 
+#
 # Remember the idea of no free lunch? In this case, as epsilon increases
 # the test accuracy decreases **BUT** the perturbations become more easily
 # perceptible. In reality, there is a tradeoff between accuracy
-# degredation and perceptibility that an attacker must consider. Here, we
+# degradation and perceptibility that an attacker must consider. Here, we
 # show some examples of successful adversarial examples at each epsilon
 # value. Each row of the plot shows a different epsilon value. The first
 # row is the :math:`\epsilon=0` examples which represent the original
@@ -368,7 +399,7 @@ def test( model, device, test_loader, epsilon ):
 # perturbations start to become evident at :math:`\epsilon=0.15` and are
 # quite evident at :math:`\epsilon=0.3`. However, in all cases humans are
 # still capable of identifying the correct class despite the added noise.
-# 
+#
 
 # Plot several examples of adversarial samples at each epsilon
 cnt = 0
@@ -380,9 +411,9 @@ def test( model, device, test_loader, epsilon ):
         plt.xticks([], [])
         plt.yticks([], [])
         if j == 0:
-            plt.ylabel("Eps: {}".format(epsilons[i]), fontsize=14)
+            plt.ylabel(f"Eps: {epsilons[i]}", fontsize=14)
         orig,adv,ex = examples[i][j]
-        plt.title("{} -> {}".format(orig, adv))
+        plt.title(f"{orig} -> {adv}")
         plt.imshow(ex, cmap="gray")
 plt.tight_layout()
 plt.show()
@@ -391,7 +422,7 @@ def test( model, device, test_loader, epsilon ):
 ######################################################################
 # Where to go next?
 # -----------------
-# 
+#
 # Hopefully this tutorial gives some insight into the topic of adversarial
 # machine learning. There are many potential directions to go from here.
 # This attack represents the very beginning of adversarial attack research
@@ -403,7 +434,7 @@ def test( model, device, test_loader, epsilon ):
 # on defense also leads into the idea of making machine learning models
 # more *robust* in general, to both naturally perturbed and adversarially
 # crafted inputs.
-# 
+#
 # Another direction to go is adversarial attacks and defense in different
 # domains. Adversarial research is not limited to the image domain, check
 # out `this <https://arxiv.org/pdf/1801.01944.pdf>`__ attack on
@@ -412,5 +443,8 @@ def test( model, device, test_loader, epsilon ):
 # implement a different attack from the NIPS 2017 competition, and see how
 # it differs from FGSM. Then, try to defend the model from your own
 # attacks.
-# 
-
+#
+# A further direction to go, depending on available resources, is to modify
+# the code to support processing work in batch, in parallel, and or distributed
+# vs working on one attack at a time in the above for each ``epsilon test()`` loop.
+#
diff --git a/beginner_source/finetuning_torchvision_models_tutorial.py b/beginner_source/finetuning_torchvision_models_tutorial.py
deleted file mode 100644
index 042301559ec..00000000000
--- a/beginner_source/finetuning_torchvision_models_tutorial.py
+++ /dev/null
@@ -1,649 +0,0 @@
-"""
-Finetuning Torchvision Models
-=============================
-
-**Author:** `Nathan Inkawhich <https://github.com/inkawhich>`__
-
-"""
-
-
-######################################################################
-# In this tutorial we will take a deeper look at how to finetune and
-# feature extract the `torchvision
-# models <https://pytorch.org/docs/stable/torchvision/models.html>`__, all
-# of which have been pretrained on the 1000-class Imagenet dataset. This
-# tutorial will give an indepth look at how to work with several modern
-# CNN architectures, and will build an intuition for finetuning any
-# PyTorch model. Since each model architecture is different, there is no
-# boilerplate finetuning code that will work in all scenarios. Rather, the
-# researcher must look at the existing architecture and make custom
-# adjustments for each model.
-# 
-# In this document we will perform two types of transfer learning:
-# finetuning and feature extraction. In **finetuning**, we start with a
-# pretrained model and update *all* of the model’s parameters for our new
-# task, in essence retraining the whole model. In **feature extraction**,
-# we start with a pretrained model and only update the final layer weights
-# from which we derive predictions. It is called feature extraction
-# because we use the pretrained CNN as a fixed feature-extractor, and only
-# change the output layer. For more technical information about transfer
-# learning see `here <https://cs231n.github.io/transfer-learning/>`__ and
-# `here <https://ruder.io/transfer-learning/>`__.
-# 
-# In general both transfer learning methods follow the same few steps:
-# 
-# -  Initialize the pretrained model
-# -  Reshape the final layer(s) to have the same number of outputs as the
-#    number of classes in the new dataset
-# -  Define for the optimization algorithm which parameters we want to
-#    update during training
-# -  Run the training step
-# 
-
-from __future__ import print_function 
-from __future__ import division
-import torch
-import torch.nn as nn
-import torch.optim as optim
-import numpy as np
-import torchvision
-from torchvision import datasets, models, transforms
-import matplotlib.pyplot as plt
-import time
-import os
-import copy
-print("PyTorch Version: ",torch.__version__)
-print("Torchvision Version: ",torchvision.__version__)
-
-
-######################################################################
-# Inputs
-# ------
-# 
-# Here are all of the parameters to change for the run. We will use the
-# *hymenoptera_data* dataset which can be downloaded
-# `here <https://download.pytorch.org/tutorial/hymenoptera_data.zip>`__.
-# This dataset contains two classes, **bees** and **ants**, and is
-# structured such that we can use the
-# `ImageFolder <https://pytorch.org/docs/stable/torchvision/datasets.html#torchvision.datasets.ImageFolder>`__
-# dataset, rather than writing our own custom dataset. Download the data
-# and set the ``data_dir`` input to the root directory of the dataset. The
-# ``model_name`` input is the name of the model you wish to use and must
-# be selected from this list:
-# 
-# ::
-# 
-#    [resnet, alexnet, vgg, squeezenet, densenet, inception]
-# 
-# The other inputs are as follows: ``num_classes`` is the number of
-# classes in the dataset, ``batch_size`` is the batch size used for
-# training and may be adjusted according to the capability of your
-# machine, ``num_epochs`` is the number of training epochs we want to run,
-# and ``feature_extract`` is a boolean that defines if we are finetuning
-# or feature extracting. If ``feature_extract = False``, the model is
-# finetuned and all model parameters are updated. If
-# ``feature_extract = True``, only the last layer parameters are updated,
-# the others remain fixed.
-# 
-
-# Top level data directory. Here we assume the format of the directory conforms 
-#   to the ImageFolder structure
-data_dir = "./data/hymenoptera_data"
-
-# Models to choose from [resnet, alexnet, vgg, squeezenet, densenet, inception]
-model_name = "squeezenet"
-
-# Number of classes in the dataset
-num_classes = 2
-
-# Batch size for training (change depending on how much memory you have)
-batch_size = 8
-
-# Number of epochs to train for 
-num_epochs = 15
-
-# Flag for feature extracting. When False, we finetune the whole model, 
-#   when True we only update the reshaped layer params
-feature_extract = True
-
-
-######################################################################
-# Helper Functions
-# ----------------
-# 
-# Before we write the code for adjusting the models, lets define a few
-# helper functions.
-# 
-# Model Training and Validation Code
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# 
-# The ``train_model`` function handles the training and validation of a
-# given model. As input, it takes a PyTorch model, a dictionary of
-# dataloaders, a loss function, an optimizer, a specified number of epochs
-# to train and validate for, and a boolean flag for when the model is an
-# Inception model. The *is_inception* flag is used to accomodate the
-# *Inception v3* model, as that architecture uses an auxiliary output and
-# the overall model loss respects both the auxiliary output and the final
-# output, as described
-# `here <https://discuss.pytorch.org/t/how-to-optimize-inception-model-with-auxiliary-classifiers/7958>`__.
-# The function trains for the specified number of epochs and after each
-# epoch runs a full validation step. It also keeps track of the best
-# performing model (in terms of validation accuracy), and at the end of
-# training returns the best performing model. After each epoch, the
-# training and validation accuracies are printed.
-# 
-
-def train_model(model, dataloaders, criterion, optimizer, num_epochs=25, is_inception=False):
-    since = time.time()
-
-    val_acc_history = []
-    
-    best_model_wts = copy.deepcopy(model.state_dict())
-    best_acc = 0.0
-
-    for epoch in range(num_epochs):
-        print('Epoch {}/{}'.format(epoch, num_epochs - 1))
-        print('-' * 10)
-
-        # Each epoch has a training and validation phase
-        for phase in ['train', 'val']:
-            if phase == 'train':
-                model.train()  # Set model to training mode
-            else:
-                model.eval()   # Set model to evaluate mode
-
-            running_loss = 0.0
-            running_corrects = 0
-
-            # Iterate over data.
-            for inputs, labels in dataloaders[phase]:
-                inputs = inputs.to(device)
-                labels = labels.to(device)
-
-                # zero the parameter gradients
-                optimizer.zero_grad()
-
-                # forward
-                # track history if only in train
-                with torch.set_grad_enabled(phase == 'train'):
-                    # Get model outputs and calculate loss
-                    # Special case for inception because in training it has an auxiliary output. In train
-                    #   mode we calculate the loss by summing the final output and the auxiliary output
-                    #   but in testing we only consider the final output.
-                    if is_inception and phase == 'train':
-                        # From https://discuss.pytorch.org/t/how-to-optimize-inception-model-with-auxiliary-classifiers/7958
-                        outputs, aux_outputs = model(inputs)
-                        loss1 = criterion(outputs, labels)
-                        loss2 = criterion(aux_outputs, labels)
-                        loss = loss1 + 0.4*loss2
-                    else:
-                        outputs = model(inputs)
-                        loss = criterion(outputs, labels)
-
-                    _, preds = torch.max(outputs, 1)
-
-                    # backward + optimize only if in training phase
-                    if phase == 'train':
-                        loss.backward()
-                        optimizer.step()
-
-                # statistics
-                running_loss += loss.item() * inputs.size(0)
-                running_corrects += torch.sum(preds == labels.data)
-
-            epoch_loss = running_loss / len(dataloaders[phase].dataset)
-            epoch_acc = running_corrects.double() / len(dataloaders[phase].dataset)
-
-            print('{} Loss: {:.4f} Acc: {:.4f}'.format(phase, epoch_loss, epoch_acc))
-
-            # deep copy the model
-            if phase == 'val' and epoch_acc > best_acc:
-                best_acc = epoch_acc
-                best_model_wts = copy.deepcopy(model.state_dict())
-            if phase == 'val':
-                val_acc_history.append(epoch_acc)
-
-        print()
-
-    time_elapsed = time.time() - since
-    print('Training complete in {:.0f}m {:.0f}s'.format(time_elapsed // 60, time_elapsed % 60))
-    print('Best val Acc: {:4f}'.format(best_acc))
-
-    # load best model weights
-    model.load_state_dict(best_model_wts)
-    return model, val_acc_history
-
-
-######################################################################
-# Set Model Parameters’ .requires_grad attribute
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-# 
-# This helper function sets the ``.requires_grad`` attribute of the
-# parameters in the model to False when we are feature extracting. By
-# default, when we load a pretrained model all of the parameters have
-# ``.requires_grad=True``, which is fine if we are training from scratch
-# or finetuning. However, if we are feature extracting and only want to
-# compute gradients for the newly initialized layer then we want all of
-# the other parameters to not require gradients. This will make more sense
-# later.
-# 
-
-def set_parameter_requires_grad(model, feature_extracting):
-    if feature_extracting:
-        for param in model.parameters():
-            param.requires_grad = False
-
-
-######################################################################
-# Initialize and Reshape the Networks
-# -----------------------------------
-# 
-# Now to the most interesting part. Here is where we handle the reshaping
-# of each network. Note, this is not an automatic procedure and is unique
-# to each model. Recall, the final layer of a CNN model, which is often
-# times an FC layer, has the same number of nodes as the number of output
-# classes in the dataset. Since all of the models have been pretrained on
-# Imagenet, they all have output layers of size 1000, one node for each
-# class. The goal here is to reshape the last layer to have the same
-# number of inputs as before, AND to have the same number of outputs as
-# the number of classes in the dataset. In the following sections we will
-# discuss how to alter the architecture of each model individually. But
-# first, there is one important detail regarding the difference between
-# finetuning and feature-extraction.
-# 
-# When feature extracting, we only want to update the parameters of the
-# last layer, or in other words, we only want to update the parameters for
-# the layer(s) we are reshaping. Therefore, we do not need to compute the
-# gradients of the parameters that we are not changing, so for efficiency
-# we set the .requires_grad attribute to False. This is important because
-# by default, this attribute is set to True. Then, when we initialize the
-# new layer and by default the new parameters have ``.requires_grad=True``
-# so only the new layer’s parameters will be updated. When we are
-# finetuning we can leave all of the .required_grad’s set to the default
-# of True.
-# 
-# Finally, notice that inception_v3 requires the input size to be
-# (299,299), whereas all of the other models expect (224,224).
-# 
-# Resnet
-# ~~~~~~
-# 
-# Resnet was introduced in the paper `Deep Residual Learning for Image
-# Recognition <https://arxiv.org/abs/1512.03385>`__. There are several
-# variants of different sizes, including Resnet18, Resnet34, Resnet50,
-# Resnet101, and Resnet152, all of which are available from torchvision
-# models. Here we use Resnet18, as our dataset is small and only has two
-# classes. When we print the model, we see that the last layer is a fully
-# connected layer as shown below:
-# 
-# ::
-# 
-#    (fc): Linear(in_features=512, out_features=1000, bias=True) 
-# 
-# Thus, we must reinitialize ``model.fc`` to be a Linear layer with 512
-# input features and 2 output features with:
-# 
-# ::
-# 
-#    model.fc = nn.Linear(512, num_classes)
-# 
-# Alexnet
-# ~~~~~~~
-# 
-# Alexnet was introduced in the paper `ImageNet Classification with Deep
-# Convolutional Neural
-# Networks <https://papers.nips.cc/paper/4824-imagenet-classification-with-deep-convolutional-neural-networks.pdf>`__
-# and was the first very successful CNN on the ImageNet dataset. When we
-# print the model architecture, we see the model output comes from the 6th
-# layer of the classifier
-# 
-# ::
-# 
-#    (classifier): Sequential(
-#        ...
-#        (6): Linear(in_features=4096, out_features=1000, bias=True)
-#     ) 
-# 
-# To use the model with our dataset we reinitialize this layer as
-# 
-# ::
-# 
-#    model.classifier[6] = nn.Linear(4096,num_classes)
-# 
-# VGG
-# ~~~
-# 
-# VGG was introduced in the paper `Very Deep Convolutional Networks for
-# Large-Scale Image Recognition <https://arxiv.org/pdf/1409.1556.pdf>`__.
-# Torchvision offers eight versions of VGG with various lengths and some
-# that have batch normalizations layers. Here we use VGG-11 with batch
-# normalization. The output layer is similar to Alexnet, i.e.
-# 
-# ::
-# 
-#    (classifier): Sequential(
-#        ...
-#        (6): Linear(in_features=4096, out_features=1000, bias=True)
-#     )
-# 
-# Therefore, we use the same technique to modify the output layer
-# 
-# ::
-# 
-#    model.classifier[6] = nn.Linear(4096,num_classes)
-# 
-# Squeezenet
-# ~~~~~~~~~~
-# 
-# The Squeeznet architecture is described in the paper `SqueezeNet:
-# AlexNet-level accuracy with 50x fewer parameters and <0.5MB model
-# size <https://arxiv.org/abs/1602.07360>`__ and uses a different output
-# structure than any of the other models shown here. Torchvision has two
-# versions of Squeezenet, we use version 1.0. The output comes from a 1x1
-# convolutional layer which is the 1st layer of the classifier:
-# 
-# ::
-# 
-#    (classifier): Sequential(
-#        (0): Dropout(p=0.5)
-#        (1): Conv2d(512, 1000, kernel_size=(1, 1), stride=(1, 1))
-#        (2): ReLU(inplace)
-#        (3): AvgPool2d(kernel_size=13, stride=1, padding=0)
-#     ) 
-# 
-# To modify the network, we reinitialize the Conv2d layer to have an
-# output feature map of depth 2 as
-# 
-# ::
-# 
-#    model.classifier[1] = nn.Conv2d(512, num_classes, kernel_size=(1,1), stride=(1,1))
-# 
-# Densenet
-# ~~~~~~~~
-# 
-# Densenet was introduced in the paper `Densely Connected Convolutional
-# Networks <https://arxiv.org/abs/1608.06993>`__. Torchvision has four
-# variants of Densenet but here we only use Densenet-121. The output layer
-# is a linear layer with 1024 input features:
-# 
-# ::
-# 
-#    (classifier): Linear(in_features=1024, out_features=1000, bias=True) 
-# 
-# To reshape the network, we reinitialize the classifier’s linear layer as
-# 
-# ::
-# 
-#    model.classifier = nn.Linear(1024, num_classes)
-# 
-# Inception v3
-# ~~~~~~~~~~~~
-# 
-# Finally, Inception v3 was first described in `Rethinking the Inception
-# Architecture for Computer
-# Vision <https://arxiv.org/pdf/1512.00567v1.pdf>`__. This network is
-# unique because it has two output layers when training. The second output
-# is known as an auxiliary output and is contained in the AuxLogits part
-# of the network. The primary output is a linear layer at the end of the
-# network. Note, when testing we only consider the primary output. The
-# auxiliary output and primary output of the loaded model are printed as:
-# 
-# ::
-# 
-#    (AuxLogits): InceptionAux(
-#        ...
-#        (fc): Linear(in_features=768, out_features=1000, bias=True)
-#     )
-#     ...
-#    (fc): Linear(in_features=2048, out_features=1000, bias=True)
-# 
-# To finetune this model we must reshape both layers. This is accomplished
-# with the following
-# 
-# ::
-# 
-#    model.AuxLogits.fc = nn.Linear(768, num_classes)
-#    model.fc = nn.Linear(2048, num_classes)
-# 
-# Notice, many of the models have similar output structures, but each must
-# be handled slightly differently. Also, check out the printed model
-# architecture of the reshaped network and make sure the number of output
-# features is the same as the number of classes in the dataset.
-# 
-
-def initialize_model(model_name, num_classes, feature_extract, use_pretrained=True):
-    # Initialize these variables which will be set in this if statement. Each of these
-    #   variables is model specific.
-    model_ft = None
-    input_size = 0
-
-    if model_name == "resnet":
-        """ Resnet18
-        """
-        model_ft = models.resnet18(pretrained=use_pretrained)
-        set_parameter_requires_grad(model_ft, feature_extract)
-        num_ftrs = model_ft.fc.in_features
-        model_ft.fc = nn.Linear(num_ftrs, num_classes)
-        input_size = 224
-
-    elif model_name == "alexnet":
-        """ Alexnet
-        """
-        model_ft = models.alexnet(pretrained=use_pretrained)
-        set_parameter_requires_grad(model_ft, feature_extract)
-        num_ftrs = model_ft.classifier[6].in_features
-        model_ft.classifier[6] = nn.Linear(num_ftrs,num_classes)
-        input_size = 224
-
-    elif model_name == "vgg":
-        """ VGG11_bn
-        """
-        model_ft = models.vgg11_bn(pretrained=use_pretrained)
-        set_parameter_requires_grad(model_ft, feature_extract)
-        num_ftrs = model_ft.classifier[6].in_features
-        model_ft.classifier[6] = nn.Linear(num_ftrs,num_classes)
-        input_size = 224
-
-    elif model_name == "squeezenet":
-        """ Squeezenet
-        """
-        model_ft = models.squeezenet1_0(pretrained=use_pretrained)
-        set_parameter_requires_grad(model_ft, feature_extract)
-        model_ft.classifier[1] = nn.Conv2d(512, num_classes, kernel_size=(1,1), stride=(1,1))
-        model_ft.num_classes = num_classes
-        input_size = 224
-
-    elif model_name == "densenet":
-        """ Densenet
-        """
-        model_ft = models.densenet121(pretrained=use_pretrained)
-        set_parameter_requires_grad(model_ft, feature_extract)
-        num_ftrs = model_ft.classifier.in_features
-        model_ft.classifier = nn.Linear(num_ftrs, num_classes) 
-        input_size = 224
-
-    elif model_name == "inception":
-        """ Inception v3 
-        Be careful, expects (299,299) sized images and has auxiliary output
-        """
-        model_ft = models.inception_v3(pretrained=use_pretrained)
-        set_parameter_requires_grad(model_ft, feature_extract)
-        # Handle the auxilary net
-        num_ftrs = model_ft.AuxLogits.fc.in_features
-        model_ft.AuxLogits.fc = nn.Linear(num_ftrs, num_classes)
-        # Handle the primary net
-        num_ftrs = model_ft.fc.in_features
-        model_ft.fc = nn.Linear(num_ftrs,num_classes)
-        input_size = 299
-
-    else:
-        print("Invalid model name, exiting...")
-        exit()
-    
-    return model_ft, input_size
-
-# Initialize the model for this run
-model_ft, input_size = initialize_model(model_name, num_classes, feature_extract, use_pretrained=True)
-
-# Print the model we just instantiated
-print(model_ft) 
-
-
-######################################################################
-# Load Data
-# ---------
-# 
-# Now that we know what the input size must be, we can initialize the data
-# transforms, image datasets, and the dataloaders. Notice, the models were
-# pretrained with the hard-coded normalization values, as described
-# `here <https://pytorch.org/docs/master/torchvision/models.html>`__.
-# 
-
-# Data augmentation and normalization for training
-# Just normalization for validation
-data_transforms = {
-    'train': transforms.Compose([
-        transforms.RandomResizedCrop(input_size),
-        transforms.RandomHorizontalFlip(),
-        transforms.ToTensor(),
-        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
-    ]),
-    'val': transforms.Compose([
-        transforms.Resize(input_size),
-        transforms.CenterCrop(input_size),
-        transforms.ToTensor(),
-        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
-    ]),
-}
-
-print("Initializing Datasets and Dataloaders...")
-
-# Create training and validation datasets
-image_datasets = {x: datasets.ImageFolder(os.path.join(data_dir, x), data_transforms[x]) for x in ['train', 'val']}
-# Create training and validation dataloaders
-dataloaders_dict = {x: torch.utils.data.DataLoader(image_datasets[x], batch_size=batch_size, shuffle=True, num_workers=4) for x in ['train', 'val']}
-
-# Detect if we have a GPU available
-device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
-
-
-######################################################################
-# Create the Optimizer
-# --------------------
-# 
-# Now that the model structure is correct, the final step for finetuning
-# and feature extracting is to create an optimizer that only updates the
-# desired parameters. Recall that after loading the pretrained model, but
-# before reshaping, if ``feature_extract=True`` we manually set all of the
-# parameter’s ``.requires_grad`` attributes to False. Then the
-# reinitialized layer’s parameters have ``.requires_grad=True`` by
-# default. So now we know that *all parameters that have
-# .requires_grad=True should be optimized.* Next, we make a list of such
-# parameters and input this list to the SGD algorithm constructor.
-# 
-# To verify this, check out the printed parameters to learn. When
-# finetuning, this list should be long and include all of the model
-# parameters. However, when feature extracting this list should be short
-# and only include the weights and biases of the reshaped layers.
-# 
-
-# Send the model to GPU
-model_ft = model_ft.to(device)
-
-# Gather the parameters to be optimized/updated in this run. If we are
-#  finetuning we will be updating all parameters. However, if we are 
-#  doing feature extract method, we will only update the parameters
-#  that we have just initialized, i.e. the parameters with requires_grad
-#  is True.
-params_to_update = model_ft.parameters()
-print("Params to learn:")
-if feature_extract:
-    params_to_update = []
-    for name,param in model_ft.named_parameters():
-        if param.requires_grad == True:
-            params_to_update.append(param)
-            print("\t",name)
-else:
-    for name,param in model_ft.named_parameters():
-        if param.requires_grad == True:
-            print("\t",name)
-
-# Observe that all parameters are being optimized
-optimizer_ft = optim.SGD(params_to_update, lr=0.001, momentum=0.9)
-
-
-######################################################################
-# Run Training and Validation Step
-# --------------------------------
-# 
-# Finally, the last step is to setup the loss for the model, then run the
-# training and validation function for the set number of epochs. Notice,
-# depending on the number of epochs this step may take a while on a CPU.
-# Also, the default learning rate is not optimal for all of the models, so
-# to achieve maximum accuracy it would be necessary to tune for each model
-# separately.
-# 
-
-# Setup the loss fxn
-criterion = nn.CrossEntropyLoss()
-
-# Train and evaluate
-model_ft, hist = train_model(model_ft, dataloaders_dict, criterion, optimizer_ft, num_epochs=num_epochs, is_inception=(model_name=="inception"))
-
-
-######################################################################
-# Comparison with Model Trained from Scratch
-# ------------------------------------------
-# 
-# Just for fun, lets see how the model learns if we do not use transfer
-# learning. The performance of finetuning vs. feature extracting depends
-# largely on the dataset but in general both transfer learning methods
-# produce favorable results in terms of training time and overall accuracy
-# versus a model trained from scratch.
-# 
-
-# Initialize the non-pretrained version of the model used for this run
-scratch_model,_ = initialize_model(model_name, num_classes, feature_extract=False, use_pretrained=False)
-scratch_model = scratch_model.to(device)
-scratch_optimizer = optim.SGD(scratch_model.parameters(), lr=0.001, momentum=0.9)
-scratch_criterion = nn.CrossEntropyLoss()
-_,scratch_hist = train_model(scratch_model, dataloaders_dict, scratch_criterion, scratch_optimizer, num_epochs=num_epochs, is_inception=(model_name=="inception"))
-
-# Plot the training curves of validation accuracy vs. number 
-#  of training epochs for the transfer learning method and
-#  the model trained from scratch
-ohist = []
-shist = []
-
-ohist = [h.cpu().numpy() for h in hist]
-shist = [h.cpu().numpy() for h in scratch_hist]
-
-plt.title("Validation Accuracy vs. Number of Training Epochs")
-plt.xlabel("Training Epochs")
-plt.ylabel("Validation Accuracy")
-plt.plot(range(1,num_epochs+1),ohist,label="Pretrained")
-plt.plot(range(1,num_epochs+1),shist,label="Scratch")
-plt.ylim((0,1.))
-plt.xticks(np.arange(1, num_epochs+1, 1.0))
-plt.legend()
-plt.show()
-
-
-######################################################################
-# Final Thoughts and Where to Go Next
-# -----------------------------------
-# 
-# Try running some of the other models and see how good the accuracy gets.
-# Also, notice that feature extracting takes less time because in the
-# backward pass we do not have to calculate most of the gradients. There
-# are many places to go from here. You could:
-# 
-# -  Run this code with a harder dataset and see some more benefits of
-#    transfer learning
-# -  Using the methods described here, use transfer learning to update a
-#    different model, perhaps in a new domain (i.e. NLP, audio, etc.)
-# -  Once you are happy with a model, you can export it as an ONNX model,
-#    or trace it using the hybrid frontend for more speed and optimization
-#    opportunities.
-# 
-
diff --git a/beginner_source/finetuning_torchvision_models_tutorial.rst b/beginner_source/finetuning_torchvision_models_tutorial.rst
new file mode 100644
index 00000000000..711f4b0f99b
--- /dev/null
+++ b/beginner_source/finetuning_torchvision_models_tutorial.rst
@@ -0,0 +1,10 @@
+Finetuning Torchvision Models
+=============================
+
+This tutorial has been moved to https://pytorch.org/tutorials/intermediate/torchvision_tutorial.html
+
+It will redirect in 3 seconds.
+
+.. raw:: html
+
+   <meta http-equiv="Refresh" content="3; url='https://pytorch.org/tutorials/intermediate/torchvision_tutorial.html'" />
diff --git a/beginner_source/former_torchies/README.txt b/beginner_source/former_torchies/README.txt
deleted file mode 100644
index 5bb8c93f00c..00000000000
--- 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 65cc8e8d507..00000000000
--- 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 stops 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 00000000000..8c887e00c8a
--- /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 316bf03a985..00000000000
--- 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 00000000000..db378a7162b
--- /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 4a798975526..00000000000
--- a/beginner_source/former_torchies/parallelism_tutorial.py
+++ /dev/null
@@ -1,142 +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/nn.html#dataparallel>`_.
-# 
-# **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):
-        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 an 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/master/Deep%20Learning%20with%20PyTorch.ipynb
-# .. _Train a state-of-the-art ResNet network on imagenet: https://github.com/pytorch/examples/tree/master/imagenet
-# .. _Train an 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 00000000000..04bb1d69e57
--- /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 10a9d81fadb..00000000000
--- 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 00000000000..939a6855c27
--- /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 e6ae59b7082..5071a62e73c 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/hta_intro_tutorial.rst b/beginner_source/hta_intro_tutorial.rst
new file mode 100644
index 00000000000..dc7c8cedf9e
--- /dev/null
+++ b/beginner_source/hta_intro_tutorial.rst
@@ -0,0 +1,390 @@
+Introduction to Holistic Trace Analysis
+=======================================
+
+**Author:** `Anupam Bhatnagar <https://github.com/anupambhatnagar>`_
+
+In this tutorial, we demonstrate how to use Holistic Trace Analysis (HTA) to
+analyze traces from a distributed training job. To get started follow the steps
+below.
+
+Installing HTA
+~~~~~~~~~~~~~~
+
+We recommend using a Conda environment to install HTA. To install Anaconda, see
+`the official Anaconda documentation <https://docs.anaconda.com/anaconda/install/index.html>`_.
+
+1. Install HTA using pip:
+
+   .. code-block:: python
+
+      pip install HolisticTraceAnalysis
+
+2. (Optional and recommended) Set up a Conda environment:
+
+   .. code-block:: python
+
+      # create the environment env_name
+      conda create -n env_name
+
+      # activate the environment
+      conda activate env_name
+
+      # When you are done, deactivate the environment by running ``conda deactivate``
+
+Getting Started
+~~~~~~~~~~~~~~~
+
+Launch a Jupyter notebook and set the ``trace_dir`` variable to the location of the traces.
+
+.. code-block:: python
+
+   from hta.trace_analysis import TraceAnalysis
+   trace_dir = "/path/to/folder/with/traces"
+   analyzer = TraceAnalysis(trace_dir=trace_dir)
+
+
+Temporal Breakdown
+------------------
+
+To effectively utilize the GPUs, it is crucial to understand how they are spending
+time for a specific job. Are they primarily engaged in computation, communication,
+memory events, or are they idle? The temporal breakdown feature provides a detailed
+analysis of the time spent in these three categories.
+
+* Idle time - GPU is idle.
+* Compute time - GPU is being used for matrix multiplications or vector operations.
+* Non-compute time - GPU is being used for communication or memory events.
+
+To achieve high training efficiency, the code should maximize compute time and
+minimize idle time and non-compute time. The following function generates a
+dataframe that provides a detailed breakdown of the temporal usage for each rank.
+
+.. code-block:: python
+
+   analyzer = TraceAnalysis(trace_dir = "/path/to/trace/folder")
+   time_spent_df = analyzer.get_temporal_breakdown()
+
+
+.. image:: ../_static/img/hta/temporal_breakdown_df.png
+
+When the ``visualize`` argument is set to ``True`` in the `get_temporal_breakdown
+<https://hta.readthedocs.io/en/latest/source/api/trace_analysis_api.html#hta.trace_analysis.TraceAnalysis.get_temporal_breakdown>`_
+function it also generates a bar graph representing the breakdown by rank.
+
+.. image:: ../_static/img/hta/temporal_breakdown_plot.png
+
+
+Idle Time Breakdown
+-------------------
+
+Gaining insight into the amount of time the GPU spends idle and the
+reasons behind it can help guide optimization strategies. A GPU is
+considered idle when no kernel is running on it. We have developed an
+algorithm to categorize the `Idle` time into three distinct categories:
+
+* **Host wait:** refers to the idle time on the GPU that is caused by
+  the CPU not enqueuing kernels quickly enough to keep the GPU fully utilized.
+  These types of inefficiencies can be addressed by examining the CPU
+  operators that are contributing to the slowdown, increasing the batch
+  size and applying operator fusion.
+
+* **Kernel wait:** This refers to brief overhead associated with launching
+  consecutive kernels on the GPU. The idle time attributed to this category
+  can be minimized by using CUDA Graph optimizations.
+
+* **Other wait:** This category includes idle time that cannot currently
+  be attributed due to insufficient information. The likely causes include
+  synchronization among CUDA streams using CUDA events and delays in launching
+  kernels.
+
+The host wait time can be interpreted as the time when the GPU is stalling due
+to the CPU. To attribute the idle time as kernel wait we use the following
+heuristic:
+
+   | **gap between consecutive kernels < threshold**
+
+The default threshold value is 30 nanoseconds and can be configured using the
+``consecutive_kernel_delay`` argument. By default, the idle time breakdown is
+computed for rank 0 only. In order to calculate the breakdown for other ranks,
+use the ``ranks`` argument in the `get_idle_time_breakdown
+<https://hta.readthedocs.io/en/latest/source/api/trace_analysis_api.html#hta.trace_analysis.TraceAnalysis.get_idle_time_breakdown>`_
+function. The idle time breakdown can be generated as follows:
+
+.. code-block:: python
+
+  analyzer = TraceAnalysis(trace_dir = "/path/to/trace/folder")
+  idle_time_df = analyzer.get_idle_time_breakdown()
+
+.. image:: ../_static/img/hta/idle_time_breakdown_percentage.png
+
+The function returns a tuple of dataframes. The first dataframe contains the
+idle time by category on each stream for each rank.
+
+.. image:: ../_static/img/hta/idle_time.png
+   :scale: 100%
+   :align: center
+
+The second dataframe is generated when ``show_idle_interval_stats`` is set to
+``True``. It contains the summary statistics of the idle time for each stream
+on each rank.
+
+.. image:: ../_static/img/hta/idle_time_summary.png
+   :scale: 100%
+   
+.. tip::
+
+   By default, the idle time breakdown presents the percentage of each of the
+   idle time categories. Setting the ``visualize_pctg`` argument to ``False``,
+   the function renders with absolute time on the y-axis. 
+
+
+Kernel Breakdown
+----------------
+
+The kernel breakdown feature breaks down the time spent for each kernel type,
+such as communication (COMM), computation (COMP), and memory (MEM), across all
+ranks and presents the proportion of time spent in each category. Here is the
+percentage of time spent in each category as a pie chart:
+
+.. image:: ../_static/img/hta/kernel_type_breakdown.png
+   :align: center
+
+The kernel breakdown can be calculated as follows:
+
+.. code-block:: python
+
+   analyzer = TraceAnalysis(trace_dir = "/path/to/trace/folder")
+   kernel_type_metrics_df, kernel_metrics_df = analyzer.get_gpu_kernel_breakdown()
+
+The first dataframe returned by the function contains the raw values used to
+generate the pie chart.
+
+Kernel Duration Distribution
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The second dataframe returned by `get_gpu_kernel_breakdown
+<https://hta.readthedocs.io/en/latest/source/api/trace_analysis_api.html#hta.trace_analysis.TraceAnalysis.get_gpu_kernel_breakdown>`_
+contains duration summary statistics for each kernel. In particular, this
+includes the count, min, max, average, standard deviation, sum, and kernel type
+for each kernel on each rank.
+
+.. image:: ../_static/img/hta/kernel_metrics_df.png
+   :align: center
+
+Using this data HTA creates many visualizations to identify performance
+bottlenecks.
+
+#. Pie charts of the top kernels for each kernel type for each rank.
+
+#. Bar graphs of the average duration across all ranks for each of the top
+   kernels and for each kernel type.
+
+.. image:: ../_static/img/hta/pie_charts.png
+
+.. tip::
+
+   All images are generated using plotly. Hovering on the graph shows the
+   mode bar on the top right which allows the user to zoom, pan, select, and
+   download the graph.
+
+The pie charts above show the top 5 computation, communication, and memory
+kernels. Similar pie charts are generated for each rank. The pie charts can be
+configured to show the top k kernels using the ``num_kernels`` argument passed
+to the `get_gpu_kernel_breakdown` function. Additionally, the
+``duration_ratio`` argument can be used to tune the percentage of time that
+needs to be analyzed. If both ``num_kernels`` and ``duration_ratio`` are
+specified, then ``num_kernels`` takes precedence.
+
+.. image:: ../_static/img/hta/comm_across_ranks.png
+
+The bar graph above shows the average duration of the NCCL AllReduce kernel
+across all the ranks. The black lines indicate the minimum and maximum time
+taken on each rank.
+
+.. warning::
+   When using jupyter-lab set the "image_renderer" argument value to
+   "jupyterlab" otherwise the graphs will not render in the notebook.
+
+For a detailed walkthrough of this feature see the `gpu_kernel_breakdown
+notebook
+<https://github.com/facebookresearch/HolisticTraceAnalysis/blob/main/examples/kernel_breakdown_demo.ipynb>`_
+in the examples folder of the repo.
+
+
+Communication Computation Overlap
+---------------------------------
+
+In distributed training, a significant amount of time is spent in communication
+and synchronization events between GPUs. To achieve high GPU efficiency (such as
+TFLOPS/GPU), it is crucial to keep the GPU oversubscribed with computation
+kernels. In other words, the GPU should not be blocked due to unresolved data
+dependencies. One way to measure the extent to which computation is blocked by
+data dependencies is to calculate the communication computation overlap. Higher
+GPU efficiency is observed if communication events overlap computation events.
+Lack of communication and computation overlap will lead to the GPU being idle,
+resulting in low efficiency.
+To sum up, a higher communication computation overlap is desirable. To calculate
+the overlap percentage for each rank, we measure the following ratio:
+
+  | **(time spent in computation while communicating) / (time spent in communication)**
+
+The communication computation overlap can be calculated as follows:
+
+.. code-block:: python
+
+   analyzer = TraceAnalysis(trace_dir = "/path/to/trace/folder")
+   overlap_df = analyzer.get_comm_comp_overlap()
+
+The function returns a dataframe containing the overlap percentage
+for each rank.
+
+.. image:: ../_static/img/hta/overlap_df.png
+   :align: center
+   :scale: 50%
+
+When the ``visualize`` argument is set to True, the `get_comm_comp_overlap
+<https://hta.readthedocs.io/en/latest/source/api/trace_analysis_api.html#hta.trace_analysis.TraceAnalysis.get_comm_comp_overlap>`_
+function also generates a bar graph representing the overlap by rank.
+
+.. image:: ../_static/img/hta/overlap_plot.png
+
+
+Augmented Counters
+------------------
+
+Memory Bandwidth & Queue Length Counters
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Memory bandwidth counters measure the memory copy bandwidth used while copying
+the data from H2D, D2H and D2D by memory copy (memcpy) and memory set (memset)
+events. HTA also computes the number of outstanding operations on each CUDA
+stream. We refer to this as **queue length**. When the queue length on a stream
+is 1024 or larger new events cannot be scheduled on that stream and the CPU
+will stall until the events on the GPU stream have processed.
+
+The `generate_trace_with_counters
+<https://hta.readthedocs.io/en/latest/source/api/trace_analysis_api.html#hta.trace_analysis.TraceAnalysis.generate_trace_with_counters>`_
+API outputs a new trace file with the memory bandwidth and queue length
+counters. The new trace file contains tracks which indicate the memory
+bandwidth used by memcpy/memset operations and tracks for the queue length on
+each stream. By default, these counters are generated using the rank 0
+trace file, and the new file contains the suffix ``_with_counters`` in its name.
+Users have the option to generate the counters for multiple ranks by using the
+``ranks`` argument in the ``generate_trace_with_counters`` API.
+
+.. code-block:: python
+
+  analyzer = TraceAnalysis(trace_dir = "/path/to/trace/folder")
+  analyzer.generate_trace_with_counters()
+
+A screenshot of the generated trace file with augmented counters.
+
+.. image:: ../_static/img/hta/mem_bandwidth_queue_length.png
+   :scale: 100%
+
+HTA also provides a summary of the memory copy bandwidth and queue length
+counters as well as the time series of the counters for the profiled portion of
+the code using the following API:
+
+* `get_memory_bw_summary <https://hta.readthedocs.io/en/latest/source/api/trace_analysis_api.html#hta.trace_analysis.TraceAnalysis.get_memory_bw_summary>`_
+
+* `get_queue_length_summary <https://hta.readthedocs.io/en/latest/source/api/trace_analysis_api.html#hta.trace_analysis.TraceAnalysis.get_queue_length_summary>`_
+
+* `get_memory_bw_time_series <https://hta.readthedocs.io/en/latest/source/api/trace_analysis_api.html#hta.trace_analysis.TraceAnalysis.get_memory_bw_time_series>`_
+
+* `get_queue_length_time_series <https://hta.readthedocs.io/en/latest/source/api/trace_analysis_api.html#hta.trace_analysis.TraceAnalysis.get_queue_length_time_series>`_
+
+To view the summary and time series, use:
+
+.. code-block:: python
+
+  # generate summary
+  mem_bw_summary = analyzer.get_memory_bw_summary()
+  queue_len_summary = analyzer.get_queue_length_summary()
+
+  # get time series
+  mem_bw_series = analyzer.get_memory_bw_time_series()
+  queue_len_series = analyzer.get_queue_length_series()
+
+The summary contains the count, min, max, mean, standard deviation, 25th, 50th,
+and 75th percentile.
+
+.. image:: ../_static/img/hta/queue_length_summary.png
+   :scale: 100%
+   :align: center
+
+The time series only contains the points when a value changes. Once a value is
+observed the time series stays constant until the next update. The memory
+bandwidth and queue length time series functions return a dictionary whose key
+is the rank and the value is the time series for that rank. By default, the
+time series is computed for rank 0 only.
+
+CUDA Kernel Launch Statistics
+-----------------------------
+
+.. image:: ../_static/img/hta/cuda_kernel_launch.png
+
+For each event launched on the GPU, there is a corresponding scheduling event on
+the CPU, such as ``CudaLaunchKernel``, ``CudaMemcpyAsync``, ``CudaMemsetAsync``.
+These events are linked by a common correlation ID in the trace - see the figure
+above. This feature computes the duration of the CPU runtime event, its corresponding GPU
+kernel and the launch delay, for example, the difference between GPU kernel starting and
+CPU operator ending. The kernel launch info can be generated as follows:
+
+.. code-block:: python
+
+  analyzer = TraceAnalysis(trace_dir="/path/to/trace/dir")
+  kernel_info_df = analyzer.get_cuda_kernel_launch_stats()
+
+A screenshot of the generated dataframe is given below.
+
+.. image:: ../_static/img/hta/cuda_kernel_launch_stats.png
+   :scale: 100%
+   :align: center
+
+The duration of the CPU op, GPU kernel, and the launch delay allow us to find
+the following:
+
+* **Short GPU kernels** - GPU kernels with duration less than the corresponding
+  CPU runtime event.
+
+* **Runtime event outliers** - CPU runtime events with excessive duration.
+
+* **Launch delay outliers** - GPU kernels which take too long to be scheduled.
+
+HTA generates distribution plots for each of the aforementioned three categories.
+
+**Short GPU kernels**
+
+Typically, the launch time on the CPU side ranges from 5-20 microseconds. In some
+cases, the GPU execution time is lower than the launch time itself. The graph
+below helps us to find how frequently such instances occur in the code.
+
+.. image:: ../_static/img/hta/short_gpu_kernels.png
+
+
+**Runtime event outliers**
+
+The runtime outliers depend on the cutoff used to classify the outliers, hence
+the `get_cuda_kernel_launch_stats
+<https://hta.readthedocs.io/en/latest/source/api/trace_analysis_api.html#hta.trace_analysis.TraceAnalysis.get_cuda_kernel_launch_stats>`_
+API provides the ``runtime_cutoff`` argument to configure the value.
+
+.. image:: ../_static/img/hta/runtime_outliers.png
+
+**Launch delay outliers**
+
+The launch delay outliers depend on the cutoff used to classify the outliers,
+hence the `get_cuda_kernel_launch_stats` API provides the
+``launch_delay_cutoff`` argument to configure the value.
+
+.. image:: ../_static/img/hta/launch_delay_outliers.png
+
+
+Conclusion
+~~~~~~~~~~
+
+In this tutorial, you have learned how to install and use HTA,
+a performance tool that enables you analyze bottlenecks in your distributed
+training workflows. To learn how you can use the HTA tool to perform trace
+diff analysis, see `Trace Diff using Holistic Trace Analysis <https://pytorch.org/tutorials/beginner/hta_trace_diff_tutorial.html>`__.
diff --git a/beginner_source/hta_trace_diff_tutorial.rst b/beginner_source/hta_trace_diff_tutorial.rst
new file mode 100644
index 00000000000..608d29ea358
--- /dev/null
+++ b/beginner_source/hta_trace_diff_tutorial.rst
@@ -0,0 +1,66 @@
+Trace Diff using Holistic Trace Analysis
+========================================
+
+**Author:** `Anupam Bhatnagar <https://github.com/anupambhatnagar>`_
+
+Occasionally, users need to identify the changes in PyTorch operators and CUDA
+kernels resulting from a code change. To support this requirement, HTA
+provides a trace comparison feature. This feature allows the user to input two
+sets of trace files where the first can be thought of as the *control group*
+and the second as the *test group*, similar to an A/B test. The ``TraceDiff`` class
+provides functions to compare the differences between traces and functionality
+to visualize these differences. In particular, users can find operators and
+kernels that were added and removed from each group, along with the frequency
+of each operator/kernel and the cumulative time taken by the operator/kernel.
+
+The `TraceDiff <https://hta.readthedocs.io/en/latest/source/api/trace_diff_api.html>`_ class 
+has the following methods:
+
+* `compare_traces <https://hta.readthedocs.io/en/latest/source/api/trace_diff_api.html#hta.trace_diff.TraceDiff.compare_traces>`_:
+  Compare the frequency and total duration of CPU operators and GPU kernels from
+  two sets of traces.
+
+* `ops_diff <https://hta.readthedocs.io/en/latest/source/api/trace_diff_api.html#hta.trace_diff.TraceDiff.ops_diff>`_:
+  Get the operators and kernels which have been:
+
+    #. **added** to the test trace and are absent in the control trace
+    #. **deleted** from the test trace and are present in the control trace
+    #. **increased** in frequency in the test trace and exist in the control trace
+    #. **decreased** in frequency in the test trace and exist in the control trace
+    #. **unchanged** between the two sets of traces
+
+* `visualize_counts_diff <https://hta.readthedocs.io/en/latest/source/api/trace_diff_api.html#hta.trace_diff.TraceDiff.visualize_counts_diff>`_
+
+* `visualize_duration_diff <https://hta.readthedocs.io/en/latest/source/api/trace_diff_api.html#hta.trace_diff.TraceDiff.visualize_duration_diff>`_
+
+The last two methods can be used to visualize various changes in frequency and
+duration of CPU operators and GPU kernels, using the output of the
+``compare_traces`` method.
+
+For example, the top ten operators with increase in frequency can be computed as
+follows:
+
+.. code-block:: python
+
+    df = compare_traces_output.sort_values(by="diff_counts", ascending=False).head(10)
+    TraceDiff.visualize_counts_diff(df)
+
+.. image:: ../_static/img/hta/counts_diff.png
+
+Similarly, the top ten operators with the largest change in duration can be computed as
+follows:
+
+.. code-block:: python
+
+    df = compare_traces_output.sort_values(by="diff_duration", ascending=False)
+    # The duration differerence can be overshadowed by the "ProfilerStep",
+    # so we can filter it out to show the trend of other operators.
+    df = df.loc[~df.index.str.startswith("ProfilerStep")].head(10)
+    TraceDiff.visualize_duration_diff(df)
+
+.. image:: ../_static/img/hta/duration_diff.png
+
+For a detailed example of this feature see the `trace_diff_demo notebook
+<https://github.com/facebookresearch/HolisticTraceAnalysis/blob/main/examples/trace_diff_demo.ipynb>`_
+in the examples folder of the repository.
+
diff --git a/beginner_source/hybrid_frontend/README.txt b/beginner_source/hybrid_frontend/README.txt
deleted file mode 100644
index 6ba5067ef0a..00000000000
--- a/beginner_source/hybrid_frontend/README.txt
+++ /dev/null
@@ -1,10 +0,0 @@
- Hybrid Frontend Tutorials
- -------------------------
- 
-1. learning_hybrid_frontend_through_example_tutorial.py
-	Learning Hybrid Frontend Through Example
-	https://pytorch.org/tutorials/beginner/hybrid_frontend/learning_hybrid_frontend_through_example_tutorial.html
-
-2. introduction_to_hybrid_frontend_tutorial.py
-	Introduction to Hybrid Frontend
-	https://pytorch.org/tutorials/beginner/hybrid_frontend/introduction_to_hybrid_frontend_tutorial.html
diff --git a/beginner_source/hybrid_frontend/learning_hybrid_frontend_through_example_tutorial.py b/beginner_source/hybrid_frontend/learning_hybrid_frontend_through_example_tutorial.py
deleted file mode 100644
index b767ba31d71..00000000000
--- a/beginner_source/hybrid_frontend/learning_hybrid_frontend_through_example_tutorial.py
+++ /dev/null
@@ -1,270 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-Learning Hybrid Frontend Syntax Through Example
-===============================================
-**Author:** `Nathan Inkawhich <https://github.com/inkawhich>`_
-
-This document is meant to highlight the syntax of the Hybrid Frontend
-through a non-code intensive example. The Hybrid Frontend is one of the
-new shiny features of Pytorch 1.0 and provides an avenue for developers
-to transition their models from **eager** to **graph** mode. PyTorch
-users are very familiar with eager mode as it provides the ease-of-use
-and flexibility that we all enjoy as researchers. Caffe2 users are more
-aquainted with graph mode which has the benefits of speed, optimization
-opportunities, and functionality in C++ runtime environments. The hybrid
-frontend bridges the gap between the the two modes by allowing
-researchers to develop and refine their models in eager mode (i.e.
-PyTorch), then gradually transition the proven model to graph mode for
-production, when speed and resouce consumption become critical.
-
-Hybrid Frontend Information
----------------------------
-
-The process for transitioning a model to graph mode is as follows.
-First, the developer constructs, trains, and tests the model in eager
-mode. Then they incrementally **trace** and **script** each
-function/module of the model with the Just-In-Time (JIT) compiler, at
-each step verifying that the output is correct. Finally, when each of
-the components of the top-level model have been traced and scripted, the
-model itself is traced. At which point the model has been transitioned
-to graph mode, and has a complete python-free representation. With this
-representation, the model runtime can take advantage of high-performance
-Caffe2 operators and graph based optimizations.
-
-Before we continue, it is important to understand the idea of tracing
-and scripting, and why they are separate. The goal of **trace** and
-**script** is the same, and that is to create a graph representation of
-the operations taking place in a given function. The discrepency comes
-from the flexibility of eager mode that allows for **data-dependent
-control flows** within the model architecture. When a function does NOT
-have a data-dependent control flow, it may be *traced* with
-``torch.jit.trace``. However, when the function *has* a data-dependent
-control flow it must be *scripted* with ``torch.jit.script``. We will
-leave the details of the interworkings of the hybrid frontend for
-another document, but the code example below will show the syntax of how
-to trace and script different pure python functions and torch Modules.
-Hopefully, you will find that using the hybrid frontend is non-intrusive
-as it mostly involves adding decorators to the existing function and
-class definitions.
-
-Motivating Example
-------------------
-
-In this example we will implement a strange math function that may be
-logically broken up into four parts that do, and do not contain
-data-dependent control flows. The purpose here is to show a non-code
-intensive example where the use of the JIT is highlighted. This example
-is a stand-in representation of a useful model, whose implementation has
-been divided into various pure python functions and modules.
-
-The function we seek to implement, :math:`Y(x)`, is defined for
-:math:`x \epsilon \mathbb{N}` as
-
-.. math::
-
-    z(x) = \Biggl \lfloor \\frac{\sqrt{\prod_{i=1}^{|2 x|}i}}{5} \Biggr \\rfloor
-
-.. math::
-
-    Y(x) = \\begin{cases}
-      \\frac{z(x)}{2}  &  \\text{if } z(x)\%2 == 0, \\\\
-      z(x)             &  \\text{otherwise}
-    \end{cases}
-
-.. math::
-
-    \\begin{array}{| r  | r |} \hline
-    x &1 &2 &3 &4 &5 &6 &7 \\\\ \hline
-    Y(x) &0 &0 &-5 &20 &190 &-4377 &-59051 \\\\ \hline
-    \end{array}
-
-As mentioned, the computation is split into four parts. Part one is the
-simple tensor calculation of :math:`|2x|`, which can be traced. Part two
-is the iterative product calculation that represents a data dependent
-control flow to be scripted (the number of loop iteration depends on the
-input at runtime). Part three is a trace-able
-:math:`\lfloor \sqrt{a/5} \\rfloor` calculation. Finally, part 4 handles
-the output cases depending on the value of :math:`z(x)` and must be
-scripted due to the data dependency. Now, let's see how this looks in
-code.
-
-Part 1 - Tracing a pure python function
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-We can implement part one as a pure python function as below. Notice, to
-trace this function we call ``torch.jit.trace`` and pass in the function
-to be traced. Since the trace requires a dummy input of the expected
-runtime type and shape, we also include the ``torch.rand`` to generate a
-single valued torch tensor.
-
-"""
-
-import torch
-
-def fn(x):
-    return torch.abs(2*x)
-
-# This is how you define a traced function
-# Pass in both the function to be traced and an example input to ``torch.jit.trace``
-traced_fn = torch.jit.trace(fn, torch.rand(()))
-
-######################################################################
-# Part 2 - Scripting a pure python function
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-#
-# We can also implement part 2 as a pure python function where we
-# iteratively compute the product. Since the number of iterations depends
-# on the value of the input, we have a data dependent control flow, so the
-# function must be scripted. We can script python functions simply with
-# the ``@torch.jit.script`` decorator.
-#
-
-# This is how you define a script function
-# Apply this decorator directly to the function
-@torch.jit.script
-def script_fn(x):
-    z = torch.ones([1], dtype=torch.int64)
-    for i in range(int(x)):
-        z = z * (i + 1)
-    return z
-
-
-######################################################################
-# Part 3 - Tracing a nn.Module
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-#
-# Next, we will implement part 3 of the computation within the forward
-# function of a ``torch.nn.Module``. This module may be traced, but rather
-# than adding a decorator here, we will handle the tracing where the
-# Module is constructed. Thus, the class definition is not changed at all.
-#
-
-# This is a normal module that can be traced.
-class TracedModule(torch.nn.Module):
-    def forward(self, x):
-        x = x.type(torch.float32)
-        return torch.floor(torch.sqrt(x) / 5.)
-
-
-######################################################################
-# Part 4 - Scripting a nn.Module
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-#
-# In the final part of the computation we have a ``torch.nn.Module`` that
-# must be scripted. To accomodate this, we inherit from
-# ``torch.jit.ScriptModule`` and add the ``@torch.jit.script_method``
-# decorator to the forward function.
-#
-
-# This is how you define a scripted module.
-# The module should inherit from ScriptModule and the forward should have the
-#   script_method decorator applied to it.
-class ScriptModule(torch.jit.ScriptModule):
-    @torch.jit.script_method
-    def forward(self, x):
-        r = -x
-        if int(torch.fmod(x, 2.0)) == 0.0:
-            r = x / 2.0
-        return r
-
-
-######################################################################
-# Top-Level Module
-# ~~~~~~~~~~~~~~~~
-#
-# Now we will put together the pieces of the computation via a top level
-# module called ``Net``. In the constructor, we will instantiate the
-# ``TracedModule`` and ``ScriptModule`` as attributes. This must be done
-# because we ultimately want to trace/script the top level module, and
-# having the traced/scripted modules as attributes allows the Net to
-# inherit the required submodules' parameters. Notice, this is where we
-# actually trace the ``TracedModule`` by calling ``torch.jit.trace()`` and
-# providing the necessary dummy input. Also notice that the
-# ``ScriptModule`` is constructed as normal because we handled the
-# scripting in the class definition.
-#
-# Here we can also print the graphs created for each individual part of
-# the computation. The printed graphs allows us to see how the JIT
-# ultimately interpreted the functions as graph computations.
-#
-# Finally, we define the ``forward`` function for the Net module where we
-# run the input data ``x`` through the four parts of the computation.
-# There is no strange syntax here and we call the traced and scripted
-# modules and functions as expected.
-#
-
-# This is a demonstration net that calls all of the different types of
-# methods and functions
-class Net(torch.nn.Module):
-    def __init__(self):
-        super(Net, self).__init__()
-        # Modules must be attributes on the Module because if you want to trace
-        # or script this Module, we must be able to inherit the submodules'
-        # params.
-        self.traced_module = torch.jit.trace(TracedModule(), torch.rand(()))
-        self.script_module = ScriptModule()
-
-        print('traced_fn graph', traced_fn.graph)
-        print('script_fn graph', script_fn.graph)
-        print('TracedModule graph', self.traced_module.__getattr__('forward').graph)
-        print('ScriptModule graph', self.script_module.__getattr__('forward').graph)
-
-    def forward(self, x):
-        # Call a traced function
-        x = traced_fn(x)
-
-        # Call a script function
-        x = script_fn(x)
-
-        # Call a traced submodule
-        x = self.traced_module(x)
-
-        # Call a scripted submodule
-        x = self.script_module(x)
-
-        return x
-
-
-######################################################################
-# Running the Model
-# ~~~~~~~~~~~~~~~~~
-#
-# All that's left to do is construct the Net and compute the output
-# through the forward function. Here, we use :math:`x=5` as the test input
-# value and expect :math:`Y(x)=190.` Also, check out the graphs that were
-# printed during the construction of the Net.
-#
-
-# Instantiate this net and run it
-n = Net()
-print(n(torch.tensor([5]))) # 190.
-
-
-######################################################################
-# Tracing the Top-Level Model
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-#
-# The last part of the example is to trace the top-level module, ``Net``.
-# As mentioned previously, since the traced/scripted modules are
-# attributes of Net, we are able to trace ``Net`` as it inherits the
-# parameters of the traced/scripted submodules. Note, the syntax for
-# tracing Net is identical to the syntax for tracing ``TracedModule``.
-# Also, check out the graph that is created.
-#
-
-n_traced = torch.jit.trace(n, torch.tensor([5]))
-print(n_traced(torch.tensor([5])))
-print('n_traced graph', n_traced.graph)
-
-
-######################################################################
-# Hopefully, this document can serve as an introduction to the hybrid
-# frontend as well as a syntax reference guide for more experienced users.
-# Also, there are a few things to keep in mind when using the hybrid
-# frontend. There is a constraint that traced/scripted methods must be
-# written in a restricted subset of python, as features like generators,
-# defs, and Python data structures are not supported. As a workaround, the
-# scripting model *is* designed to work with both traced and non-traced
-# code which means you can call non-traced code from traced functions.
-# However, such a model may not be exported to ONNX.
-#
diff --git a/beginner_source/hybrid_frontend_tutorial.rst b/beginner_source/hybrid_frontend_tutorial.rst
deleted file mode 100644
index 89209b0affc..00000000000
--- a/beginner_source/hybrid_frontend_tutorial.rst
+++ /dev/null
@@ -1,21 +0,0 @@
-Hybrid Frontend Tutorials
--------------------------
-**Authors**: `Nathan Inkawhich <https://google.com>`_ and `Matthew Inkawhich <https://github.com/MatthewInkawhich>`_
-
-In this set of tutorials, you will learn the following:
-
-1. What the hybrid frontend is and the suggested workflow
-2. Basic syntax
-3. How to transition an eager model to graph mode
-
-
-.. toctree::
-   :hidden:
-
-   /beginner/hybrid_frontend/learning_hybrid_frontend_through_example_tutorial
-   
-.. galleryitem:: /beginner/hybrid_frontend/learning_hybrid_frontend_through_example_tutorial.py
-
-.. raw:: html
-
-    <div style='clear:both'></div>
diff --git a/beginner_source/hyperparameter_tuning_tutorial.py b/beginner_source/hyperparameter_tuning_tutorial.py
new file mode 100644
index 00000000000..dd3fe65699e
--- /dev/null
+++ b/beginner_source/hyperparameter_tuning_tutorial.py
@@ -0,0 +1,512 @@
+# -*- coding: utf-8 -*-
+"""
+Hyperparameter tuning with Ray Tune
+===================================
+
+Hyperparameter tuning can make the difference between an average model and a highly
+accurate one. Often simple things like choosing a different learning rate or changing
+a network layer size can have a dramatic impact on your model performance.
+
+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 various analysis libraries, and natively
+supports distributed training through `Ray's distributed machine learning engine
+<https://ray.io/>`_.
+
+In this tutorial, we will show you how to integrate Ray Tune into your PyTorch
+training workflow. We will extend `this tutorial from the PyTorch documentation
+<https://pytorch.org/tutorials/beginner/blitz/cifar10_tutorial.html>`_ for training
+a CIFAR10 image classifier.
+
+As you will see, we only need to add some slight modifications. In particular, we
+need to
+
+1. wrap data loading and training in functions,
+2. make some network parameters configurable,
+3. add checkpointing (optional),
+4. and define the search space for the model tuning
+
+|
+
+To run this tutorial, please make sure the following packages are
+installed:
+
+-  ``ray[tune]``: Distributed hyperparameter tuning library
+-  ``torchvision``: For the data transformers
+
+Setup / Imports
+---------------
+Let's start with the imports:
+"""
+from functools import partial
+import os
+import tempfile
+from pathlib import Path
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.optim as optim
+from torch.utils.data import random_split
+import torchvision
+import torchvision.transforms as transforms
+# sphinx_gallery_start_ignore
+# Fixes ``AttributeError: '_LoggingTee' object has no attribute 'fileno'``.
+# This is only needed to run with sphinx-build.
+import sys
+if not hasattr(sys.stdout, "encoding"):
+    sys.stdout.encoding = "latin1"
+    sys.stdout.fileno = lambda: 0
+# sphinx_gallery_end_ignore
+from ray import tune
+from ray import train
+from ray.train import Checkpoint, get_checkpoint
+from ray.tune.schedulers import ASHAScheduler
+import ray.cloudpickle as pickle
+
+######################################################################
+# Most of the imports are needed for building the PyTorch model. Only the last 
+# imports are for Ray Tune.
+#
+# Data loaders
+# ------------
+# We wrap the data loaders in their own function and pass a global data directory.
+# This way we can share a data directory between different trials.
+
+
+def load_data(data_dir="./data"):
+    transform = transforms.Compose(
+        [transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]
+    )
+
+    trainset = torchvision.datasets.CIFAR10(
+        root=data_dir, train=True, download=True, transform=transform
+    )
+
+    testset = torchvision.datasets.CIFAR10(
+        root=data_dir, train=False, download=True, transform=transform
+    )
+
+    return trainset, testset
+
+
+######################################################################
+# Configurable neural network
+# ---------------------------
+# We can only tune those parameters that are configurable.
+# In this example, we can specify
+# the layer sizes of the fully connected layers:
+
+
+class Net(nn.Module):
+    def __init__(self, l1=120, l2=84):
+        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, l1)
+        self.fc2 = nn.Linear(l1, l2)
+        self.fc3 = nn.Linear(l2, 10)
+
+    def forward(self, x):
+        x = self.pool(F.relu(self.conv1(x)))
+        x = self.pool(F.relu(self.conv2(x)))
+        x = torch.flatten(x, 1)  # flatten all dimensions except batch
+        x = F.relu(self.fc1(x))
+        x = F.relu(self.fc2(x))
+        x = self.fc3(x)
+        return x
+
+
+######################################################################
+# The train function
+# ------------------
+# Now it gets interesting, because we introduce some changes to the example `from the PyTorch
+# documentation <https://pytorch.org/tutorials/beginner/blitz/cifar10_tutorial.html>`_.
+#
+# We wrap the training script in a function ``train_cifar(config, data_dir=None)``.
+# The ``config`` parameter will receive the hyperparameters we would like to
+# train with. The ``data_dir`` specifies the directory where we load and store the data,
+# so that multiple runs can share the same data source.
+# We also load the model and optimizer state at the start of the run, if a checkpoint
+# is provided. Further down in this tutorial you will find information on how
+# to save the checkpoint and what it is used for.
+#
+# .. code-block:: python
+#
+#     net = Net(config["l1"], config["l2"])
+#
+#     checkpoint = get_checkpoint()
+#     if checkpoint:
+#         with checkpoint.as_directory() as checkpoint_dir:
+#             data_path = Path(checkpoint_dir) / "data.pkl"
+#             with open(data_path, "rb") as fp:
+#                 checkpoint_state = pickle.load(fp)
+#             start_epoch = checkpoint_state["epoch"]
+#             net.load_state_dict(checkpoint_state["net_state_dict"])
+#             optimizer.load_state_dict(checkpoint_state["optimizer_state_dict"])
+#     else:
+#         start_epoch = 0
+#
+# The learning rate of the optimizer is made configurable, too:
+#
+# .. code-block:: python
+#
+#     optimizer = optim.SGD(net.parameters(), lr=config["lr"], momentum=0.9)
+#
+# We also split the training data into a training and validation subset. We thus train on
+# 80% of the data and calculate the validation loss on the remaining 20%. The batch sizes
+# with which we iterate through the training and test sets are configurable as well.
+#
+# Adding (multi) GPU support with DataParallel
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# Image classification benefits largely from GPUs. Luckily, we can continue to use
+# PyTorch's abstractions in Ray Tune. Thus, we can wrap our model in ``nn.DataParallel``
+# to support data parallel training on multiple GPUs:
+#
+# .. code-block:: python
+#
+#     device = "cpu"
+#     if torch.cuda.is_available():
+#         device = "cuda:0"
+#         if torch.cuda.device_count() > 1:
+#             net = nn.DataParallel(net)
+#     net.to(device)
+#
+# By using a ``device`` variable we make sure that training also works when we have
+# no GPUs available. PyTorch requires us to send our data to the GPU memory explicitly,
+# like this:
+#
+# .. code-block:: python
+#
+#     for i, data in enumerate(trainloader, 0):
+#         inputs, labels = data
+#         inputs, labels = inputs.to(device), labels.to(device)
+#
+# The code now supports training on CPUs, on a single GPU, and on multiple GPUs. Notably, Ray
+# also supports `fractional GPUs <https://docs.ray.io/en/latest/ray-core/scheduling/accelerators.html#fractional-accelerators>`_
+# so we can share GPUs among trials, as long as the model still fits on the GPU memory. We'll come back
+# to that later.
+#
+# Communicating with Ray Tune
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# The most interesting part is the communication with Ray Tune:
+#
+# .. code-block:: python
+#
+#     checkpoint_data = {
+#         "epoch": epoch,
+#         "net_state_dict": net.state_dict(),
+#         "optimizer_state_dict": optimizer.state_dict(),
+#     }
+#     with tempfile.TemporaryDirectory() as checkpoint_dir:
+#         data_path = Path(checkpoint_dir) / "data.pkl"
+#         with open(data_path, "wb") as fp:
+#             pickle.dump(checkpoint_data, fp)
+#
+#         checkpoint = Checkpoint.from_directory(checkpoint_dir)
+#         train.report(
+#             {"loss": val_loss / val_steps, "accuracy": correct / total},
+#             checkpoint=checkpoint,
+#         )
+#
+# Here we first save a checkpoint and then report some metrics back to Ray Tune. Specifically,
+# we send the validation loss and accuracy back to Ray Tune. Ray Tune can then use these metrics
+# to decide which hyperparameter configuration lead to the best results. These metrics
+# can also be used to stop bad performing trials early in order to avoid wasting
+# resources on those trials.
+#
+# The checkpoint saving is optional, however, it is necessary if we wanted to use advanced
+# schedulers like
+# `Population Based Training <https://docs.ray.io/en/latest/tune/examples/pbt_guide.html>`_.
+# Also, by saving the checkpoint we can later load the trained models and validate them
+# on a test set. Lastly, saving checkpoints is useful for fault tolerance, and it allows
+# us to interrupt training and continue training later.
+#
+# Full training function
+# ~~~~~~~~~~~~~~~~~~~~~~
+#
+# The full code example looks like this:
+
+
+def train_cifar(config, data_dir=None):
+    net = Net(config["l1"], config["l2"])
+
+    device = "cpu"
+    if torch.cuda.is_available():
+        device = "cuda:0"
+        if torch.cuda.device_count() > 1:
+            net = nn.DataParallel(net)
+    net.to(device)
+
+    criterion = nn.CrossEntropyLoss()
+    optimizer = optim.SGD(net.parameters(), lr=config["lr"], momentum=0.9)
+
+    checkpoint = get_checkpoint()
+    if checkpoint:
+        with checkpoint.as_directory() as checkpoint_dir:
+            data_path = Path(checkpoint_dir) / "data.pkl"
+            with open(data_path, "rb") as fp:
+                checkpoint_state = pickle.load(fp)
+            start_epoch = checkpoint_state["epoch"]
+            net.load_state_dict(checkpoint_state["net_state_dict"])
+            optimizer.load_state_dict(checkpoint_state["optimizer_state_dict"])
+    else:
+        start_epoch = 0
+
+    trainset, testset = load_data(data_dir)
+
+    test_abs = int(len(trainset) * 0.8)
+    train_subset, val_subset = random_split(
+        trainset, [test_abs, len(trainset) - test_abs]
+    )
+
+    trainloader = torch.utils.data.DataLoader(
+        train_subset, batch_size=int(config["batch_size"]), shuffle=True, num_workers=8
+    )
+    valloader = torch.utils.data.DataLoader(
+        val_subset, batch_size=int(config["batch_size"]), shuffle=True, num_workers=8
+    )
+
+    for epoch in range(start_epoch, 10):  # loop over the dataset multiple times
+        running_loss = 0.0
+        epoch_steps = 0
+        for i, data in enumerate(trainloader, 0):
+            # get the inputs; data is a list of [inputs, labels]
+            inputs, labels = data
+            inputs, labels = inputs.to(device), labels.to(device)
+
+            # zero the parameter gradients
+            optimizer.zero_grad()
+
+            # forward + backward + optimize
+            outputs = net(inputs)
+            loss = criterion(outputs, labels)
+            loss.backward()
+            optimizer.step()
+
+            # print statistics
+            running_loss += loss.item()
+            epoch_steps += 1
+            if i % 2000 == 1999:  # print every 2000 mini-batches
+                print(
+                    "[%d, %5d] loss: %.3f"
+                    % (epoch + 1, i + 1, running_loss / epoch_steps)
+                )
+                running_loss = 0.0
+
+        # Validation loss
+        val_loss = 0.0
+        val_steps = 0
+        total = 0
+        correct = 0
+        for i, data in enumerate(valloader, 0):
+            with torch.no_grad():
+                inputs, labels = data
+                inputs, labels = inputs.to(device), labels.to(device)
+
+                outputs = net(inputs)
+                _, predicted = torch.max(outputs.data, 1)
+                total += labels.size(0)
+                correct += (predicted == labels).sum().item()
+
+                loss = criterion(outputs, labels)
+                val_loss += loss.cpu().numpy()
+                val_steps += 1
+
+        checkpoint_data = {
+            "epoch": epoch,
+            "net_state_dict": net.state_dict(),
+            "optimizer_state_dict": optimizer.state_dict(),
+        }
+        with tempfile.TemporaryDirectory() as checkpoint_dir:
+            data_path = Path(checkpoint_dir) / "data.pkl"
+            with open(data_path, "wb") as fp:
+                pickle.dump(checkpoint_data, fp)
+
+            checkpoint = Checkpoint.from_directory(checkpoint_dir)
+            train.report(
+                {"loss": val_loss / val_steps, "accuracy": correct / total},
+                checkpoint=checkpoint,
+            )
+    
+    print("Finished Training")
+
+
+######################################################################
+# As you can see, most of the code is adapted directly from the original example.
+#
+# Test set accuracy
+# -----------------
+# Commonly the performance of a machine learning model is tested on a hold-out test
+# set with data that has not been used for training the model. We also wrap this in a
+# function:
+
+
+def test_accuracy(net, device="cpu"):
+    trainset, testset = load_data()
+
+    testloader = torch.utils.data.DataLoader(
+        testset, batch_size=4, shuffle=False, num_workers=2
+    )
+
+    correct = 0
+    total = 0
+    with torch.no_grad():
+        for data in testloader:
+            images, labels = data
+            images, labels = images.to(device), labels.to(device)
+            outputs = net(images)
+            _, predicted = torch.max(outputs.data, 1)
+            total += labels.size(0)
+            correct += (predicted == labels).sum().item()
+
+    return correct / total
+
+
+######################################################################
+# The function also expects a ``device`` parameter, so we can do the
+# test set validation on a GPU.
+#
+# Configuring the search space
+# ----------------------------
+# Lastly, we need to define Ray Tune's search space. Here is an example:
+#
+# .. code-block:: python
+#
+#     config = {
+#         "l1": tune.choice([2 ** i for i in range(9)]),
+#         "l2": tune.choice([2 ** i for i in range(9)]),
+#         "lr": tune.loguniform(1e-4, 1e-1),
+#         "batch_size": tune.choice([2, 4, 8, 16])
+#     }
+#
+# The ``tune.choice()`` accepts a list of values that are uniformly sampled from.
+# In this example, the ``l1`` and ``l2`` parameters
+# should be powers of 2 between 4 and 256, so either 4, 8, 16, 32, 64, 128, or 256.
+# The ``lr`` (learning rate) should be uniformly sampled between 0.0001 and 0.1. Lastly,
+# the batch size is a choice between 2, 4, 8, and 16.
+#
+# At each trial, Ray Tune will now randomly sample a combination of parameters from these
+# search spaces. It will then train a number of models in parallel and find the best
+# performing one among these. We also use the ``ASHAScheduler`` which will terminate bad
+# performing trials early.
+#
+# We wrap the ``train_cifar`` function with ``functools.partial`` to set the constant
+# ``data_dir`` parameter. We can also tell Ray Tune what resources should be
+# available for each trial:
+#
+# .. code-block:: python
+#
+#     gpus_per_trial = 2
+#     # ...
+#     result = tune.run(
+#         partial(train_cifar, data_dir=data_dir),
+#         resources_per_trial={"cpu": 8, "gpu": gpus_per_trial},
+#         config=config,
+#         num_samples=num_samples,
+#         scheduler=scheduler,
+#         checkpoint_at_end=True)
+#
+# You can specify the number of CPUs, which are then available e.g.
+# to increase the ``num_workers`` of the PyTorch ``DataLoader`` instances. The selected
+# number of GPUs are made visible to PyTorch in each trial. Trials do not have access to
+# GPUs that haven't been requested for them - so you don't have to care about two trials
+# using the same set of resources.
+#
+# Here we can also specify fractional GPUs, so something like ``gpus_per_trial=0.5`` is
+# completely valid. The trials will then share GPUs among each other.
+# You just have to make sure that the models still fit in the GPU memory.
+#
+# After training the models, we will find the best performing one and load the trained
+# network from the checkpoint file. We then obtain the test set accuracy and report
+# everything by printing.
+#
+# The full main function looks like this:
+
+
+def main(num_samples=10, max_num_epochs=10, gpus_per_trial=2):
+    data_dir = os.path.abspath("./data")
+    load_data(data_dir)
+    config = {
+        "l1": tune.choice([2**i for i in range(9)]),
+        "l2": tune.choice([2**i for i in range(9)]),
+        "lr": tune.loguniform(1e-4, 1e-1),
+        "batch_size": tune.choice([2, 4, 8, 16]),
+    }
+    scheduler = ASHAScheduler(
+        metric="loss",
+        mode="min",
+        max_t=max_num_epochs,
+        grace_period=1,
+        reduction_factor=2,
+    )
+    result = tune.run(
+        partial(train_cifar, data_dir=data_dir),
+        resources_per_trial={"cpu": 2, "gpu": gpus_per_trial},
+        config=config,
+        num_samples=num_samples,
+        scheduler=scheduler,
+    )
+
+    best_trial = result.get_best_trial("loss", "min", "last")
+    print(f"Best trial config: {best_trial.config}")
+    print(f"Best trial final validation loss: {best_trial.last_result['loss']}")
+    print(f"Best trial final validation accuracy: {best_trial.last_result['accuracy']}")
+
+    best_trained_model = Net(best_trial.config["l1"], best_trial.config["l2"])
+    device = "cpu"
+    if torch.cuda.is_available():
+        device = "cuda:0"
+        if gpus_per_trial > 1:
+            best_trained_model = nn.DataParallel(best_trained_model)
+    best_trained_model.to(device)
+
+    best_checkpoint = result.get_best_checkpoint(trial=best_trial, metric="accuracy", mode="max")
+    with best_checkpoint.as_directory() as checkpoint_dir:
+        data_path = Path(checkpoint_dir) / "data.pkl"
+        with open(data_path, "rb") as fp:
+            best_checkpoint_data = pickle.load(fp)
+
+        best_trained_model.load_state_dict(best_checkpoint_data["net_state_dict"])
+        test_acc = test_accuracy(best_trained_model, device)
+        print("Best trial test set accuracy: {}".format(test_acc))
+
+
+if __name__ == "__main__":
+    # You can change the number of GPUs per trial here:
+    main(num_samples=10, max_num_epochs=10, gpus_per_trial=0)
+
+
+######################################################################
+# If you run the code, an example output could look like this:
+#
+# .. code-block:: sh
+#
+#     Number of trials: 10/10 (10 TERMINATED)
+#     +-----+--------------+------+------+-------------+--------+---------+------------+
+#     | ... |   batch_size |   l1 |   l2 |          lr |   iter |    loss |   accuracy |
+#     |-----+--------------+------+------+-------------+--------+---------+------------|
+#     | ... |            2 |    1 |  256 | 0.000668163 |      1 | 2.31479 |     0.0977 |
+#     | ... |            4 |   64 |    8 | 0.0331514   |      1 | 2.31605 |     0.0983 |
+#     | ... |            4 |    2 |    1 | 0.000150295 |      1 | 2.30755 |     0.1023 |
+#     | ... |           16 |   32 |   32 | 0.0128248   |     10 | 1.66912 |     0.4391 |
+#     | ... |            4 |    8 |  128 | 0.00464561  |      2 | 1.7316  |     0.3463 |
+#     | ... |            8 |  256 |    8 | 0.00031556  |      1 | 2.19409 |     0.1736 |
+#     | ... |            4 |   16 |  256 | 0.00574329  |      2 | 1.85679 |     0.3368 |
+#     | ... |            8 |    2 |    2 | 0.00325652  |      1 | 2.30272 |     0.0984 |
+#     | ... |            2 |    2 |    2 | 0.000342987 |      2 | 1.76044 |     0.292  |
+#     | ... |            4 |   64 |   32 | 0.003734    |      8 | 1.53101 |     0.4761 |
+#     +-----+--------------+------+------+-------------+--------+---------+------------+
+#
+#     Best trial config: {'l1': 64, 'l2': 32, 'lr': 0.0037339984519545164, 'batch_size': 4}
+#     Best trial final validation loss: 1.5310075663924216
+#     Best trial final validation accuracy: 0.4761
+#     Best trial test set accuracy: 0.4737
+#
+# Most trials have been stopped early in order to avoid wasting resources.
+# The best performing trial achieved a validation accuracy of about 47%, which could
+# be confirmed on the test set.
+#
+# So that's it! You can now tune the parameters of your PyTorch models.
diff --git a/beginner_source/introyt.rst b/beginner_source/introyt.rst
new file mode 100644
index 00000000000..9b2a630c245
--- /dev/null
+++ b/beginner_source/introyt.rst
@@ -0,0 +1,10 @@
+Introduction to PyTorch - YouTube Series
+========================================
+
+This page has been moved.
+
+Redirecting now...
+
+.. raw:: html
+
+   <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
new file mode 100644
index 00000000000..b90d269cfab
--- /dev/null
+++ b/beginner_source/introyt/README.txt
@@ -0,0 +1,34 @@
+Introduction to PyTorch on YouTube
+----------------------------------
+
+1. introyt.py
+    Introduction to PyTorch - Youtube Series
+    https://pytorch.org/tutorials/beginner/introyt/introyt.html
+
+2. introyt1_tutorial.py
+    Introduction to PyTorch
+    https://pytorch.org/tutorials/beginner/introyt/introyt1_tutorial.html
+
+3. tensors_deeper_tutorial.py
+    PyTorch Tensors
+    https://pytorch.org/tutorials/beginner/introyt/tensors_deeper_tutorial.html
+
+4. autogradyt_tutorial.py
+    The Fundamentals of Autograd
+    https://pytorch.org/tutorials/beginner/introyt/autogradyt_tutorial.html
+
+5. modelsyt_tutorial.py
+    Building Models with PyTorch
+    https://pytorch.org/tutorials/beginner/introyt/modelsyt_tutorial.html
+
+6. tensorboardyt_tutorial.py
+    PyTorch TensorBoard Support
+    https://pytorch.org/tutorials/beginner/introyt/tensorboardyt_tutorial.html
+
+7. trainingyt_tutorial.py
+    Training with PyTorch
+    https://pytorch.org/tutorials/beginner/introyt/trainingyt_tutorial.html
+    
+8. captumyt_tutorial.py
+    Model Understanding with Captum
+    https://pytorch.org/tutorials/beginner/introyt/captumyt_tutorial.html
diff --git a/beginner_source/introyt/autogradyt_tutorial.py b/beginner_source/introyt/autogradyt_tutorial.py
new file mode 100644
index 00000000000..abf75a7d266
--- /dev/null
+++ b/beginner_source/introyt/autogradyt_tutorial.py
@@ -0,0 +1,655 @@
+"""
+`Introduction <introyt1_tutorial.html>`_ ||
+`Tensors <tensors_deeper_tutorial.html>`_ ||
+**Autograd** ||
+`Building Models <modelsyt_tutorial.html>`_ ||
+`TensorBoard Support <tensorboardyt_tutorial.html>`_ ||
+`Training Models <trainingyt.html>`_ ||
+`Model Understanding <captumyt.html>`_
+
+The Fundamentals of Autograd
+============================
+
+Follow along with the video below or on `youtube <https://www.youtube.com/watch?v=M0fX15_-xrY>`__.
+
+.. raw:: html
+
+   <div style="margin-top:10px; margin-bottom:10px;">
+     <iframe width="560" height="315" src="https://www.youtube.com/embed/M0fX15_-xrY" frameborder="0" allow="accelerometer; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
+   </div>
+
+PyTorch’s *Autograd* feature is part of what make PyTorch flexible and
+fast for building machine learning projects. It allows for the rapid and
+easy computation of multiple partial derivatives (also referred to as
+*gradients)* over a complex computation. This operation is central to
+backpropagation-based neural network learning.
+
+The power of autograd comes from the fact that it traces your
+computation dynamically *at runtime,* meaning that if your model has
+decision branches, or loops whose lengths are not known until runtime,
+the computation will still be traced correctly, and you’ll get correct
+gradients to drive learning. This, combined with the fact that your
+models are built in Python, offers far more flexibility than frameworks
+that rely on static analysis of a more rigidly-structured model for
+computing gradients.
+
+What Do We Need Autograd For?
+-----------------------------
+
+"""
+
+###########################################################################
+# A machine learning model is a *function*, with inputs and outputs. For
+# this discussion, we’ll treat the inputs as an *i*-dimensional vector
+# :math:`\vec{x}`, with elements :math:`x_{i}`. We can then express the
+# model, *M*, as a vector-valued function of the input: :math:`\vec{y} =
+# \vec{M}(\vec{x})`. (We treat the value of M’s output as
+# a vector because in general, a model may have any number of outputs.)
+#
+# Since we’ll mostly be discussing autograd in the context of training,
+# our output of interest will be the model’s loss. The *loss function*
+# L(:math:`\vec{y}`) = L(:math:`\vec{M}`\ (:math:`\vec{x}`)) is a
+# single-valued scalar function of the model’s output. This function
+# expresses how far off our model’s prediction was from a particular
+# input’s *ideal* output. *Note: After this point, we will often omit the
+# vector sign where it should be contextually clear - e.g.,* :math:`y`
+# instead of :math:`\vec y`.
+#
+# In training a model, we want to minimize the loss. In the idealized case
+# of a perfect model, that means adjusting its learning weights - that is,
+# the adjustable parameters of the function - such that loss is zero for
+# all inputs. In the real world, it means an iterative process of nudging
+# the learning weights until we see that we get a tolerable loss for a
+# wide variety of inputs.
+#
+# How do we decide how far and in which direction to nudge the weights? We
+# want to *minimize* the loss, which means making its first derivative
+# with respect to the input equal to 0:
+# :math:`\frac{\partial L}{\partial x} = 0`.
+#
+# Recall, though, that the loss is not *directly* derived from the input,
+# but a function of the model’s output (which is a function of the input
+# directly), :math:`\frac{\partial L}{\partial x}` =
+# :math:`\frac{\partial {L({\vec y})}}{\partial x}`. By the chain rule of
+# differential calculus, we have
+# :math:`\frac{\partial {L({\vec y})}}{\partial x}` =
+# :math:`\frac{\partial L}{\partial y}\frac{\partial y}{\partial x}` =
+# :math:`\frac{\partial L}{\partial y}\frac{\partial M(x)}{\partial x}`.
+#
+# :math:`\frac{\partial M(x)}{\partial x}` is where things get complex.
+# The partial derivatives of the model’s outputs with respect to its
+# inputs, if we were to expand the expression using the chain rule again,
+# would involve many local partial derivatives over every multiplied
+# learning weight, every activation function, and every other mathematical
+# transformation in the model. The full expression for each such partial
+# derivative is the sum of the products of the local gradient of *every
+# possible path* through the computation graph that ends with the variable
+# whose gradient we are trying to measure.
+#
+# In particular, the gradients over the learning weights are of interest
+# to us - they tell us *what direction to change each weight* to get the
+# loss function closer to zero.
+#
+# Since the number of such local derivatives (each corresponding to a
+# separate path through the model’s computation graph) will tend to go up
+# exponentially with the depth of a neural network, so does the complexity
+# in computing them. This is where autograd comes in: It tracks the
+# history of every computation. Every computed tensor in your PyTorch
+# model carries a history of its input tensors and the function used to
+# create it. Combined with the fact that PyTorch functions meant to act on
+# tensors each have a built-in implementation for computing their own
+# derivatives, this greatly speeds the computation of the local
+# derivatives needed for learning.
+#
+# A Simple Example
+# ----------------
+#
+# That was a lot of theory - but what does it look like to use autograd in
+# practice?
+#
+# Let’s start with a straightforward example. First, we’ll do some imports
+# to let us graph our results:
+#
+
+# %matplotlib inline
+
+import torch
+
+import matplotlib.pyplot as plt
+import matplotlib.ticker as ticker
+import math
+
+
+#########################################################################
+# Next, we’ll create an input tensor full of evenly spaced values on the
+# interval :math:`[0, 2{\pi}]`, and specify ``requires_grad=True``. (Like
+# most functions that create tensors, ``torch.linspace()`` accepts an
+# optional ``requires_grad`` option.) Setting this flag means that in
+# every computation that follows, autograd will be accumulating the
+# history of the computation in the output tensors of that computation.
+# 
+
+a = torch.linspace(0., 2. * math.pi, steps=25, requires_grad=True)
+print(a)
+
+
+########################################################################
+# Next, we’ll perform a computation, and plot its output in terms of its
+# inputs:
+# 
+
+b = torch.sin(a)
+plt.plot(a.detach(), b.detach())
+
+
+########################################################################
+# Let’s have a closer look at the tensor ``b``. When we print it, we see
+# an indicator that it is tracking its computation history:
+# 
+
+print(b)
+
+
+#######################################################################
+# This ``grad_fn`` gives us a hint that when we execute the
+# backpropagation step and compute gradients, we’ll need to compute the
+# derivative of :math:`\sin(x)` for all this tensor’s inputs.
+# 
+# Let’s perform some more computations:
+# 
+
+c = 2 * b
+print(c)
+
+d = c + 1
+print(d)
+
+
+##########################################################################
+# Finally, let’s compute a single-element output. When you call
+# ``.backward()`` on a tensor with no arguments, it expects the calling
+# tensor to contain only a single element, as is the case when computing a
+# loss function.
+# 
+
+out = d.sum()
+print(out)
+
+
+##########################################################################
+# Each ``grad_fn`` stored with our tensors allows you to walk the
+# computation all the way back to its inputs with its ``next_functions``
+# property. We can see below that drilling down on this property on ``d``
+# shows us the gradient functions for all the prior tensors. Note that
+# ``a.grad_fn`` is reported as ``None``, indicating that this was an input
+# to the function with no history of its own.
+# 
+
+print('d:')
+print(d.grad_fn)
+print(d.grad_fn.next_functions)
+print(d.grad_fn.next_functions[0][0].next_functions)
+print(d.grad_fn.next_functions[0][0].next_functions[0][0].next_functions)
+print(d.grad_fn.next_functions[0][0].next_functions[0][0].next_functions[0][0].next_functions)
+print('\nc:')
+print(c.grad_fn)
+print('\nb:')
+print(b.grad_fn)
+print('\na:')
+print(a.grad_fn)
+
+
+######################################################################
+# With all this machinery in place, how do we get derivatives out? You
+# call the ``backward()`` method on the output, and check the input’s
+# ``grad`` property to inspect the gradients:
+# 
+
+out.backward()
+print(a.grad)
+plt.plot(a.detach(), a.grad.detach())
+
+
+#########################################################################
+# Recall the computation steps we took to get here:
+# 
+# .. code-block:: python
+# 
+#    a = torch.linspace(0., 2. * math.pi, steps=25, requires_grad=True)
+#    b = torch.sin(a)
+#    c = 2 * b
+#    d = c + 1
+#    out = d.sum()
+# 
+# Adding a constant, as we did to compute ``d``, does not change the
+# derivative. That leaves :math:`c = 2 * b = 2 * \sin(a)`, the derivative
+# of which should be :math:`2 * \cos(a)`. Looking at the graph above,
+# that’s just what we see.
+# 
+# Be aware that only *leaf nodes* of the computation have their gradients
+# computed. If you tried, for example, ``print(c.grad)`` you’d get back
+# ``None``. In this simple example, only the input is a leaf node, so only
+# it has gradients computed.
+# 
+# Autograd in Training
+# --------------------
+# 
+# We’ve had a brief look at how autograd works, but how does it look when
+# it’s used for its intended purpose? Let’s define a small model and
+# examine how it changes after a single training batch. First, define a
+# few constants, our model, and some stand-ins for inputs and outputs:
+# 
+
+BATCH_SIZE = 16
+DIM_IN = 1000
+HIDDEN_SIZE = 100
+DIM_OUT = 10
+
+class TinyModel(torch.nn.Module):
+
+    def __init__(self):
+        super(TinyModel, self).__init__()
+        
+        self.layer1 = torch.nn.Linear(DIM_IN, HIDDEN_SIZE)
+        self.relu = torch.nn.ReLU()
+        self.layer2 = torch.nn.Linear(HIDDEN_SIZE, DIM_OUT)
+    
+    def forward(self, x):
+        x = self.layer1(x)
+        x = self.relu(x)
+        x = self.layer2(x)
+        return x
+    
+some_input = torch.randn(BATCH_SIZE, DIM_IN, requires_grad=False)
+ideal_output = torch.randn(BATCH_SIZE, DIM_OUT, requires_grad=False)
+
+model = TinyModel()
+
+
+##########################################################################
+# One thing you might notice is that we never specify
+# ``requires_grad=True`` for the model’s layers. Within a subclass of
+# ``torch.nn.Module``, it’s assumed that we want to track gradients on the
+# layers’ weights for learning.
+# 
+# If we look at the layers of the model, we can examine the values of the
+# weights, and verify that no gradients have been computed yet:
+# 
+
+print(model.layer2.weight[0][0:10]) # just a small slice
+print(model.layer2.weight.grad)
+
+
+##########################################################################
+# Let’s see how this changes when we run through one training batch. For a
+# loss function, we’ll just use the square of the Euclidean distance
+# between our ``prediction`` and the ``ideal_output``, and we’ll use a
+# basic stochastic gradient descent optimizer.
+# 
+
+optimizer = torch.optim.SGD(model.parameters(), lr=0.001)
+
+prediction = model(some_input)
+
+loss = (ideal_output - prediction).pow(2).sum()
+print(loss)
+
+
+######################################################################
+# Now, let’s call ``loss.backward()`` and see what happens:
+# 
+
+loss.backward()
+print(model.layer2.weight[0][0:10])
+print(model.layer2.weight.grad[0][0:10])
+
+
+########################################################################
+# We can see that the gradients have been computed for each learning
+# weight, but the weights remain unchanged, because we haven’t run the
+# optimizer yet. The optimizer is responsible for updating model weights
+# based on the computed gradients.
+# 
+
+optimizer.step()
+print(model.layer2.weight[0][0:10])
+print(model.layer2.weight.grad[0][0:10])
+
+
+######################################################################
+# You should see that ``layer2``\ ’s weights have changed.
+# 
+# One important thing about the process: After calling
+# ``optimizer.step()``, you need to call ``optimizer.zero_grad()``, or
+# else every time you run ``loss.backward()``, the gradients on the
+# learning weights will accumulate:
+# 
+
+print(model.layer2.weight.grad[0][0:10])
+
+for i in range(0, 5):
+    prediction = model(some_input)
+    loss = (ideal_output - prediction).pow(2).sum()
+    loss.backward()
+    
+print(model.layer2.weight.grad[0][0:10])
+
+optimizer.zero_grad(set_to_none=False)
+
+print(model.layer2.weight.grad[0][0:10])
+
+
+#########################################################################
+# After running the cell above, you should see that after running
+# ``loss.backward()`` multiple times, the magnitudes of most of the
+# gradients will be much larger. Failing to zero the gradients before
+# running your next training batch will cause the gradients to blow up in
+# this manner, causing incorrect and unpredictable learning results.
+# 
+# Turning Autograd Off and On
+# ---------------------------
+# 
+# There are situations where you will need fine-grained control over
+# whether autograd is enabled. There are multiple ways to do this,
+# depending on the situation.
+# 
+# The simplest is to change the ``requires_grad`` flag on a tensor
+# directly:
+# 
+
+a = torch.ones(2, 3, requires_grad=True)
+print(a)
+
+b1 = 2 * a
+print(b1)
+
+a.requires_grad = False
+b2 = 2 * a
+print(b2)
+
+
+##########################################################################
+# In the cell above, we see that ``b1`` has a ``grad_fn`` (i.e., a traced
+# computation history), which is what we expect, since it was derived from
+# a tensor, ``a``, that had autograd turned on. When we turn off autograd
+# explicitly with ``a.requires_grad = False``, computation history is no
+# longer tracked, as we see when we compute ``b2``.
+# 
+# If you only need autograd turned off temporarily, a better way is to use
+# the ``torch.no_grad()``:
+# 
+
+a = torch.ones(2, 3, requires_grad=True) * 2
+b = torch.ones(2, 3, requires_grad=True) * 3
+
+c1 = a + b
+print(c1)
+
+with torch.no_grad():
+    c2 = a + b
+
+print(c2)
+
+c3 = a * b
+print(c3)
+
+
+##########################################################################
+# ``torch.no_grad()`` can also be used as a function or method decorator:
+# 
+
+def add_tensors1(x, y):
+    return x + y
+
+@torch.no_grad()
+def add_tensors2(x, y):
+    return x + y
+
+
+a = torch.ones(2, 3, requires_grad=True) * 2
+b = torch.ones(2, 3, requires_grad=True) * 3
+
+c1 = add_tensors1(a, b)
+print(c1)
+
+c2 = add_tensors2(a, b)
+print(c2)
+
+
+##########################################################################
+# There’s a corresponding context manager, ``torch.enable_grad()``, for
+# turning autograd on when it isn’t already. It may also be used as a
+# decorator.
+# 
+# Finally, you may have a tensor that requires gradient tracking, but you
+# want a copy that does not. For this we have the ``Tensor`` object’s
+# ``detach()`` method - it creates a copy of the tensor that is *detached*
+# from the computation history:
+# 
+
+x = torch.rand(5, requires_grad=True)
+y = x.detach()
+
+print(x)
+print(y)
+
+
+#########################################################################
+# We did this above when we wanted to graph some of our tensors. This is
+# because ``matplotlib`` expects a NumPy array as input, and the implicit
+# conversion from a PyTorch tensor to a NumPy array is not enabled for
+# tensors with requires_grad=True. Making a detached copy lets us move
+# forward.
+# 
+# Autograd and In-place Operations
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# 
+# In every example in this notebook so far, we’ve used variables to
+# capture the intermediate values of a computation. Autograd needs these
+# intermediate values to perform gradient computations. *For this reason,
+# you must be careful about using in-place operations when using
+# autograd.* Doing so can destroy information you need to compute
+# derivatives in the ``backward()`` call. PyTorch will even stop you if
+# you attempt an in-place operation on leaf variable that requires
+# autograd, as shown below.
+# 
+# .. note::
+#     The following code cell throws a runtime error. This is expected.
+# 
+#    .. code-block:: python
+#
+#       a = torch.linspace(0., 2. * math.pi, steps=25, requires_grad=True)
+#       torch.sin_(a)
+#
+
+#########################################################################
+# Autograd Profiler
+# -----------------
+# 
+# Autograd tracks every step of your computation in detail. Such a
+# computation history, combined with timing information, would make a
+# handy profiler - and autograd has that feature baked in. Here’s a quick
+# example usage:
+# 
+
+device = torch.device('cpu')
+run_on_gpu = False
+if torch.cuda.is_available():
+    device = torch.device('cuda')
+    run_on_gpu = True
+    
+x = torch.randn(2, 3, requires_grad=True)
+y = torch.rand(2, 3, requires_grad=True)
+z = torch.ones(2, 3, requires_grad=True)
+
+with torch.autograd.profiler.profile(use_cuda=run_on_gpu) as prf:
+    for _ in range(1000):
+        z = (z / x) * y
+        
+print(prf.key_averages().table(sort_by='self_cpu_time_total'))
+
+
+##########################################################################
+# The profiler can also label individual sub-blocks of code, break out the
+# data by input tensor shape, and export data as a Chrome tracing tools
+# file. For full details of the API, see the
+# `documentation <https://pytorch.org/docs/stable/autograd.html#profiler>`__.
+# 
+# Advanced Topic: More Autograd Detail and the High-Level API
+# -----------------------------------------------------------
+# 
+# If you have a function with an n-dimensional input and m-dimensional
+# output, :math:`\vec{y}=f(\vec{x})`, the complete gradient is a matrix of
+# the derivative of every output with respect to every input, called the
+# *Jacobian:*
+# 
+# .. math::
+#
+#      J
+#      =
+#      \left(\begin{array}{ccc}
+#      \frac{\partial y_{1}}{\partial x_{1}} & \cdots & \frac{\partial y_{1}}{\partial x_{n}}\\
+#      \vdots & \ddots & \vdots\\
+#      \frac{\partial y_{m}}{\partial x_{1}} & \cdots & \frac{\partial y_{m}}{\partial x_{n}}
+#      \end{array}\right)
+# 
+# If you have a second function, :math:`l=g\left(\vec{y}\right)` that
+# takes m-dimensional input (that is, the same dimensionality as the
+# output above), and returns a scalar output, you can express its
+# gradients with respect to :math:`\vec{y}` as a column vector,
+# :math:`v=\left(\begin{array}{ccc}\frac{\partial l}{\partial y_{1}} & \cdots & \frac{\partial l}{\partial y_{m}}\end{array}\right)^{T}`
+# - which is really just a one-column Jacobian.
+# 
+# More concretely, imagine the first function as your PyTorch model (with
+# potentially many inputs and many outputs) and the second function as a
+# loss function (with the model’s output as input, and the loss value as
+# the scalar output).
+# 
+# If we multiply the first function’s Jacobian by the gradient of the
+# second function, and apply the chain rule, we get:
+# 
+# .. math::
+#
+#    J^{T}\cdot v=\left(\begin{array}{ccc}
+#    \frac{\partial y_{1}}{\partial x_{1}} & \cdots & \frac{\partial y_{m}}{\partial x_{1}}\\
+#    \vdots & \ddots & \vdots\\
+#    \frac{\partial y_{1}}{\partial x_{n}} & \cdots & \frac{\partial y_{m}}{\partial x_{n}}
+#    \end{array}\right)\left(\begin{array}{c}
+#    \frac{\partial l}{\partial y_{1}}\\
+#    \vdots\\
+#    \frac{\partial l}{\partial y_{m}}
+#    \end{array}\right)=\left(\begin{array}{c}
+#    \frac{\partial l}{\partial x_{1}}\\
+#    \vdots\\
+#    \frac{\partial l}{\partial x_{n}}
+#    \end{array}\right)
+# 
+# Note: You could also use the equivalent operation :math:`v^{T}\cdot J`,
+# and get back a row vector.
+# 
+# The resulting column vector is the *gradient of the second function with
+# respect to the inputs of the first* - or in the case of our model and
+# loss function, the gradient of the loss with respect to the model
+# inputs.
+# 
+# **``torch.autograd`` is an engine for computing these products.** This
+# is how we accumulate the gradients over the learning weights during the
+# backward pass.
+# 
+# For this reason, the ``backward()`` call can *also* take an optional
+# vector input. This vector represents a set of gradients over the tensor,
+# which are multiplied by the Jacobian of the autograd-traced tensor that
+# precedes it. Let’s try a specific example with a small vector:
+# 
+
+x = torch.randn(3, requires_grad=True)
+
+y = x * 2
+while y.data.norm() < 1000:
+    y = y * 2
+
+print(y)
+
+
+##########################################################################
+# If we tried to call ``y.backward()`` now, we’d get a runtime error and a
+# message that gradients can only be *implicitly* computed for scalar
+# outputs. For a multi-dimensional output, autograd expects us to provide
+# gradients for those three outputs that it can multiply into the
+# Jacobian:
+# 
+
+v = torch.tensor([0.1, 1.0, 0.0001], dtype=torch.float) # stand-in for gradients
+y.backward(v)
+
+print(x.grad)
+
+
+##########################################################################
+# (Note that the output gradients are all related to powers of two - which
+# we’d expect from a repeated doubling operation.)
+# 
+# The High-Level API
+# ~~~~~~~~~~~~~~~~~~
+# 
+# There is an API on autograd that gives you direct access to important
+# differential matrix and vector operations. In particular, it allows you
+# to calculate the Jacobian and the *Hessian* matrices of a particular
+# function for particular inputs. (The Hessian is like the Jacobian, but
+# expresses all partial *second* derivatives.) It also provides methods
+# for taking vector products with these matrices.
+# 
+# Let’s take the Jacobian of a simple function, evaluated for a 2
+# single-element inputs:
+# 
+
+def exp_adder(x, y):
+    return 2 * x.exp() + 3 * y
+
+inputs = (torch.rand(1), torch.rand(1)) # arguments for the function
+print(inputs)
+torch.autograd.functional.jacobian(exp_adder, inputs)
+
+
+########################################################################
+# If you look closely, the first output should equal :math:`2e^x` (since
+# the derivative of :math:`e^x` is :math:`e^x`), and the second value
+# should be 3.
+# 
+# You can, of course, do this with higher-order tensors:
+# 
+
+inputs = (torch.rand(3), torch.rand(3)) # arguments for the function
+print(inputs)
+torch.autograd.functional.jacobian(exp_adder, inputs)
+
+
+#########################################################################
+# The ``torch.autograd.functional.hessian()`` method works identically
+# (assuming your function is twice differentiable), but returns a matrix
+# of all second derivatives.
+# 
+# There is also a function to directly compute the vector-Jacobian
+# product, if you provide the vector:
+# 
+
+def do_some_doubling(x):
+    y = x * 2
+    while y.data.norm() < 1000:
+        y = y * 2
+    return y
+
+inputs = torch.randn(3)
+my_gradients = torch.tensor([0.1, 1.0, 0.0001])
+torch.autograd.functional.vjp(do_some_doubling, inputs, v=my_gradients)
+
+
+##############################################################################
+# The ``torch.autograd.functional.jvp()`` method performs the same matrix
+# multiplication as ``vjp()`` with the operands reversed. The ``vhp()``
+# and ``hvp()`` methods do the same for a vector-Hessian product.
+# 
+# For more information, including performance notes on the `docs for the
+# functional
+# API <https://pytorch.org/docs/stable/autograd.html#functional-higher-level-api>`__
+# 
diff --git a/beginner_source/introyt/captumyt.py b/beginner_source/introyt/captumyt.py
new file mode 100644
index 00000000000..abf2391d254
--- /dev/null
+++ b/beginner_source/introyt/captumyt.py
@@ -0,0 +1,499 @@
+"""
+`Introduction <introyt1_tutorial.html>`_ ||
+`Tensors <tensors_deeper_tutorial.html>`_ ||
+`Autograd <autogradyt_tutorial.html>`_ ||
+`Building Models <modelsyt_tutorial.html>`_ ||
+`TensorBoard Support <tensorboardyt_tutorial.html>`_ ||
+`Training Models <trainingyt.html>`_ ||
+**Model Understanding**
+
+Model Understanding with Captum
+===============================
+
+Follow along with the video below or on `youtube <https://www.youtube.com/watch?v=Am2EF9CLu-g>`__. Download the notebook and corresponding files
+`here <https://pytorch-tutorial-assets.s3.amazonaws.com/youtube-series/video7.zip>`__.
+
+.. raw:: html
+
+   <div style="margin-top:10px; margin-bottom:10px;">
+     <iframe width="560" height="315" src="https://www.youtube.com/embed/Am2EF9CLu-g" frameborder="0" allow="accelerometer; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
+   </div>
+
+`Captum <https://captum.ai/>`__ (“comprehension” in Latin) is an open
+source, extensible library for model interpretability built on PyTorch.
+
+With the increase in model complexity and the resulting lack of
+transparency, model interpretability methods have become increasingly
+important. Model understanding is both an active area of research as
+well as an area of focus for practical applications across industries
+using machine learning. Captum provides state-of-the-art algorithms,
+including Integrated Gradients, to provide researchers and developers
+with an easy way to understand which features are contributing to a
+model’s output.
+
+Full documentation, an API reference, and a suite of tutorials on
+specific topics are available at the `captum.ai <https://captum.ai/>`__
+website.
+
+Introduction
+------------
+
+Captum’s approach to model interpretability is in terms of
+*attributions.* There are three kinds of attributions available in
+Captum:
+
+-  **Feature Attribution** seeks to explain a particular output in terms
+   of features of the input that generated it. Explaining whether a
+   movie review was positive or negative in terms of certain words in
+   the review is an example of feature attribution.
+-  **Layer Attribution** examines the activity of a model’s hidden layer
+   subsequent to a particular input. Examining the spatially-mapped
+   output of a convolutional layer in response to an input image in an
+   example of layer attribution.
+-  **Neuron Attribution** is analagous to layer attribution, but focuses
+   on the activity of a single neuron.
+
+In this interactive notebook, we’ll look at Feature Attribution and
+Layer Attribution.
+
+Each of the three attribution types has multiple **attribution
+algorithms** associated with it. Many attribution algorithms fall into
+two broad categories:
+
+-  **Gradient-based algorithms** calculate the backward gradients of a
+   model output, layer output, or neuron activation with respect to the
+   input. **Integrated Gradients** (for features), **Layer Gradient \*
+   Activation**, and **Neuron Conductance** are all gradient-based
+   algorithms.
+-  **Perturbation-based algorithms** examine the changes in the output
+   of a model, layer, or neuron in response to changes in the input. The
+   input perturbations may be directed or random. **Occlusion,**
+   **Feature Ablation,** and **Feature Permutation** are all
+   perturbation-based algorithms.
+
+We’ll be examining algorithms of both types below.
+
+Especially where large models are involved, it can be valuable to
+visualize attribution data in ways that relate it easily to the input
+features being examined. While it is certainly possible to create your
+own visualizations with Matplotlib, Plotly, or similar tools, Captum
+offers enhanced tools specific to its attributions:
+
+-  The ``captum.attr.visualization`` module (imported below as ``viz``)
+   provides helpful functions for visualizing attributions related to
+   images.
+-  **Captum Insights** is an easy-to-use API on top of Captum that
+   provides a visualization widget with ready-made visualizations for
+   image, text, and arbitrary model types.
+
+Both of these visualization toolsets will be demonstrated in this
+notebook. The first few examples will focus on computer vision use
+cases, but the Captum Insights section at the end will demonstrate
+visualization of attributions in a multi-model, visual
+question-and-answer model.
+
+Installation
+------------
+
+Before you get started, you need to have a Python environment with:
+
+-  Python version 3.6 or higher
+-  For the Captum Insights example, Flask 1.1 or higher and Flask-Compress
+   (the latest version is recommended)
+-  PyTorch version 1.2 or higher (the latest version is recommended)
+-  TorchVision version 0.6 or higher (the latest version is recommended)
+-  Captum (the latest version is recommended)
+-  Matplotlib version 3.3.4, since Captum currently uses a Matplotlib
+   function whose arguments have been renamed in later versions
+
+To install Captum in an Anaconda or pip virtual environment, use the
+appropriate command for your environment below:
+
+With ``conda``:
+
+.. code-block:: sh
+
+    conda install pytorch torchvision captum flask-compress matplotlib=3.3.4 -c pytorch
+
+With ``pip``:
+
+.. code-block:: sh
+
+    pip install torch torchvision captum matplotlib==3.3.4 Flask-Compress
+
+Restart this notebook in the environment you set up, and you’re ready to
+go!
+
+
+A First Example
+---------------
+ 
+To start, let’s take a simple, visual example. We’ll start with a ResNet
+model pretrained on the ImageNet dataset. We’ll get a test input, and
+use different **Feature Attribution** algorithms to examine how the
+input images affect the output, and see a helpful visualization of this
+input attribution map for some test images.
+ 
+First, some imports: 
+
+"""
+
+import torch
+import torch.nn.functional as F
+import torchvision.transforms as transforms
+import torchvision.models as models
+
+import captum
+from captum.attr import IntegratedGradients, Occlusion, LayerGradCam, LayerAttribution
+from captum.attr import visualization as viz
+
+import os, sys
+import json
+
+import numpy as np
+from PIL import Image
+import matplotlib.pyplot as plt
+from matplotlib.colors import LinearSegmentedColormap
+
+
+#########################################################################
+# Now we’ll use the TorchVision model library to download a pretrained
+# ResNet. Since we’re not training, we’ll place it in evaluation mode for
+# now.
+# 
+
+model = models.resnet18(weights='IMAGENET1K_V1')
+model = model.eval()
+
+
+#######################################################################
+# The place where you got this interactive notebook should also have an
+# ``img`` folder with a file ``cat.jpg`` in it.
+# 
+
+test_img = Image.open('img/cat.jpg')
+test_img_data = np.asarray(test_img)
+plt.imshow(test_img_data)
+plt.show()
+
+
+##########################################################################
+# Our ResNet model was trained on the ImageNet dataset, and expects images
+# to be of a certain size, with the channel data normalized to a specific
+# range of values. We’ll also pull in the list of human-readable labels
+# for the categories our model recognizes - that should be in the ``img``
+# folder as well.
+# 
+
+# model expects 224x224 3-color image
+transform = transforms.Compose([
+ transforms.Resize(224),
+ transforms.CenterCrop(224),
+ transforms.ToTensor()
+])
+
+# standard ImageNet normalization
+transform_normalize = transforms.Normalize(
+     mean=[0.485, 0.456, 0.406],
+     std=[0.229, 0.224, 0.225]
+ )
+
+transformed_img = transform(test_img)
+input_img = transform_normalize(transformed_img)
+input_img = input_img.unsqueeze(0) # the model requires a dummy batch dimension
+
+labels_path = 'img/imagenet_class_index.json'
+with open(labels_path) as json_data:
+    idx_to_labels = json.load(json_data)
+
+
+######################################################################
+# Now, we can ask the question: What does our model think this image
+# represents?
+# 
+
+output = model(input_img)
+output = F.softmax(output, dim=1)
+prediction_score, pred_label_idx = torch.topk(output, 1)
+pred_label_idx.squeeze_()
+predicted_label = idx_to_labels[str(pred_label_idx.item())][1]
+print('Predicted:', predicted_label, '(', prediction_score.squeeze().item(), ')')
+
+
+######################################################################
+# We’ve confirmed that ResNet thinks our image of a cat is, in fact, a
+# cat. But *why* does the model think this is an image of a cat?
+# 
+# For the answer to that, we turn to Captum.
+# 
+
+
+##########################################################################
+# Feature Attribution with Integrated Gradients
+# ---------------------------------------------
+# 
+# **Feature attribution** attributes a particular output to features of
+# the input. It uses a specific input - here, our test image - to generate
+# a map of the relative importance of each input feature to a particular
+# output feature.
+# 
+# `Integrated
+# Gradients <https://captum.ai/api/integrated_gradients.html>`__ is one of
+# the feature attribution algorithms available in Captum. Integrated
+# Gradients assigns an importance score to each input feature by
+# approximating the integral of the gradients of the model’s output with
+# respect to the inputs.
+# 
+# In our case, we’re going to be taking a specific element of the output
+# vector - that is, the one indicating the model’s confidence in its
+# chosen category - and use Integrated Gradients to understand what parts
+# of the input image contributed to this output.
+# 
+# Once we have the importance map from Integrated Gradients, we’ll use the
+# visualization tools in Captum to give a helpful representation of the
+# importance map. Captum’s ``visualize_image_attr()`` function provides a
+# variety of options for customizing display of your attribution data.
+# Here, we pass in a custom Matplotlib color map.
+# 
+# Running the cell with the ``integrated_gradients.attribute()`` call will
+# usually take a minute or two.
+# 
+
+# Initialize the attribution algorithm with the model
+integrated_gradients = IntegratedGradients(model)
+
+# Ask the algorithm to attribute our output target to 
+attributions_ig = integrated_gradients.attribute(input_img, target=pred_label_idx, n_steps=200)
+
+# Show the original image for comparison
+_ = viz.visualize_image_attr(None, np.transpose(transformed_img.squeeze().cpu().detach().numpy(), (1,2,0)), 
+                      method="original_image", title="Original Image")
+
+default_cmap = LinearSegmentedColormap.from_list('custom blue', 
+                                                 [(0, '#ffffff'),
+                                                  (0.25, '#0000ff'),
+                                                  (1, '#0000ff')], N=256)
+
+_ = viz.visualize_image_attr(np.transpose(attributions_ig.squeeze().cpu().detach().numpy(), (1,2,0)),
+                             np.transpose(transformed_img.squeeze().cpu().detach().numpy(), (1,2,0)),
+                             method='heat_map',
+                             cmap=default_cmap,
+                             show_colorbar=True,
+                             sign='positive',
+                             title='Integrated Gradients')
+
+
+#######################################################################
+# In the image above, you should see that Integrated Gradients gives us
+# the strongest signal around the cat’s location in the image.
+# 
+
+
+##########################################################################
+# Feature Attribution with Occlusion
+# ----------------------------------
+# 
+# Gradient-based attribution methods help to understand the model in terms
+# of directly computing out the output changes with respect to the input.
+# *Perturbation-based attribution* methods approach this more directly, by
+# introducing changes to the input to measure the effect on the output.
+# `Occlusion <https://captum.ai/api/occlusion.html>`__ is one such method.
+# It involves replacing sections of the input image, and examining the
+# effect on the output signal.
+# 
+# Below, we set up Occlusion attribution. Similarly to configuring a
+# convolutional neural network, you can specify the size of the target
+# region, and a stride length to determine the spacing of individual
+# measurements. We’ll visualize the output of our Occlusion attribution
+# with ``visualize_image_attr_multiple()``, showing heat maps of both
+# positive and negative attribution by region, and by masking the original
+# image with the positive attribution regions. The masking gives a very
+# instructive view of what regions of our cat photo the model found to be
+# most “cat-like”.
+# 
+
+occlusion = Occlusion(model)
+
+attributions_occ = occlusion.attribute(input_img,
+                                       target=pred_label_idx,
+                                       strides=(3, 8, 8),
+                                       sliding_window_shapes=(3,15, 15),
+                                       baselines=0)
+
+
+_ = viz.visualize_image_attr_multiple(np.transpose(attributions_occ.squeeze().cpu().detach().numpy(), (1,2,0)),
+                                      np.transpose(transformed_img.squeeze().cpu().detach().numpy(), (1,2,0)),
+                                      ["original_image", "heat_map", "heat_map", "masked_image"],
+                                      ["all", "positive", "negative", "positive"],
+                                      show_colorbar=True,
+                                      titles=["Original", "Positive Attribution", "Negative Attribution", "Masked"],
+                                      fig_size=(18, 6)
+                                     )
+
+
+######################################################################
+# Again, we see greater significance placed on the region of the image
+# that contains the cat.
+# 
+
+
+#########################################################################
+# Layer Attribution with Layer GradCAM
+# ------------------------------------
+# 
+# **Layer Attribution** allows you to attribute the activity of hidden
+# layers within your model to features of your input. Below, we’ll use a
+# layer attribution algorithm to examine the activity of one of the
+# convolutional layers within our model.
+# 
+# GradCAM computes the gradients of the target output with respect to the
+# given layer, averages for each output channel (dimension 2 of output),
+# and multiplies the average gradient for each channel by the layer
+# activations. The results are summed over all channels. GradCAM is
+# designed for convnets; since the activity of convolutional layers often
+# maps spatially to the input, GradCAM attributions are often upsampled
+# and used to mask the input.
+# 
+# Layer attribution is set up similarly to input attribution, except that
+# in addition to the model, you must specify a hidden layer within the
+# model that you wish to examine. As above, when we call ``attribute()``,
+# we specify the target class of interest.
+# 
+
+layer_gradcam = LayerGradCam(model, model.layer3[1].conv2)
+attributions_lgc = layer_gradcam.attribute(input_img, target=pred_label_idx)
+
+_ = viz.visualize_image_attr(attributions_lgc[0].cpu().permute(1,2,0).detach().numpy(),
+                             sign="all",
+                             title="Layer 3 Block 1 Conv 2")
+
+
+##########################################################################
+# We’ll use the convenience method ``interpolate()`` in the
+# `LayerAttribution <https://captum.ai/api/base_classes.html?highlight=layerattribution#captum.attr.LayerAttribution>`__
+# base class to upsample this attribution data for comparison to the input
+# image.
+# 
+
+upsamp_attr_lgc = LayerAttribution.interpolate(attributions_lgc, input_img.shape[2:])
+
+print(attributions_lgc.shape)
+print(upsamp_attr_lgc.shape)
+print(input_img.shape)
+
+_ = viz.visualize_image_attr_multiple(upsamp_attr_lgc[0].cpu().permute(1,2,0).detach().numpy(),
+                                      transformed_img.permute(1,2,0).numpy(),
+                                      ["original_image","blended_heat_map","masked_image"],
+                                      ["all","positive","positive"],
+                                      show_colorbar=True,
+                                      titles=["Original", "Positive Attribution", "Masked"],
+                                      fig_size=(18, 6))
+
+
+#######################################################################
+# Visualizations such as this can give you novel insights into how your
+# hidden layers respond to your input.
+# 
+
+
+##########################################################################
+# Visualization with Captum Insights
+# ----------------------------------
+# 
+# Captum Insights is an interpretability visualization widget built on top
+# of Captum to facilitate model understanding. Captum Insights works
+# across images, text, and other features to help users understand feature
+# attribution. It allows you to visualize attribution for multiple
+# input/output pairs, and provides visualization tools for image, text,
+# and arbitrary data.
+# 
+# In this section of the notebook, we’ll visualize multiple image
+# classification inferences with Captum Insights.
+# 
+# First, let’s gather some image and see what the model thinks of them.
+# For variety, we’ll take our cat, a teapot, and a trilobite fossil:
+# 
+
+imgs = ['img/cat.jpg', 'img/teapot.jpg', 'img/trilobite.jpg']
+
+for img in imgs:
+    img = Image.open(img)
+    transformed_img = transform(img)
+    input_img = transform_normalize(transformed_img)
+    input_img = input_img.unsqueeze(0) # the model requires a dummy batch dimension
+
+    output = model(input_img)
+    output = F.softmax(output, dim=1)
+    prediction_score, pred_label_idx = torch.topk(output, 1)
+    pred_label_idx.squeeze_()
+    predicted_label = idx_to_labels[str(pred_label_idx.item())][1]
+    print('Predicted:', predicted_label, '/', pred_label_idx.item(), ' (', prediction_score.squeeze().item(), ')')
+
+
+##########################################################################
+# …and it looks like our model is identifying them all correctly - but of
+# course, we want to dig deeper. For that we’ll use the Captum Insights
+# widget, which we configure with an ``AttributionVisualizer`` object,
+# imported below. The ``AttributionVisualizer`` expects batches of data,
+# so we’ll bring in Captum’s ``Batch`` helper class. And we’ll be looking
+# at images specifically, so well also import ``ImageFeature``.
+# 
+# We configure the ``AttributionVisualizer`` with the following arguments:
+# 
+# -  An array of models to be examined (in our case, just the one)
+# -  A scoring function, which allows Captum Insights to pull out the
+#    top-k predictions from a model
+# -  An ordered, human-readable list of classes our model is trained on
+# -  A list of features to look for - in our case, an ``ImageFeature``
+# -  A dataset, which is an iterable object returning batches of inputs
+#    and labels - just like you’d use for training
+# 
+
+from captum.insights import AttributionVisualizer, Batch
+from captum.insights.attr_vis.features import ImageFeature
+
+# Baseline is all-zeros input - this may differ depending on your data
+def baseline_func(input):
+    return input * 0
+
+# merging our image transforms from above
+def full_img_transform(input):
+    i = Image.open(input)
+    i = transform(i)
+    i = transform_normalize(i)
+    i = i.unsqueeze(0)
+    return i
+
+
+input_imgs = torch.cat(list(map(lambda i: full_img_transform(i), imgs)), 0)
+
+visualizer = AttributionVisualizer(
+    models=[model],
+    score_func=lambda o: torch.nn.functional.softmax(o, 1),
+    classes=list(map(lambda k: idx_to_labels[k][1], idx_to_labels.keys())),
+    features=[
+        ImageFeature(
+            "Photo",
+            baseline_transforms=[baseline_func],
+            input_transforms=[],
+        )
+    ],
+    dataset=[Batch(input_imgs, labels=[282,849,69])]
+)
+
+
+#########################################################################
+# Note that running the cell above didn’t take much time at all, unlike
+# our attributions above. That’s because Captum Insights lets you
+# configure different attribution algorithms in a visual widget, after
+# which it will compute and display the attributions. *That* process will
+# take a few minutes.
+# 
+# Running the cell below will render the Captum Insights widget. You can
+# then choose attributions methods and their arguments, filter model
+# responses based on predicted class or prediction correctness, see the
+# model’s predictions with associated probabilities, and view heatmaps of
+# the attribution compared with the original image.
+# 
+
+visualizer.render()
diff --git a/beginner_source/introyt/introyt1_tutorial.py b/beginner_source/introyt/introyt1_tutorial.py
new file mode 100644
index 00000000000..c01befb40cc
--- /dev/null
+++ b/beginner_source/introyt/introyt1_tutorial.py
@@ -0,0 +1,631 @@
+"""
+**Introduction** ||
+`Tensors <tensors_deeper_tutorial.html>`_ ||
+`Autograd <autogradyt_tutorial.html>`_ ||
+`Building Models <modelsyt_tutorial.html>`_ ||
+`TensorBoard Support <tensorboardyt_tutorial.html>`_ ||
+`Training Models <trainingyt.html>`_ ||
+`Model Understanding <captumyt.html>`_
+
+Introduction to PyTorch
+=======================
+
+Follow along with the video below or on `youtube <https://www.youtube.com/watch?v=IC0_FRiX-sw>`__.
+
+.. raw:: html
+
+   <div style="margin-top:10px; margin-bottom:10px;">
+     <iframe width="560" height="315" src="https://www.youtube.com/embed/IC0_FRiX-sw" frameborder="0" allow="accelerometer; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
+   </div>
+
+PyTorch Tensors
+---------------
+
+Follow along with the video beginning at `03:50 <https://www.youtube.com/watch?v=IC0_FRiX-sw&t=230s>`__.
+
+First, we’ll import pytorch.
+
+"""
+
+import torch
+
+######################################################################
+# Let’s see a few basic tensor manipulations. First, just a few of the
+# ways to create tensors:
+# 
+
+z = torch.zeros(5, 3)
+print(z)
+print(z.dtype)
+
+
+#########################################################################
+# Above, we create a 5x3 matrix filled with zeros, and query its datatype
+# to find out that the zeros are 32-bit floating point numbers, which is
+# the default PyTorch.
+# 
+# What if you wanted integers instead? You can always override the
+# default:
+# 
+
+i = torch.ones((5, 3), dtype=torch.int16)
+print(i)
+
+
+######################################################################
+# You can see that when we do change the default, the tensor helpfully
+# reports this when printed.
+# 
+# It’s common to initialize learning weights randomly, often with a
+# specific seed for the PRNG for reproducibility of results:
+# 
+
+torch.manual_seed(1729)
+r1 = torch.rand(2, 2)
+print('A random tensor:')
+print(r1)
+
+r2 = torch.rand(2, 2)
+print('\nA different random tensor:')
+print(r2) # new values
+
+torch.manual_seed(1729)
+r3 = torch.rand(2, 2)
+print('\nShould match r1:')
+print(r3) # repeats values of r1 because of re-seed
+
+
+#######################################################################
+# PyTorch tensors perform arithmetic operations intuitively. Tensors of
+# similar shapes may be added, multiplied, etc. Operations with scalars
+# are distributed over the tensor:
+# 
+
+ones = torch.ones(2, 3)
+print(ones)
+
+twos = torch.ones(2, 3) * 2 # every element is multiplied by 2
+print(twos)
+
+threes = ones + twos       # addition allowed because shapes are similar
+print(threes)              # tensors are added element-wise
+print(threes.shape)        # this has the same dimensions as input tensors
+
+r1 = torch.rand(2, 3)
+r2 = torch.rand(3, 2)
+# uncomment this line to get a runtime error
+# r3 = r1 + r2
+
+
+######################################################################
+# Here’s a small sample of the mathematical operations available:
+# 
+
+r = (torch.rand(2, 2) - 0.5) * 2 # values between -1 and 1
+print('A random matrix, r:')
+print(r)
+
+# Common mathematical operations are supported:
+print('\nAbsolute value of r:')
+print(torch.abs(r))
+
+# ...as are trigonometric functions:
+print('\nInverse sine of r:')
+print(torch.asin(r))
+
+# ...and linear algebra operations like determinant and singular value decomposition
+print('\nDeterminant of r:')
+print(torch.det(r))
+print('\nSingular value decomposition of r:')
+print(torch.svd(r))
+
+# ...and statistical and aggregate operations:
+print('\nAverage and standard deviation of r:')
+print(torch.std_mean(r))
+print('\nMaximum value of r:')
+print(torch.max(r))
+
+
+##########################################################################
+# There’s a good deal more to know about the power of PyTorch tensors,
+# including how to set them up for parallel computations on GPU - we’ll be
+# going into more depth in another video.
+# 
+# PyTorch Models
+# --------------
+#
+# Follow along with the video beginning at `10:00 <https://www.youtube.com/watch?v=IC0_FRiX-sw&t=600s>`__.
+#
+# Let’s talk about how we can express models in PyTorch
+#
+
+import torch                     # for all things PyTorch
+import torch.nn as nn            # for torch.nn.Module, the parent object for PyTorch models
+import torch.nn.functional as F  # for the activation function
+
+
+#########################################################################
+# .. figure:: /_static/img/mnist.png
+#    :alt: le-net-5 diagram
+#
+# *Figure: LeNet-5*
+# 
+# Above is a diagram of LeNet-5, one of the earliest convolutional neural
+# nets, and one of the drivers of the explosion in Deep Learning. It was
+# built to read small images of handwritten numbers (the MNIST dataset),
+# and correctly classify which digit was represented in the image.
+# 
+# Here’s the abridged version of how it works:
+# 
+# -  Layer C1 is a convolutional layer, meaning that it scans the input
+#    image for features it learned during training. It outputs a map of
+#    where it saw each of its learned features in the image. This
+#    “activation map” is downsampled in layer S2.
+# -  Layer C3 is another convolutional layer, this time scanning C1’s
+#    activation map for *combinations* of features. It also puts out an
+#    activation map describing the spatial locations of these feature
+#    combinations, which is downsampled in layer S4.
+# -  Finally, the fully-connected layers at the end, F5, F6, and OUTPUT,
+#    are a *classifier* that takes the final activation map, and
+#    classifies it into one of ten bins representing the 10 digits.
+# 
+# How do we express this simple neural network in code?
+# 
+
+class LeNet(nn.Module):
+
+    def __init__(self):
+        super(LeNet, self).__init__()
+        # 1 input image channel (black & white), 6 output channels, 5x5 square convolution
+        # kernel
+        self.conv1 = nn.Conv2d(1, 6, 5)
+        self.conv2 = nn.Conv2d(6, 16, 5)
+        # an affine operation: y = Wx + b
+        self.fc1 = nn.Linear(16 * 5 * 5, 120)  # 5*5 from image dimension
+        self.fc2 = nn.Linear(120, 84)
+        self.fc3 = nn.Linear(84, 10)
+
+    def forward(self, x):
+        # Max pooling over a (2, 2) window
+        x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
+        # If the size is a square you can only specify a single number
+        x = F.max_pool2d(F.relu(self.conv2(x)), 2)
+        x = x.view(-1, self.num_flat_features(x))
+        x = F.relu(self.fc1(x))
+        x = F.relu(self.fc2(x))
+        x = self.fc3(x)
+        return x
+
+    def num_flat_features(self, x):
+        size = x.size()[1:]  # all dimensions except the batch dimension
+        num_features = 1
+        for s in size:
+            num_features *= s
+        return num_features
+
+
+############################################################################
+# Looking over this code, you should be able to spot some structural
+# similarities with the diagram above.
+# 
+# This demonstrates the structure of a typical PyTorch model: 
+#
+# -  It inherits from ``torch.nn.Module`` - modules may be nested - in fact,
+#    even the ``Conv2d`` and ``Linear`` layer classes inherit from
+#    ``torch.nn.Module``.
+# -  A model will have an ``__init__()`` function, where it instantiates
+#    its layers, and loads any data artifacts it might
+#    need (e.g., an NLP model might load a vocabulary).
+# -  A model will have a ``forward()`` function. This is where the actual
+#    computation happens: An input is passed through the network layers
+#    and various functions to generate an output.
+# -  Other than that, you can build out your model class like any other
+#    Python class, adding whatever properties and methods you need to
+#    support your model’s computation.
+# 
+# Let’s instantiate this object and run a sample input through it.
+# 
+
+net = LeNet()
+print(net)                         # what does the object tell us about itself?
+
+input = torch.rand(1, 1, 32, 32)   # stand-in for a 32x32 black & white image
+print('\nImage batch shape:')
+print(input.shape)
+
+output = net(input)                # we don't call forward() directly
+print('\nRaw output:')
+print(output)
+print(output.shape)
+
+
+##########################################################################
+# There are a few important things happening above:
+# 
+# First, we instantiate the ``LeNet`` class, and we print the ``net``
+# object. A subclass of ``torch.nn.Module`` will report the layers it has
+# created and their shapes and parameters. This can provide a handy
+# overview of a model if you want to get the gist of its processing.
+# 
+# Below that, we create a dummy input representing a 32x32 image with 1
+# color channel. Normally, you would load an image tile and convert it to
+# a tensor of this shape.
+# 
+# You may have noticed an extra dimension to our tensor - the *batch
+# dimension.* PyTorch models assume they are working on *batches* of data
+# - for example, a batch of 16 of our image tiles would have the shape
+# ``(16, 1, 32, 32)``. Since we’re only using one image, we create a batch
+# of 1 with shape ``(1, 1, 32, 32)``.
+# 
+# We ask the model for an inference by calling it like a function:
+# ``net(input)``. The output of this call represents the model’s
+# confidence that the input represents a particular digit. (Since this
+# instance of the model hasn’t learned anything yet, we shouldn’t expect
+# to see any signal in the output.) Looking at the shape of ``output``, we
+# can see that it also has a batch dimension, the size of which should
+# always match the input batch dimension. If we had passed in an input
+# batch of 16 instances, ``output`` would have a shape of ``(16, 10)``.
+# 
+# Datasets and Dataloaders
+# ------------------------
+#
+# Follow along with the video beginning at `14:00 <https://www.youtube.com/watch?v=IC0_FRiX-sw&t=840s>`__.
+#
+# Below, we’re going to demonstrate using one of the ready-to-download,
+# open-access datasets from TorchVision, how to transform the images for
+# consumption by your model, and how to use the DataLoader to feed batches
+# of data to your model.
+#
+# The first thing we need to do is transform our incoming images into a
+# PyTorch tensor.
+#
+
+#%matplotlib inline
+
+import torch
+import torchvision
+import torchvision.transforms as transforms
+
+transform = transforms.Compose(
+    [transforms.ToTensor(),
+     transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2470, 0.2435, 0.2616))])
+
+
+##########################################################################
+# Here, we specify two transformations for our input:
+#
+# -  ``transforms.ToTensor()`` converts images loaded by Pillow into 
+#    PyTorch tensors.
+# -  ``transforms.Normalize()`` adjusts the values of the tensor so
+#    that their average is zero and their standard deviation is 1.0. Most
+#    activation functions have their strongest gradients around x = 0, so
+#    centering our data there can speed learning.
+#    The values passed to the transform are the means (first tuple) and the
+#    standard deviations (second tuple) of the rgb values of the images in
+#    the dataset. You can calculate these values yourself by running these
+#    few lines of code::
+#
+#        from torch.utils.data import ConcatDataset
+#        transform = transforms.Compose([transforms.ToTensor()])
+#        trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
+#                                        download=True, transform=transform)
+#
+#        # stack all train images together into a tensor of shape 
+#        # (50000, 3, 32, 32)
+#        x = torch.stack([sample[0] for sample in ConcatDataset([trainset])])
+#           
+#        # get the mean of each channel            
+#        mean = torch.mean(x, dim=(0,2,3)) # tensor([0.4914, 0.4822, 0.4465])
+#        std = torch.std(x, dim=(0,2,3)) # tensor([0.2470, 0.2435, 0.2616])  
+#    
+# 
+# There are many more transforms available, including cropping, centering,
+# rotation, and reflection.
+# 
+# Next, we’ll create an instance of the CIFAR10 dataset. This is a set of
+# 32x32 color image tiles representing 10 classes of objects: 6 of animals
+# (bird, cat, deer, dog, frog, horse) and 4 of vehicles (airplane,
+# automobile, ship, truck):
+# 
+
+trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
+                                        download=True, transform=transform)
+
+
+##########################################################################
+# .. note::
+#      When you run the cell above, it may take a little time for the 
+#      dataset to download.
+# 
+# This is an example of creating a dataset object in PyTorch. Downloadable
+# datasets (like CIFAR-10 above) are subclasses of
+# ``torch.utils.data.Dataset``. ``Dataset`` classes in PyTorch include the
+# downloadable datasets in TorchVision, Torchtext, and TorchAudio, as well
+# as utility dataset classes such as ``torchvision.datasets.ImageFolder``,
+# which will read a folder of labeled images. You can also create your own
+# subclasses of ``Dataset``.
+# 
+# When we instantiate our dataset, we need to tell it a few things:
+#
+# -  The filesystem path to where we want the data to go. 
+# -  Whether or not we are using this set for training; most datasets
+#    will be split into training and test subsets.
+# -  Whether we would like to download the dataset if we haven’t already.
+# -  The transformations we want to apply to the data.
+# 
+# Once your dataset is ready, you can give it to the ``DataLoader``:
+# 
+
+trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
+                                          shuffle=True, num_workers=2)
+
+
+##########################################################################
+# A ``Dataset`` subclass wraps access to the data, and is specialized to
+# the type of data it’s serving. The ``DataLoader`` knows *nothing* about
+# the data, but organizes the input tensors served by the ``Dataset`` into
+# batches with the parameters you specify.
+# 
+# In the example above, we’ve asked a ``DataLoader`` to give us batches of
+# 4 images from ``trainset``, randomizing their order (``shuffle=True``),
+# and we told it to spin up two workers to load data from disk.
+# 
+# It’s good practice to visualize the batches your ``DataLoader`` serves:
+# 
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+classes = ('plane', 'car', 'bird', 'cat',
+           'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
+
+def imshow(img):
+    img = img / 2 + 0.5     # unnormalize
+    npimg = img.numpy()
+    plt.imshow(np.transpose(npimg, (1, 2, 0)))
+
+
+# get some random training images
+dataiter = iter(trainloader)
+images, labels = next(dataiter)
+
+# show images
+imshow(torchvision.utils.make_grid(images))
+# print labels
+print(' '.join('%5s' % classes[labels[j]] for j in range(4)))
+
+
+########################################################################
+# Running the above cell should show you a strip of four images, and the
+# correct label for each.
+# 
+# Training Your PyTorch Model
+# ---------------------------
+#
+# Follow along with the video beginning at `17:10 <https://www.youtube.com/watch?v=IC0_FRiX-sw&t=1030s>`__.
+#
+# Let’s put all the pieces together, and train a model:
+#
+
+#%matplotlib inline
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.optim as optim
+
+import torchvision
+import torchvision.transforms as transforms
+
+import matplotlib
+import matplotlib.pyplot as plt
+import numpy as np
+
+
+#########################################################################
+# First, we’ll need training and test datasets. If you haven’t already,
+# run the cell below to make sure the dataset is downloaded. (It may take
+# a minute.)
+# 
+
+transform = transforms.Compose(
+    [transforms.ToTensor(),
+     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
+
+trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
+                                        download=True, transform=transform)
+trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
+                                          shuffle=True, num_workers=2)
+
+testset = torchvision.datasets.CIFAR10(root='./data', train=False,
+                                       download=True, transform=transform)
+testloader = torch.utils.data.DataLoader(testset, batch_size=4,
+                                         shuffle=False, num_workers=2)
+
+classes = ('plane', 'car', 'bird', 'cat',
+           'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
+
+
+######################################################################
+# We’ll run our check on the output from ``DataLoader``:
+# 
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+# functions to show an image
+
+
+def imshow(img):
+    img = img / 2 + 0.5     # unnormalize
+    npimg = img.numpy()
+    plt.imshow(np.transpose(npimg, (1, 2, 0)))
+
+
+# get some random training images
+dataiter = iter(trainloader)
+images, labels = next(dataiter)
+
+# show images
+imshow(torchvision.utils.make_grid(images))
+# print labels
+print(' '.join('%5s' % classes[labels[j]] for j in range(4)))
+
+
+##########################################################################
+# This is the model we’ll train. If it looks familiar, that’s because it’s
+# a variant of LeNet - discussed earlier in this video - adapted for
+# 3-color images.
+# 
+
+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()
+
+
+######################################################################
+# The last ingredients we need are a loss function and an optimizer:
+# 
+
+criterion = nn.CrossEntropyLoss()
+optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
+
+
+##########################################################################
+# The loss function, as discussed earlier in this video, is a measure of
+# how far from our ideal output the model’s prediction was. Cross-entropy
+# loss is a typical loss function for classification models like ours.
+# 
+# The **optimizer** is what drives the learning. Here we have created an
+# optimizer that implements *stochastic gradient descent,* one of the more
+# straightforward optimization algorithms. Besides parameters of the
+# algorithm, like the learning rate (``lr``) and momentum, we also pass in
+# ``net.parameters()``, which is a collection of all the learning weights
+# in the model - which is what the optimizer adjusts.
+# 
+# Finally, all of this is assembled into the training loop. Go ahead and
+# run this cell, as it will likely take a few minutes to execute:
+# 
+
+for epoch in range(2):  # loop over the dataset multiple times
+
+    running_loss = 0.0
+    for i, data in enumerate(trainloader, 0):
+        # get the inputs
+        inputs, labels = data
+
+        # zero the parameter gradients
+        optimizer.zero_grad()
+
+        # forward + backward + optimize
+        outputs = net(inputs)
+        loss = criterion(outputs, labels)
+        loss.backward()
+        optimizer.step()
+
+        # print statistics
+        running_loss += loss.item()
+        if i % 2000 == 1999:    # print every 2000 mini-batches
+            print('[%d, %5d] loss: %.3f' %
+                  (epoch + 1, i + 1, running_loss / 2000))
+            running_loss = 0.0
+
+print('Finished Training')
+
+
+########################################################################
+# Here, we are doing only **2 training epochs** (line 1) - that is, two
+# passes over the training dataset. Each pass has an inner loop that
+# **iterates over the training data** (line 4), serving batches of
+# transformed input images and their correct labels.
+# 
+# **Zeroing the gradients** (line 9) is an important step. Gradients are
+# accumulated over a batch; if we do not reset them for every batch, they
+# will keep accumulating, which will provide incorrect gradient values,
+# making learning impossible.
+# 
+# In line 12, we **ask the model for its predictions** on this batch. In
+# the following line (13), we compute the loss - the difference between
+# ``outputs`` (the model prediction) and ``labels`` (the correct output).
+# 
+# In line 14, we do the ``backward()`` pass, and calculate the gradients
+# that will direct the learning.
+# 
+# In line 15, the optimizer performs one learning step - it uses the
+# gradients from the ``backward()`` call to nudge the learning weights in
+# the direction it thinks will reduce the loss.
+# 
+# The remainder of the loop does some light reporting on the epoch number,
+# how many training instances have been completed, and what the collected
+# loss is over the training loop.
+# 
+# **When you run the cell above,** you should see something like this:
+# 
+# .. code-block:: sh
+# 
+#    [1,  2000] loss: 2.235
+#    [1,  4000] loss: 1.940
+#    [1,  6000] loss: 1.713
+#    [1,  8000] loss: 1.573
+#    [1, 10000] loss: 1.507
+#    [1, 12000] loss: 1.442
+#    [2,  2000] loss: 1.378
+#    [2,  4000] loss: 1.364
+#    [2,  6000] loss: 1.349
+#    [2,  8000] loss: 1.319
+#    [2, 10000] loss: 1.284
+#    [2, 12000] loss: 1.267
+#    Finished Training
+# 
+# Note that the loss is monotonically descending, indicating that our
+# model is continuing to improve its performance on the training dataset.
+# 
+# As a final step, we should check that the model is actually doing
+# *general* learning, and not simply “memorizing” the dataset. This is
+# called **overfitting,** and usually indicates that the dataset is too
+# small (not enough examples for general learning), or that the model has
+# more learning parameters than it needs to correctly model the dataset.
+# 
+# This is the reason datasets are split into training and test subsets -
+# to test the generality of the model, we ask it to make predictions on
+# data it hasn’t trained on:
+# 
+
+correct = 0
+total = 0
+with torch.no_grad():
+    for data in testloader:
+        images, labels = data
+        outputs = net(images)
+        _, predicted = torch.max(outputs.data, 1)
+        total += labels.size(0)
+        correct += (predicted == labels).sum().item()
+
+print('Accuracy of the network on the 10000 test images: %d %%' % (
+    100 * correct / total))
+
+
+#########################################################################
+# If you followed along, you should see that the model is roughly 50%
+# accurate at this point. That’s not exactly state-of-the-art, but it’s
+# far better than the 10% accuracy we’d expect from a random output. This
+# demonstrates that some general learning did happen in the model.
+# 
diff --git a/beginner_source/introyt/introyt_index.py b/beginner_source/introyt/introyt_index.py
new file mode 100644
index 00000000000..9ef60574dd9
--- /dev/null
+++ b/beginner_source/introyt/introyt_index.py
@@ -0,0 +1,38 @@
+"""
+`Introduction <introyt1_tutorial.html>`_ ||
+`Tensors <tensors_deeper_tutorial.html>`_ ||
+`Autograd <autogradyt_tutorial.html>`_ ||
+`Building Models <modelsyt_tutorial.html>`_ ||
+`TensorBoard Support <tensorboardyt_tutorial.html>`_ ||
+`Training Models <trainingyt.html>`_ ||
+`Model Understanding <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/introyt/modelsyt_tutorial.py b/beginner_source/introyt/modelsyt_tutorial.py
new file mode 100644
index 00000000000..61c27d5c543
--- /dev/null
+++ b/beginner_source/introyt/modelsyt_tutorial.py
@@ -0,0 +1,420 @@
+"""
+`Introduction <introyt1_tutorial.html>`_ ||
+`Tensors <tensors_deeper_tutorial.html>`_ ||
+`Autograd <autogradyt_tutorial.html>`_ ||
+**Building Models** ||
+`TensorBoard Support <tensorboardyt_tutorial.html>`_ ||
+`Training Models <trainingyt.html>`_ ||
+`Model Understanding <captumyt.html>`_
+
+Building Models with PyTorch
+============================
+
+Follow along with the video below or on `youtube <https://www.youtube.com/watch?v=OSqIP-mOWOI>`__.
+
+.. raw:: html
+
+   <div style="margin-top:10px; margin-bottom:10px;">
+     <iframe width="560" height="315" src="https://www.youtube.com/embed/OSqIP-mOWOI" frameborder="0" allow="accelerometer; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
+   </div>
+
+``torch.nn.Module`` and ``torch.nn.Parameter``
+----------------------------------------------
+
+In this video, we’ll be discussing some of the tools PyTorch makes
+available for building deep learning networks.
+
+Except for ``Parameter``, the classes we discuss in this video are all
+subclasses of ``torch.nn.Module``. This is the PyTorch base class meant
+to encapsulate behaviors specific to PyTorch Models and their
+components.
+
+One important behavior of ``torch.nn.Module`` is registering parameters.
+If a particular ``Module`` subclass has learning weights, these weights
+are expressed as instances of ``torch.nn.Parameter``. The ``Parameter``
+class is a subclass of ``torch.Tensor``, with the special behavior that
+when they are assigned as attributes of a ``Module``, they are added to
+the list of that modules parameters. These parameters may be accessed
+through the ``parameters()`` method on the ``Module`` class.
+
+As a simple example, here’s a very simple model with two linear layers
+and an activation function. We’ll create an instance of it and ask it to
+report on its parameters:
+
+"""
+
+import torch
+
+class TinyModel(torch.nn.Module):
+    
+    def __init__(self):
+        super(TinyModel, self).__init__()
+        
+        self.linear1 = torch.nn.Linear(100, 200)
+        self.activation = torch.nn.ReLU()
+        self.linear2 = torch.nn.Linear(200, 10)
+        self.softmax = torch.nn.Softmax()
+    
+    def forward(self, x):
+        x = self.linear1(x)
+        x = self.activation(x)
+        x = self.linear2(x)
+        x = self.softmax(x)
+        return x
+
+tinymodel = TinyModel()
+
+print('The model:')
+print(tinymodel)
+
+print('\n\nJust one layer:')
+print(tinymodel.linear2)
+
+print('\n\nModel params:')
+for param in tinymodel.parameters():
+    print(param)
+
+print('\n\nLayer params:')
+for param in tinymodel.linear2.parameters():
+    print(param)
+
+
+#########################################################################
+# This shows the fundamental structure of a PyTorch model: there is an
+# ``__init__()`` method that defines the layers and other components of a
+# model, and a ``forward()`` method where the computation gets done. Note
+# that we can print the model, or any of its submodules, to learn about
+# its structure.
+# 
+# Common Layer Types
+# ------------------
+# 
+# Linear Layers
+# ~~~~~~~~~~~~~
+# 
+# The most basic type of neural network layer is a *linear* or *fully
+# connected* layer. This is a layer where every input influences every
+# output of the layer to a degree specified by the layer’s weights. If a
+# model has *m* inputs and *n* outputs, the weights will be an *m* x *n*
+# matrix. For example:
+# 
+
+lin = torch.nn.Linear(3, 2)
+x = torch.rand(1, 3)
+print('Input:')
+print(x)
+
+print('\n\nWeight and Bias parameters:')
+for param in lin.parameters():
+    print(param)
+
+y = lin(x)
+print('\n\nOutput:')
+print(y)
+
+
+#########################################################################
+# If you do the matrix multiplication of ``x`` by the linear layer’s
+# weights, and add the biases, you’ll find that you get the output vector
+# ``y``.
+# 
+# One other important feature to note: When we checked the weights of our
+# layer with ``lin.weight``, it reported itself as a ``Parameter`` (which
+# is a subclass of ``Tensor``), and let us know that it’s tracking
+# gradients with autograd. This is a default behavior for ``Parameter``
+# that differs from ``Tensor``.
+# 
+# Linear layers are used widely in deep learning models. One of the most
+# common places you’ll see them is in classifier models, which will
+# usually have one or more linear layers at the end, where the last layer
+# will have *n* outputs, where *n* is the number of classes the classifier
+# addresses.
+# 
+# Convolutional Layers
+# ~~~~~~~~~~~~~~~~~~~~
+# 
+# *Convolutional* layers are built to handle data with a high degree of
+# spatial correlation. They are very commonly used in computer vision,
+# where they detect close groupings of features which the compose into
+# higher-level features. They pop up in other contexts too - for example,
+# in NLP applications, where a word’s immediate context (that is, the
+# other words nearby in the sequence) can affect the meaning of a
+# sentence.
+# 
+# We saw convolutional layers in action in LeNet5 in an earlier video:
+# 
+
+import torch.functional as F
+
+
+class LeNet(torch.nn.Module):
+
+    def __init__(self):
+        super(LeNet, self).__init__()
+        # 1 input image channel (black & white), 6 output channels, 5x5 square convolution
+        # kernel
+        self.conv1 = torch.nn.Conv2d(1, 6, 5)
+        self.conv2 = torch.nn.Conv2d(6, 16, 3)
+        # an affine operation: y = Wx + b
+        self.fc1 = torch.nn.Linear(16 * 6 * 6, 120)  # 6*6 from image dimension
+        self.fc2 = torch.nn.Linear(120, 84)
+        self.fc3 = torch.nn.Linear(84, 10)
+
+    def forward(self, x):
+        # Max pooling over a (2, 2) window
+        x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
+        # If the size is a square you can only specify a single number
+        x = F.max_pool2d(F.relu(self.conv2(x)), 2)
+        x = x.view(-1, self.num_flat_features(x))
+        x = F.relu(self.fc1(x))
+        x = F.relu(self.fc2(x))
+        x = self.fc3(x)
+        return x
+
+    def num_flat_features(self, x):
+        size = x.size()[1:]  # all dimensions except the batch dimension
+        num_features = 1
+        for s in size:
+            num_features *= s
+        return num_features
+
+
+##########################################################################
+# Let’s break down what’s happening in the convolutional layers of this
+# model. Starting with ``conv1``:
+# 
+# -  LeNet5 is meant to take in a 1x32x32 black & white image. **The first
+#    argument to a convolutional layer’s constructor is the number of
+#    input channels.** Here, it is 1. If we were building this model to
+#    look at 3-color channels, it would be 3.
+# -  A convolutional layer is like a window that scans over the image,
+#    looking for a pattern it recognizes. These patterns are called
+#    *features,* and one of the parameters of a convolutional layer is the
+#    number of features we would like it to learn. **This is the second
+#    argument to the constructor is the number of output features.** Here,
+#    we’re asking our layer to learn 6 features.
+# -  Just above, I likened the convolutional layer to a window - but how
+#    big is the window? **The third argument is the window or kernel
+#    size.** Here, the “5” means we’ve chosen a 5x5 kernel. (If you want a
+#    kernel with height different from width, you can specify a tuple for
+#    this argument - e.g., ``(3, 5)`` to get a 3x5 convolution kernel.)
+# 
+# The output of a convolutional layer is an *activation map* - a spatial
+# representation of the presence of features in the input tensor.
+# ``conv1`` will give us an output tensor of 6x28x28; 6 is the number of
+# features, and 28 is the height and width of our map. (The 28 comes from
+# the fact that when scanning a 5-pixel window over a 32-pixel row, there
+# are only 28 valid positions.)
+# 
+# We then pass the output of the convolution through a ReLU activation
+# function (more on activation functions later), then through a max
+# pooling layer. The max pooling layer takes features near each other in
+# the activation map and groups them together. It does this by reducing
+# the tensor, merging every 2x2 group of cells in the output into a single
+# cell, and assigning that cell the maximum value of the 4 cells that went
+# into it. This gives us a lower-resolution version of the activation map,
+# with dimensions 6x14x14.
+# 
+# Our next convolutional layer, ``conv2``, expects 6 input channels
+# (corresponding to the 6 features sought by the first layer), has 16
+# output channels, and a 3x3 kernel. It puts out a 16x12x12 activation
+# map, which is again reduced by a max pooling layer to 16x6x6. Prior to
+# passing this output to the linear layers, it is reshaped to a 16 \* 6 \*
+# 6 = 576-element vector for consumption by the next layer.
+# 
+# There are convolutional layers for addressing 1D, 2D, and 3D tensors.
+# There are also many more optional arguments for a conv layer
+# constructor, including stride length(e.g., only scanning every second or
+# every third position) in the input, padding (so you can scan out to the
+# edges of the input), and more. See the
+# `documentation <https://pytorch.org/docs/stable/nn.html#convolution-layers>`__
+# for more information.
+# 
+# Recurrent Layers
+# ~~~~~~~~~~~~~~~~
+# 
+# *Recurrent neural networks* (or *RNNs)* are used for sequential data -
+# anything from time-series measurements from a scientific instrument to
+# natural language sentences to DNA nucleotides. An RNN does this by
+# maintaining a *hidden state* that acts as a sort of memory for what it
+# has seen in the sequence so far.
+# 
+# The internal structure of an RNN layer - or its variants, the LSTM (long
+# short-term memory) and GRU (gated recurrent unit) - is moderately
+# complex and beyond the scope of this video, but we’ll show you what one
+# looks like in action with an LSTM-based part-of-speech tagger (a type of
+# classifier that tells you if a word is a noun, verb, etc.):
+# 
+
+class LSTMTagger(torch.nn.Module):
+
+    def __init__(self, embedding_dim, hidden_dim, vocab_size, tagset_size):
+        super(LSTMTagger, self).__init__()
+        self.hidden_dim = hidden_dim
+
+        self.word_embeddings = torch.nn.Embedding(vocab_size, embedding_dim)
+
+        # The LSTM takes word embeddings as inputs, and outputs hidden states
+        # with dimensionality hidden_dim.
+        self.lstm = torch.nn.LSTM(embedding_dim, hidden_dim)
+
+        # The linear layer that maps from hidden state space to tag space
+        self.hidden2tag = torch.nn.Linear(hidden_dim, tagset_size)
+
+    def forward(self, sentence):
+        embeds = self.word_embeddings(sentence)
+        lstm_out, _ = self.lstm(embeds.view(len(sentence), 1, -1))
+        tag_space = self.hidden2tag(lstm_out.view(len(sentence), -1))
+        tag_scores = F.log_softmax(tag_space, dim=1)
+        return tag_scores
+
+
+########################################################################
+# The constructor has four arguments:
+# 
+# -  ``vocab_size`` is the number of words in the input vocabulary. Each
+#    word is a one-hot vector (or unit vector) in a
+#    ``vocab_size``-dimensional space.
+# -  ``tagset_size`` is the number of tags in the output set.
+# -  ``embedding_dim`` is the size of the *embedding* space for the
+#    vocabulary. An embedding maps a vocabulary onto a low-dimensional
+#    space, where words with similar meanings are close together in the
+#    space.
+# -  ``hidden_dim`` is the size of the LSTM’s memory.
+# 
+# The input will be a sentence with the words represented as indices of
+# one-hot vectors. The embedding layer will then map these down to an
+# ``embedding_dim``-dimensional space. The LSTM takes this sequence of
+# embeddings and iterates over it, fielding an output vector of length
+# ``hidden_dim``. The final linear layer acts as a classifier; applying
+# ``log_softmax()`` to the output of the final layer converts the output
+# into a normalized set of estimated probabilities that a given word maps
+# to a given tag.
+# 
+# If you’d like to see this network in action, check out the `Sequence
+# Models and LSTM
+# Networks <https://pytorch.org/tutorials/beginner/nlp/sequence_models_tutorial.html>`__
+# tutorial on pytorch.org.
+# 
+# Transformers
+# ~~~~~~~~~~~~
+# 
+# *Transformers* are multi-purpose networks that have taken over the state
+# of the art in NLP with models like BERT. A discussion of transformer
+# architecture is beyond the scope of this video, but PyTorch has a
+# ``Transformer`` class that allows you to define the overall parameters
+# of a transformer model - the number of attention heads, the number of
+# encoder & decoder layers, dropout and activation functions, etc. (You
+# can even build the BERT model from this single class, with the right
+# parameters!) The ``torch.nn.Transformer`` class also has classes to
+# encapsulate the individual components (``TransformerEncoder``,
+# ``TransformerDecoder``) and subcomponents (``TransformerEncoderLayer``,
+# ``TransformerDecoderLayer``). For details, check out the
+# `documentation <https://pytorch.org/docs/stable/nn.html#transformer-layers>`__
+# on transformer classes.
+# 
+# Other Layers and Functions
+# --------------------------
+# 
+# Data Manipulation Layers
+# ~~~~~~~~~~~~~~~~~~~~~~~~
+# 
+# There are other layer types that perform important functions in models,
+# but don’t participate in the learning process themselves.
+# 
+# **Max pooling** (and its twin, min pooling) reduce a tensor by combining
+# cells, and assigning the maximum value of the input cells to the output
+# cell (we saw this). For example:
+# 
+
+my_tensor = torch.rand(1, 6, 6)
+print(my_tensor)
+
+maxpool_layer = torch.nn.MaxPool2d(3)
+print(maxpool_layer(my_tensor))
+
+
+#########################################################################
+# If you look closely at the values above, you’ll see that each of the
+# values in the maxpooled output is the maximum value of each quadrant of
+# the 6x6 input.
+# 
+# **Normalization layers** re-center and normalize the output of one layer
+# before feeding it to another. Centering and scaling the intermediate
+# tensors has a number of beneficial effects, such as letting you use
+# higher learning rates without exploding/vanishing gradients.
+# 
+
+my_tensor = torch.rand(1, 4, 4) * 20 + 5
+print(my_tensor)
+
+print(my_tensor.mean())
+
+norm_layer = torch.nn.BatchNorm1d(4)
+normed_tensor = norm_layer(my_tensor)
+print(normed_tensor)
+
+print(normed_tensor.mean())
+
+
+
+##########################################################################
+# Running the cell above, we’ve added a large scaling factor and offset to
+# an input tensor; you should see the input tensor’s ``mean()`` somewhere
+# in the neighborhood of 15. After running it through the normalization
+# layer, you can see that the values are smaller, and grouped around zero
+# - in fact, the mean should be very small (> 1e-8).
+# 
+# This is beneficial because many activation functions (discussed below)
+# have their strongest gradients near 0, but sometimes suffer from
+# vanishing or exploding gradients for inputs that drive them far away
+# from zero. Keeping the data centered around the area of steepest
+# gradient will tend to mean faster, better learning and higher feasible
+# learning rates.
+# 
+# **Dropout layers** are a tool for encouraging *sparse representations*
+# in your model - that is, pushing it to do inference with less data.
+# 
+# Dropout layers work by randomly setting parts of the input tensor
+# *during training* - dropout layers are always turned off for inference.
+# This forces the model to learn against this masked or reduced dataset.
+# For example:
+# 
+
+my_tensor = torch.rand(1, 4, 4)
+
+dropout = torch.nn.Dropout(p=0.4)
+print(dropout(my_tensor))
+print(dropout(my_tensor))
+
+
+##########################################################################
+# Above, you can see the effect of dropout on a sample tensor. You can use
+# the optional ``p`` argument to set the probability of an individual
+# weight dropping out; if you don’t it defaults to 0.5.
+# 
+# Activation Functions
+# ~~~~~~~~~~~~~~~~~~~~
+# 
+# Activation functions make deep learning possible. A neural network is
+# really a program - with many parameters - that *simulates a mathematical
+# function*. If all we did was multiple tensors by layer weights
+# repeatedly, we could only simulate *linear functions;* further, there
+# would be no point to having many layers, as the whole network would
+# reduce could be reduced to a single matrix multiplication. Inserting
+# *non-linear* activation functions between layers is what allows a deep
+# learning model to simulate any function, rather than just linear ones.
+# 
+# ``torch.nn.Module`` has objects encapsulating all of the major
+# activation functions including ReLU and its many variants, Tanh,
+# Hardtanh, sigmoid, and more. It also includes other functions, such as
+# Softmax, that are most useful at the output stage of a model.
+# 
+# Loss Functions
+# ~~~~~~~~~~~~~~
+# 
+# Loss functions tell us how far a model’s prediction is from the correct
+# answer. PyTorch contains a variety of loss functions, including common
+# MSE (mean squared error = L2 norm), Cross Entropy Loss and Negative
+# Likelihood Loss (useful for classifiers), and others.
+# 
diff --git a/beginner_source/introyt/tensorboardyt_tutorial.py b/beginner_source/introyt/tensorboardyt_tutorial.py
new file mode 100644
index 00000000000..49d321bd6df
--- /dev/null
+++ b/beginner_source/introyt/tensorboardyt_tutorial.py
@@ -0,0 +1,327 @@
+"""
+`Introduction <introyt1_tutorial.html>`_ ||
+`Tensors <tensors_deeper_tutorial.html>`_ ||
+`Autograd <autogradyt_tutorial.html>`_ ||
+`Building Models <modelsyt_tutorial.html>`_ ||
+**TensorBoard Support** ||
+`Training Models <trainingyt.html>`_ ||
+`Model Understanding <captumyt.html>`_
+
+PyTorch TensorBoard Support
+===========================
+
+Follow along with the video below or on `youtube <https://www.youtube.com/watch?v=6CEld3hZgqc>`__.
+
+.. raw:: html
+
+   <div style="margin-top:10px; margin-bottom:10px;">
+     <iframe width="560" height="315" src="https://www.youtube.com/embed/6CEld3hZgqc" frameborder="0" allow="accelerometer; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
+   </div>
+
+Before You Start
+----------------
+
+To run this tutorial, you’ll need to install PyTorch, TorchVision,
+Matplotlib, and TensorBoard.
+
+With ``conda``:
+
+.. code-block:: sh
+
+    conda install pytorch torchvision -c pytorch
+    conda install matplotlib tensorboard
+
+With ``pip``:
+
+.. code-block:: sh
+
+    pip install torch torchvision matplotlib tensorboard
+
+Once the dependencies are installed, restart this notebook in the Python
+environment where you installed them.
+
+
+Introduction
+------------
+ 
+In this notebook, we’ll be training a variant of LeNet-5 against the
+Fashion-MNIST dataset. Fashion-MNIST is a set of image tiles depicting
+various garments, with ten class labels indicating the type of garment
+depicted. 
+
+"""
+
+# PyTorch model and training necessities
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.optim as optim
+
+# Image datasets and image manipulation
+import torchvision
+import torchvision.transforms as transforms
+
+# Image display
+import matplotlib.pyplot as plt
+import numpy as np
+
+# PyTorch TensorBoard support
+from torch.utils.tensorboard import SummaryWriter
+
+# In case you are using an environment that has TensorFlow installed,
+# such as Google Colab, uncomment the following code to avoid
+# a bug with saving embeddings to your TensorBoard directory
+
+# import tensorflow as tf
+# import tensorboard as tb
+# tf.io.gfile = tb.compat.tensorflow_stub.io.gfile
+
+######################################################################
+# Showing Images in TensorBoard
+# -----------------------------
+# 
+# Let’s start by adding sample images from our dataset to TensorBoard:
+# 
+
+# Gather datasets and prepare them for consumption
+transform = transforms.Compose(
+    [transforms.ToTensor(),
+    transforms.Normalize((0.5,), (0.5,))])
+
+# Store separate training and validations splits in ./data
+training_set = torchvision.datasets.FashionMNIST('./data',
+    download=True,
+    train=True,
+    transform=transform)
+validation_set = torchvision.datasets.FashionMNIST('./data',
+    download=True,
+    train=False,
+    transform=transform)
+
+training_loader = torch.utils.data.DataLoader(training_set,
+                                              batch_size=4,
+                                              shuffle=True,
+                                              num_workers=2)
+
+
+validation_loader = torch.utils.data.DataLoader(validation_set,
+                                                batch_size=4,
+                                                shuffle=False,
+                                                num_workers=2)
+
+# Class labels
+classes = ('T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat',
+        'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle Boot')
+
+# Helper function for inline image display
+def matplotlib_imshow(img, one_channel=False):
+    if one_channel:
+        img = img.mean(dim=0)
+    img = img / 2 + 0.5     # unnormalize
+    npimg = img.numpy()
+    if one_channel:
+        plt.imshow(npimg, cmap="Greys")
+    else:
+        plt.imshow(np.transpose(npimg, (1, 2, 0)))
+
+# Extract a batch of 4 images
+dataiter = iter(training_loader)
+images, labels = next(dataiter)
+
+# Create a grid from the images and show them
+img_grid = torchvision.utils.make_grid(images)
+matplotlib_imshow(img_grid, one_channel=True)
+
+
+########################################################################
+# Above, we used TorchVision and Matplotlib to create a visual grid of a
+# minibatch of our input data. Below, we use the ``add_image()`` call on
+# ``SummaryWriter`` to log the image for consumption by TensorBoard, and
+# we also call ``flush()`` to make sure it’s written to disk right away.
+# 
+
+# Default log_dir argument is "runs" - but it's good to be specific
+# torch.utils.tensorboard.SummaryWriter is imported above
+writer = SummaryWriter('runs/fashion_mnist_experiment_1')
+
+# Write image data to TensorBoard log dir
+writer.add_image('Four Fashion-MNIST Images', img_grid)
+writer.flush()
+
+# To view, start TensorBoard on the command line with:
+#   tensorboard --logdir=runs
+# ...and open a browser tab to http://localhost:6006/
+
+
+##########################################################################
+# If you start TensorBoard at the command line and open it in a new
+# browser tab (usually at `localhost:6006 <localhost:6006>`__), you should
+# see the image grid under the IMAGES tab.
+# 
+# Graphing Scalars to Visualize Training
+# --------------------------------------
+# 
+# TensorBoard is useful for tracking the progress and efficacy of your
+# training. Below, we’ll run a training loop, track some metrics, and save
+# the data for TensorBoard’s consumption.
+# 
+# Let’s define a model to categorize our image tiles, and an optimizer and
+# loss function for training:
+# 
+
+class Net(nn.Module):
+    def __init__(self):
+        super(Net, self).__init__()
+        self.conv1 = nn.Conv2d(1, 6, 5)
+        self.pool = nn.MaxPool2d(2, 2)
+        self.conv2 = nn.Conv2d(6, 16, 5)
+        self.fc1 = nn.Linear(16 * 4 * 4, 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 * 4 * 4)
+        x = F.relu(self.fc1(x))
+        x = F.relu(self.fc2(x))
+        x = self.fc3(x)
+        return x
+    
+
+net = Net()
+criterion = nn.CrossEntropyLoss()
+optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
+
+
+##########################################################################
+# Now let’s train a single epoch, and evaluate the training vs. validation
+# set losses every 1000 batches:
+# 
+
+print(len(validation_loader))
+for epoch in range(1):  # loop over the dataset multiple times
+    running_loss = 0.0
+
+    for i, data in enumerate(training_loader, 0):
+        # basic training loop
+        inputs, labels = data
+        optimizer.zero_grad()
+        outputs = net(inputs)
+        loss = criterion(outputs, labels)
+        loss.backward()
+        optimizer.step()
+
+        running_loss += loss.item()
+        if i % 1000 == 999:    # Every 1000 mini-batches...
+            print('Batch {}'.format(i + 1))
+            # Check against the validation set
+            running_vloss = 0.0
+            
+            # In evaluation mode some model specific operations can be omitted eg. dropout layer
+            net.train(False) # Switching to evaluation mode, eg. turning off regularisation
+            for j, vdata in enumerate(validation_loader, 0):
+                vinputs, vlabels = vdata
+                voutputs = net(vinputs)
+                vloss = criterion(voutputs, vlabels)
+                running_vloss += vloss.item()
+            net.train(True) # Switching back to training mode, eg. turning on regularisation
+            
+            avg_loss = running_loss / 1000
+            avg_vloss = running_vloss / len(validation_loader)
+            
+            # Log the running loss averaged per batch
+            writer.add_scalars('Training vs. Validation Loss',
+                            { 'Training' : avg_loss, 'Validation' : avg_vloss },
+                            epoch * len(training_loader) + i)
+
+            running_loss = 0.0
+print('Finished Training')
+
+writer.flush()
+
+
+#########################################################################
+# Switch to your open TensorBoard and have a look at the SCALARS tab.
+# 
+# Visualizing Your Model
+# ----------------------
+# 
+# TensorBoard can also be used to examine the data flow within your model.
+# To do this, call the ``add_graph()`` method with a model and sample
+# input:
+# 
+
+# Again, grab a single mini-batch of images
+dataiter = iter(training_loader)
+images, labels = next(dataiter)
+
+# add_graph() will trace the sample input through your model,
+# and render it as a graph.
+writer.add_graph(net, images)
+writer.flush()
+
+
+#########################################################################
+# When you switch over to TensorBoard, you should see a GRAPHS tab.
+# Double-click the “NET” node to see the layers and data flow within your
+# model.
+# 
+# Visualizing Your Dataset with Embeddings
+# ----------------------------------------
+# 
+# The 28-by-28 image tiles we’re using can be modeled as 784-dimensional
+# vectors (28 \* 28 = 784). It can be instructive to project this to a
+# lower-dimensional representation. The ``add_embedding()`` method will
+# project a set of data onto the three dimensions with highest variance,
+# and display them as an interactive 3D chart. The ``add_embedding()``
+# method does this automatically by projecting to the three dimensions
+# with highest variance.
+# 
+# Below, we’ll take a sample of our data, and generate such an embedding:
+# 
+
+# Select a random subset of data and corresponding labels
+def select_n_random(data, labels, n=100):
+    assert len(data) == len(labels)
+
+    perm = torch.randperm(len(data))
+    return data[perm][:n], labels[perm][:n]
+
+# Extract a random subset of data
+images, labels = select_n_random(training_set.data, training_set.targets)
+
+# get the class labels for each image
+class_labels = [classes[label] for label in labels]
+
+# log embeddings
+features = images.view(-1, 28 * 28)
+writer.add_embedding(features,
+                    metadata=class_labels,
+                    label_img=images.unsqueeze(1))
+writer.flush()
+writer.close()
+
+
+#######################################################################
+# Now if you switch to TensorBoard and select the PROJECTOR tab, you
+# should see a 3D representation of the projection. You can rotate and
+# zoom the model. Examine it at large and small scales, and see whether
+# you can spot patterns in the projected data and the clustering of
+# labels.
+# 
+# For better visibility, it’s recommended to:
+# 
+# - Select “label” from the “Color by” drop-down on the left.
+# - Toggle the Night Mode icon along the top to place the
+#   light-colored images on a dark background.
+# 
+# Other Resources
+# ---------------
+# 
+# For more information, have a look at:
+# 
+# - PyTorch documentation on `torch.utils.tensorboard.SummaryWriter <https://pytorch.org/docs/stable/tensorboard.html?highlight=summarywriter>`__
+# - Tensorboard tutorial content in the `PyTorch.org Tutorials <https://pytorch.org/tutorials/>`__ 
+# - For more information about TensorBoard, see the `TensorBoard
+#   documentation <https://www.tensorflow.org/tensorboard>`__
diff --git a/beginner_source/introyt/tensors_deeper_tutorial.py b/beginner_source/introyt/tensors_deeper_tutorial.py
new file mode 100644
index 00000000000..4d118ad4030
--- /dev/null
+++ b/beginner_source/introyt/tensors_deeper_tutorial.py
@@ -0,0 +1,938 @@
+"""
+`Introduction <introyt1_tutorial.html>`_ ||
+**Tensors** ||
+`Autograd <autogradyt_tutorial.html>`_ ||
+`Building Models <modelsyt_tutorial.html>`_ ||
+`TensorBoard Support <tensorboardyt_tutorial.html>`_ ||
+`Training Models <trainingyt.html>`_ ||
+`Model Understanding <captumyt.html>`_
+
+Introduction to PyTorch Tensors
+===============================
+
+Follow along with the video below or on `youtube <https://www.youtube.com/watch?v=r7QDUPb2dCM>`__.
+
+.. raw:: html
+
+   <div style="margin-top:10px; margin-bottom:10px;">
+     <iframe width="560" height="315" src="https://www.youtube.com/embed/r7QDUPb2dCM" frameborder="0" allow="accelerometer; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
+   </div>
+
+Tensors are the central data abstraction in PyTorch. This interactive
+notebook provides an in-depth introduction to the ``torch.Tensor``
+class.
+
+First things first, let’s import the PyTorch module. We’ll also add
+Python’s math module to facilitate some of the examples.
+
+"""
+
+import torch
+import math
+
+
+#########################################################################
+# Creating Tensors
+# ----------------
+# 
+# The simplest way to create a tensor is with the ``torch.empty()`` call:
+# 
+
+x = torch.empty(3, 4)
+print(type(x))
+print(x)
+
+
+##########################################################################
+# Let’s upack what we just did:
+# 
+# -  We created a tensor using one of the numerous factory methods
+#    attached to the ``torch`` module.
+# -  The tensor itself is 2-dimensional, having 3 rows and 4 columns.
+# -  The type of the object returned is ``torch.Tensor``, which is an
+#    alias for ``torch.FloatTensor``; by default, PyTorch tensors are
+#    populated with 32-bit floating point numbers. (More on data types
+#    below.)
+# -  You will probably see some random-looking values when printing your
+#    tensor. The ``torch.empty()`` call allocates memory for the tensor,
+#    but does not initialize it with any values - so what you’re seeing is
+#    whatever was in memory at the time of allocation.
+# 
+# A brief note about tensors and their number of dimensions, and
+# terminology:
+# 
+# -  You will sometimes see a 1-dimensional tensor called a
+#    *vector.* 
+# -  Likewise, a 2-dimensional tensor is often referred to as a
+#    *matrix.* 
+# -  Anything with more than two dimensions is generally just
+#    called a tensor.
+# 
+# More often than not, you’ll want to initialize your tensor with some
+# value. Common cases are all zeros, all ones, or random values, and the
+# ``torch`` module provides factory methods for all of these:
+# 
+
+zeros = torch.zeros(2, 3)
+print(zeros)
+
+ones = torch.ones(2, 3)
+print(ones)
+
+torch.manual_seed(1729)
+random = torch.rand(2, 3)
+print(random)
+
+
+#########################################################################
+# The factory methods all do just what you’d expect - we have a tensor
+# full of zeros, another full of ones, and another with random values
+# between 0 and 1.
+# 
+# Random Tensors and Seeding
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~
+# 
+# Speaking of the random tensor, did you notice the call to
+# ``torch.manual_seed()`` immediately preceding it? Initializing tensors,
+# such as a model’s learning weights, with random values is common but
+# there are times - especially in research settings - where you’ll want
+# some assurance of the reproducibility of your results. Manually setting
+# your random number generator’s seed is the way to do this. Let’s look
+# more closely:
+# 
+
+torch.manual_seed(1729)
+random1 = torch.rand(2, 3)
+print(random1)
+
+random2 = torch.rand(2, 3)
+print(random2)
+
+torch.manual_seed(1729)
+random3 = torch.rand(2, 3)
+print(random3)
+
+random4 = torch.rand(2, 3)
+print(random4)
+
+
+############################################################################
+# What you should see above is that ``random1`` and ``random3`` carry
+# identical values, as do ``random2`` and ``random4``. Manually setting
+# the RNG’s seed resets it, so that identical computations depending on
+# random number should, in most settings, provide identical results.
+# 
+# For more information, see the `PyTorch documentation on
+# reproducibility <https://pytorch.org/docs/stable/notes/randomness.html>`__.
+# 
+# Tensor Shapes
+# ~~~~~~~~~~~~~
+# 
+# Often, when you’re performing operations on two or more tensors, they
+# will need to be of the same *shape* - that is, having the same number of
+# dimensions and the same number of cells in each dimension. For that, we
+# have the ``torch.*_like()`` methods:
+# 
+
+x = torch.empty(2, 2, 3)
+print(x.shape)
+print(x)
+
+empty_like_x = torch.empty_like(x)
+print(empty_like_x.shape)
+print(empty_like_x)
+
+zeros_like_x = torch.zeros_like(x)
+print(zeros_like_x.shape)
+print(zeros_like_x)
+
+ones_like_x = torch.ones_like(x)
+print(ones_like_x.shape)
+print(ones_like_x)
+
+rand_like_x = torch.rand_like(x)
+print(rand_like_x.shape)
+print(rand_like_x)
+
+
+#########################################################################
+# The first new thing in the code cell above is the use of the ``.shape``
+# property on a tensor. This property contains a list of the extent of
+# each dimension of a tensor - in our case, ``x`` is a three-dimensional
+# tensor with shape 2 x 2 x 3.
+# 
+# Below that, we call the ``.empty_like()``, ``.zeros_like()``,
+# ``.ones_like()``, and ``.rand_like()`` methods. Using the ``.shape``
+# property, we can verify that each of these methods returns a tensor of
+# identical dimensionality and extent.
+# 
+# The last way to create a tensor that will cover is to specify its data
+# directly from a PyTorch collection:
+# 
+
+some_constants = torch.tensor([[3.1415926, 2.71828], [1.61803, 0.0072897]])
+print(some_constants)
+
+some_integers = torch.tensor((2, 3, 5, 7, 11, 13, 17, 19))
+print(some_integers)
+
+more_integers = torch.tensor(((2, 4, 6), [3, 6, 9]))
+print(more_integers)
+
+
+######################################################################
+# Using ``torch.tensor()`` is the most straightforward way to create a
+# tensor if you already have data in a Python tuple or list. As shown
+# above, nesting the collections will result in a multi-dimensional
+# tensor.
+# 
+# .. note::
+#      ``torch.tensor()`` creates a copy of the data.
+# 
+# Tensor Data Types
+# ~~~~~~~~~~~~~~~~~
+# 
+# Setting the datatype of a tensor is possible a couple of ways:
+# 
+
+a = torch.ones((2, 3), dtype=torch.int16)
+print(a)
+
+b = torch.rand((2, 3), dtype=torch.float64) * 20.
+print(b)
+
+c = b.to(torch.int32)
+print(c)
+
+
+##########################################################################
+# The simplest way to set the underlying data type of a tensor is with an
+# optional argument at creation time. In the first line of the cell above,
+# we set ``dtype=torch.int16`` for the tensor ``a``. When we print ``a``,
+# we can see that it’s full of ``1`` rather than ``1.`` - Python’s subtle
+# cue that this is an integer type rather than floating point.
+# 
+# Another thing to notice about printing ``a`` is that, unlike when we
+# left ``dtype`` as the default (32-bit floating point), printing the
+# tensor also specifies its ``dtype``.
+# 
+# You may have also spotted that we went from specifying the tensor’s
+# shape as a series of integer arguments, to grouping those arguments in a
+# tuple. This is not strictly necessary - PyTorch will take a series of
+# initial, unlabeled integer arguments as a tensor shape - but when adding
+# the optional arguments, it can make your intent more readable.
+# 
+# The other way to set the datatype is with the ``.to()`` method. In the
+# cell above, we create a random floating point tensor ``b`` in the usual
+# way. Following that, we create ``c`` by converting ``b`` to a 32-bit
+# integer with the ``.to()`` method. Note that ``c`` contains all the same
+# values as ``b``, but truncated to integers.
+# 
+# For more information, see the `data types documentation <https://pytorch.org/docs/stable/tensor_attributes.html#torch.dtype>`__.
+# 
+# Math & Logic with PyTorch Tensors
+# ---------------------------------
+# 
+# Now that you know some of the ways to create a tensor… what can you do
+# with them?
+# 
+# Let’s look at basic arithmetic first, and how tensors interact with
+# simple scalars:
+# 
+
+ones = torch.zeros(2, 2) + 1
+twos = torch.ones(2, 2) * 2
+threes = (torch.ones(2, 2) * 7 - 1) / 2
+fours = twos ** 2
+sqrt2s = twos ** 0.5
+
+print(ones)
+print(twos)
+print(threes)
+print(fours)
+print(sqrt2s)
+
+
+##########################################################################
+# As you can see above, arithmetic operations between tensors and scalars,
+# such as addition, subtraction, multiplication, division, and
+# exponentiation are distributed over every element of the tensor. Because
+# the output of such an operation will be a tensor, you can chain them
+# together with the usual operator precedence rules, as in the line where
+# we create ``threes``.
+# 
+# Similar operations between two tensors also behave like you’d
+# intuitively expect:
+# 
+
+powers2 = twos ** torch.tensor([[1, 2], [3, 4]])
+print(powers2)
+
+fives = ones + fours
+print(fives)
+
+dozens = threes * fours
+print(dozens)
+
+
+##########################################################################
+# It’s important to note here that all of the tensors in the previous code
+# cell were of identical shape. What happens when we try to perform a
+# binary operation on tensors if dissimilar shape?
+# 
+# .. note::
+#    The following cell throws a run-time error. This is intentional.
+#
+#    .. code-block:: sh
+#
+#       a = torch.rand(2, 3)
+#       b = torch.rand(3, 2)
+#
+#       print(a * b)
+#
+
+
+##########################################################################
+# In the general case, you cannot operate on tensors of different shape
+# this way, even in a case like the cell above, where the tensors have an
+# identical number of elements.
+# 
+# In Brief: Tensor Broadcasting
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# 
+# .. note::
+#      If you are familiar with broadcasting semantics in NumPy
+#      ndarrays, you’ll find the same rules apply here.
+# 
+# The exception to the same-shapes rule is *tensor broadcasting.* Here’s
+# an example:
+# 
+
+rand = torch.rand(2, 4)
+doubled = rand * (torch.ones(1, 4) * 2)
+
+print(rand)
+print(doubled)
+
+
+#########################################################################
+# What’s the trick here? How is it we got to multiply a 2x4 tensor by a
+# 1x4 tensor?
+# 
+# Broadcasting is a way to perform an operation between tensors that have
+# similarities in their shapes. In the example above, the one-row,
+# four-column tensor is multiplied by *both rows* of the two-row,
+# four-column tensor.
+# 
+# This is an important operation in Deep Learning. The common example is
+# multiplying a tensor of learning weights by a *batch* of input tensors,
+# applying the operation to each instance in the batch separately, and
+# returning a tensor of identical shape - just like our (2, 4) \* (1, 4)
+# example above returned a tensor of shape (2, 4).
+# 
+# The rules for broadcasting are:
+# 
+# -  Each tensor must have at least one dimension - no empty tensors.
+# 
+# -  Comparing the dimension sizes of the two tensors, *going from last to
+#    first:*
+# 
+#    -  Each dimension must be equal, *or*
+# 
+#    -  One of the dimensions must be of size 1, *or*
+# 
+#    -  The dimension does not exist in one of the tensors
+# 
+# Tensors of identical shape, of course, are trivially “broadcastable”, as
+# you saw earlier.
+# 
+# Here are some examples of situations that honor the above rules and
+# allow broadcasting:
+# 
+
+a =     torch.ones(4, 3, 2)
+
+b = a * torch.rand(   3, 2) # 3rd & 2nd dims identical to a, dim 1 absent
+print(b)
+
+c = a * torch.rand(   3, 1) # 3rd dim = 1, 2nd dim identical to a
+print(c)
+
+d = a * torch.rand(   1, 2) # 3rd dim identical to a, 2nd dim = 1
+print(d)
+
+
+#############################################################################
+# Look closely at the values of each tensor above: 
+#
+# -  The multiplication operation that created ``b`` was 
+#    broadcast over every “layer” of ``a``.
+# -  For ``c``, the operation was broadcast over every layer and row of
+#    ``a`` - every 3-element column is identical. 
+# -  For ``d``, we switched it around - now every *row* is identical,
+#    across layers and columns.
+# 
+# For more information on broadcasting, see the `PyTorch
+# documentation <https://pytorch.org/docs/stable/notes/broadcasting.html>`__
+# on the topic.
+# 
+# Here are some examples of attempts at broadcasting that will fail:
+# 
+# .. note::
+#    The following cell throws a run-time error. This is intentional.
+#
+#    .. code-block:: python
+#
+#       a =     torch.ones(4, 3, 2)
+#
+#       b = a * torch.rand(4, 3)    # dimensions must match last-to-first
+#
+#       c = a * torch.rand(   2, 3) # both 3rd & 2nd dims different
+#
+#       d = a * torch.rand((0, ))   # can't broadcast with an empty tensor
+#
+
+
+###########################################################################
+# More Math with Tensors
+# ~~~~~~~~~~~~~~~~~~~~~~
+# 
+# PyTorch tensors have over three hundred operations that can be performed
+# on them.
+# 
+# Here is a small sample from some of the major categories of operations:
+# 
+
+# common functions
+a = torch.rand(2, 4) * 2 - 1
+print('Common functions:')
+print(torch.abs(a))
+print(torch.ceil(a))
+print(torch.floor(a))
+print(torch.clamp(a, -0.5, 0.5))
+
+# trigonometric functions and their inverses
+angles = torch.tensor([0, math.pi / 4, math.pi / 2, 3 * math.pi / 4])
+sines = torch.sin(angles)
+inverses = torch.asin(sines)
+print('\nSine and arcsine:')
+print(angles)
+print(sines)
+print(inverses)
+
+# bitwise operations
+print('\nBitwise XOR:')
+b = torch.tensor([1, 5, 11])
+c = torch.tensor([2, 7, 10])
+print(torch.bitwise_xor(b, c))
+
+# comparisons:
+print('\nBroadcasted, element-wise equality comparison:')
+d = torch.tensor([[1., 2.], [3., 4.]])
+e = torch.ones(1, 2)  # many comparison ops support broadcasting!
+print(torch.eq(d, e)) # returns a tensor of type bool
+
+# reductions:
+print('\nReduction ops:')
+print(torch.max(d))        # returns a single-element tensor
+print(torch.max(d).item()) # extracts the value from the returned tensor
+print(torch.mean(d))       # average
+print(torch.std(d))        # standard deviation
+print(torch.prod(d))       # product of all numbers
+print(torch.unique(torch.tensor([1, 2, 1, 2, 1, 2]))) # filter unique elements
+
+# vector and linear algebra operations
+v1 = torch.tensor([1., 0., 0.])         # x unit vector
+v2 = torch.tensor([0., 1., 0.])         # y unit vector
+m1 = torch.rand(2, 2)                   # random matrix
+m2 = torch.tensor([[3., 0.], [0., 3.]]) # three times identity matrix
+
+print('\nVectors & Matrices:')
+print(torch.linalg.cross(v2, v1)) # negative of z unit vector (v1 x v2 == -v2 x v1)
+print(m1)
+m3 = torch.linalg.matmul(m1, m2)
+print(m3)                  # 3 times m1
+print(torch.linalg.svd(m3))       # singular value decomposition
+
+
+##################################################################################
+# This is a small sample of operations. For more details and the full inventory of
+# math functions, have a look at the
+# `documentation <https://pytorch.org/docs/stable/torch.html#math-operations>`__.
+# For more details and the full inventory of linear algebra operations, have a
+# look at this `documentation <https://pytorch.org/docs/stable/linalg.html>`__.
+# 
+# Altering Tensors in Place
+# ~~~~~~~~~~~~~~~~~~~~~~~~~
+# 
+# Most binary operations on tensors will return a third, new tensor. When
+# we say ``c = a * b`` (where ``a`` and ``b`` are tensors), the new tensor
+# ``c`` will occupy a region of memory distinct from the other tensors.
+# 
+# There are times, though, that you may wish to alter a tensor in place -
+# for example, if you’re doing an element-wise computation where you can
+# discard intermediate values. For this, most of the math functions have a
+# version with an appended underscore (``_``) that will alter a tensor in
+# place.
+# 
+# For example:
+# 
+
+a = torch.tensor([0, math.pi / 4, math.pi / 2, 3 * math.pi / 4])
+print('a:')
+print(a)
+print(torch.sin(a))   # this operation creates a new tensor in memory
+print(a)              # a has not changed
+
+b = torch.tensor([0, math.pi / 4, math.pi / 2, 3 * math.pi / 4])
+print('\nb:')
+print(b)
+print(torch.sin_(b))  # note the underscore
+print(b)              # b has changed
+
+
+#######################################################################
+# For arithmetic operations, there are functions that behave similarly:
+# 
+
+a = torch.ones(2, 2)
+b = torch.rand(2, 2)
+
+print('Before:')
+print(a)
+print(b)
+print('\nAfter adding:')
+print(a.add_(b))
+print(a)
+print(b)
+print('\nAfter multiplying')
+print(b.mul_(b))
+print(b)
+
+
+##########################################################################
+# Note that these in-place arithmetic functions are methods on the
+# ``torch.Tensor`` object, not attached to the ``torch`` module like many
+# other functions (e.g., ``torch.sin()``). As you can see from
+# ``a.add_(b)``, *the calling tensor is the one that gets changed in
+# place.*
+# 
+# There is another option for placing the result of a computation in an
+# existing, allocated tensor. Many of the methods and functions we’ve seen
+# so far - including creation methods! - have an ``out`` argument that
+# lets you specify a tensor to receive the output. If the ``out`` tensor
+# is the correct shape and ``dtype``, this can happen without a new memory
+# allocation:
+# 
+
+a = torch.rand(2, 2)
+b = torch.rand(2, 2)
+c = torch.zeros(2, 2)
+old_id = id(c)
+
+print(c)
+d = torch.matmul(a, b, out=c)
+print(c)                # contents of c have changed
+
+assert c is d           # test c & d are same object, not just containing equal values
+assert id(c) == old_id  # make sure that our new c is the same object as the old one
+
+torch.rand(2, 2, out=c) # works for creation too!
+print(c)                # c has changed again
+assert id(c) == old_id  # still the same object!
+
+
+##########################################################################
+# Copying Tensors
+# ---------------
+# 
+# As with any object in Python, assigning a tensor to a variable makes the
+# variable a *label* of the tensor, and does not copy it. For example:
+# 
+
+a = torch.ones(2, 2)
+b = a
+
+a[0][1] = 561  # we change a...
+print(b)       # ...and b is also altered
+
+
+######################################################################
+# But what if you want a separate copy of the data to work on? The
+# ``clone()`` method is there for you:
+# 
+
+a = torch.ones(2, 2)
+b = a.clone()
+
+assert b is not a      # different objects in memory...
+print(torch.eq(a, b))  # ...but still with the same contents!
+
+a[0][1] = 561          # a changes...
+print(b)               # ...but b is still all ones
+
+
+#########################################################################
+# **There is an important thing to be aware of when using ``clone()``.**
+# If your source tensor has autograd, enabled then so will the clone.
+# **This will be covered more deeply in the video on autograd,** but if
+# you want the light version of the details, continue on.
+# 
+# *In many cases, this will be what you want.* For example, if your model
+# has multiple computation paths in its ``forward()`` method, and *both*
+# the original tensor and its clone contribute to the model’s output, then
+# to enable model learning you want autograd turned on for both tensors.
+# If your source tensor has autograd enabled (which it generally will if
+# it’s a set of learning weights or derived from a computation involving
+# the weights), then you’ll get the result you want.
+# 
+# On the other hand, if you’re doing a computation where *neither* the
+# original tensor nor its clone need to track gradients, then as long as
+# the source tensor has autograd turned off, you’re good to go.
+# 
+# *There is a third case,* though: Imagine you’re performing a computation
+# in your model’s ``forward()`` function, where gradients are turned on
+# for everything by default, but you want to pull out some values
+# mid-stream to generate some metrics. In this case, you *don’t* want the
+# cloned copy of your source tensor to track gradients - performance is
+# improved with autograd’s history tracking turned off. For this, you can
+# use the ``.detach()`` method on the source tensor:
+# 
+
+a = torch.rand(2, 2, requires_grad=True) # turn on autograd
+print(a)
+
+b = a.clone()
+print(b)
+
+c = a.detach().clone()
+print(c)
+
+print(a)
+
+
+#########################################################################
+# What’s happening here?
+# 
+# -  We create ``a`` with ``requires_grad=True`` turned on. **We haven’t
+#    covered this optional argument yet, but will during the unit on
+#    autograd.**
+# -  When we print ``a``, it informs us that the property
+#    ``requires_grad=True`` - this means that autograd and computation
+#    history tracking are turned on.
+# -  We clone ``a`` and label it ``b``. When we print ``b``, we can see
+#    that it’s tracking its computation history - it has inherited
+#    ``a``\ ’s autograd settings, and added to the computation history.
+# -  We clone ``a`` into ``c``, but we call ``detach()`` first.
+# -  Printing ``c``, we see no computation history, and no
+#    ``requires_grad=True``.
+# 
+# The ``detach()`` method *detaches the tensor from its computation
+# history.* It says, “do whatever comes next as if autograd was off.” It
+# does this *without* changing ``a`` - you can see that when we print
+# ``a`` again at the end, it retains its ``requires_grad=True`` property.
+# 
+# Moving to `Accelerator <https://pytorch.org/docs/stable/torch.html#accelerators>`__
+# -------------
+# 
+# One of the major advantages of PyTorch is its robust acceleration on an
+# `accelerator <https://pytorch.org/docs/stable/torch.html#accelerators>`__
+# such as CUDA, MPS, MTIA, or XPU. 
+# So far, everything we’ve done has been on CPU. How do we move to the faster
+# hardware?
+# 
+# First, we should check whether an accelerator is available, with the
+# ``is_available()`` method.
+# 
+# .. note::
+#      If you do not have an accelerator, the executable cells in this section will not execute any
+#      accelerator-related code.
+# 
+
+if torch.accelerator.is_available():
+    print('We have an accelerator!')
+else:
+    print('Sorry, CPU only.')
+
+
+##########################################################################
+# Once we’ve determined that one or more accelerators is available, we need to put
+# our data someplace where the accelerator can see it. Your CPU does computation
+# on data in your computer’s RAM. Your accelerator has dedicated memory attached
+# to it. Whenever you want to perform a computation on a device, you must
+# move *all* the data needed for that computation to memory accessible by
+# that device. (Colloquially, “moving the data to memory accessible by the
+# GPU” is shorted to, “moving the data to the GPU”.)
+# 
+# There are multiple ways to get your data onto your target device. You
+# may do it at creation time:
+# 
+
+if torch.accelerator.is_available():
+    gpu_rand = torch.rand(2, 2, device=torch.accelerator.current_accelerator())
+    print(gpu_rand)
+else:
+    print('Sorry, CPU only.')
+
+
+##########################################################################
+# By default, new tensors are created on the CPU, so we have to specify
+# when we want to create our tensor on the accelerator with the optional
+# ``device`` argument. You can see when we print the new tensor, PyTorch
+# informs us which device it’s on (if it’s not on CPU).
+# 
+# You can query the number of accelerators with ``torch.accelerator.device_count()``. If
+# you have more than one accelerator, you can specify them by index, take CUDA for example:
+# ``device='cuda:0'``, ``device='cuda:1'``, etc.
+# 
+# As a coding practice, specifying our devices everywhere with string
+# constants is pretty fragile. In an ideal world, your code would perform
+# robustly whether you’re on CPU or accelerator hardware. You can do this by
+# creating a device handle that can be passed to your tensors instead of a
+# string:
+# 
+
+my_device = torch.accelerator.current_accelerator() if torch.accelerator.is_available() else torch.device('cpu')
+print('Device: {}'.format(my_device))
+
+x = torch.rand(2, 2, device=my_device)
+print(x)
+
+
+#########################################################################
+# If you have an existing tensor living on one device, you can move it to
+# another with the ``to()`` method. The following line of code creates a
+# tensor on CPU, and moves it to whichever device handle you acquired in
+# the previous cell.
+# 
+
+y = torch.rand(2, 2)
+y = y.to(my_device)
+
+
+##########################################################################
+# It is important to know that in order to do computation involving two or
+# more tensors, *all of the tensors must be on the same device*. The
+# following code will throw a runtime error, regardless of whether you
+# have an accelerator device available, take CUDA for example:
+# 
+# .. code-block:: python
+# 
+#    x = torch.rand(2, 2)
+#    y = torch.rand(2, 2, device='cuda')
+#    z = x + y  # exception will be thrown
+# 
+
+
+###########################################################################
+# Manipulating Tensor Shapes
+# --------------------------
+# 
+# Sometimes, you’ll need to change the shape of your tensor. Below, we’ll
+# look at a few common cases, and how to handle them.
+# 
+# Changing the Number of Dimensions
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# 
+# One case where you might need to change the number of dimensions is
+# passing a single instance of input to your model. PyTorch models
+# generally expect *batches* of input.
+# 
+# For example, imagine having a model that works on 3 x 226 x 226 images -
+# a 226-pixel square with 3 color channels. When you load and transform
+# it, you’ll get a tensor of shape ``(3, 226, 226)``. Your model, though,
+# is expecting input of shape ``(N, 3, 226, 226)``, where ``N`` is the
+# number of images in the batch. So how do you make a batch of one?
+# 
+
+a = torch.rand(3, 226, 226)
+b = a.unsqueeze(0)
+
+print(a.shape)
+print(b.shape)
+
+
+##########################################################################
+# The ``unsqueeze()`` method adds a dimension of extent 1.
+# ``unsqueeze(0)`` adds it as a new zeroth dimension - now you have a
+# batch of one!
+# 
+# So if that’s *un*\ squeezing? What do we mean by squeezing? We’re taking
+# advantage of the fact that any dimension of extent 1 *does not* change
+# the number of elements in the tensor.
+# 
+
+c = torch.rand(1, 1, 1, 1, 1)
+print(c)
+
+
+##########################################################################
+# Continuing the example above, let’s say the model’s output is a
+# 20-element vector for each input. You would then expect the output to
+# have shape ``(N, 20)``, where ``N`` is the number of instances in the
+# input batch. That means that for our single-input batch, we’ll get an
+# output of shape ``(1, 20)``.
+# 
+# What if you want to do some *non-batched* computation with that output -
+# something that’s just expecting a 20-element vector?
+# 
+
+a = torch.rand(1, 20)
+print(a.shape)
+print(a)
+
+b = a.squeeze(0)
+print(b.shape)
+print(b)
+
+c = torch.rand(2, 2)
+print(c.shape)
+
+d = c.squeeze(0)
+print(d.shape)
+
+
+#########################################################################
+# You can see from the shapes that our 2-dimensional tensor is now
+# 1-dimensional, and if you look closely at the output of the cell above
+# you’ll see that printing ``a`` shows an “extra” set of square brackets
+# ``[]`` due to having an extra dimension.
+# 
+# You may only ``squeeze()`` dimensions of extent 1. See above where we
+# try to squeeze a dimension of size 2 in ``c``, and get back the same
+# shape we started with. Calls to ``squeeze()`` and ``unsqueeze()`` can
+# only act on dimensions of extent 1 because to do otherwise would change
+# the number of elements in the tensor.
+# 
+# Another place you might use ``unsqueeze()`` is to ease broadcasting.
+# Recall the example above where we had the following code:
+# 
+# .. code-block:: python
+# 
+#    a = torch.ones(4, 3, 2)
+# 
+#    c = a * torch.rand(   3, 1) # 3rd dim = 1, 2nd dim identical to a
+#    print(c)
+# 
+# The net effect of that was to broadcast the operation over dimensions 0
+# and 2, causing the random, 3 x 1 tensor to be multiplied element-wise by
+# every 3-element column in ``a``.
+# 
+# What if the random vector had just been 3-element vector? We’d lose the
+# ability to do the broadcast, because the final dimensions would not
+# match up according to the broadcasting rules. ``unsqueeze()`` comes to
+# the rescue:
+# 
+
+a = torch.ones(4, 3, 2)
+b = torch.rand(   3)     # trying to multiply a * b will give a runtime error
+c = b.unsqueeze(1)       # change to a 2-dimensional tensor, adding new dim at the end
+print(c.shape)
+print(a * c)             # broadcasting works again!
+
+
+######################################################################
+# The ``squeeze()`` and ``unsqueeze()`` methods also have in-place
+# versions, ``squeeze_()`` and ``unsqueeze_()``:
+# 
+
+batch_me = torch.rand(3, 226, 226)
+print(batch_me.shape)
+batch_me.unsqueeze_(0)
+print(batch_me.shape)
+
+
+##########################################################################
+# Sometimes you’ll want to change the shape of a tensor more radically,
+# while still preserving the number of elements and their contents. One
+# case where this happens is at the interface between a convolutional
+# layer of a model and a linear layer of the model - this is common in
+# image classification models. A convolution kernel will yield an output
+# tensor of shape *features x width x height,* but the following linear
+# layer expects a 1-dimensional input. ``reshape()`` will do this for you,
+# provided that the dimensions you request yield the same number of
+# elements as the input tensor has:
+# 
+
+output3d = torch.rand(6, 20, 20)
+print(output3d.shape)
+
+input1d = output3d.reshape(6 * 20 * 20)
+print(input1d.shape)
+
+# can also call it as a method on the torch module:
+print(torch.reshape(output3d, (6 * 20 * 20,)).shape)
+
+
+###############################################################################
+# .. note::
+#      The ``(6 * 20 * 20,)`` argument in the final line of the cell
+#      above is because PyTorch expects a **tuple** when specifying a
+#      tensor shape - but when the shape is the first argument of a method, it
+#      lets us cheat and just use a series of integers. Here, we had to add the
+#      parentheses and comma to convince the method that this is really a
+#      one-element tuple.
+# 
+# When it can, ``reshape()`` will return a *view* on the tensor to be
+# changed - that is, a separate tensor object looking at the same
+# underlying region of memory. *This is important:* That means any change
+# made to the source tensor will be reflected in the view on that tensor,
+# unless you ``clone()`` it.
+# 
+# There *are* conditions, beyond the scope of this introduction, where
+# ``reshape()`` has to return a tensor carrying a copy of the data. For
+# more information, see the
+# `docs <https://pytorch.org/docs/stable/torch.html#torch.reshape>`__.
+# 
+
+
+#######################################################################
+# NumPy Bridge
+# ------------
+# 
+# In the section above on broadcasting, it was mentioned that PyTorch’s
+# broadcast semantics are compatible with NumPy’s - but the kinship
+# between PyTorch and NumPy goes even deeper than that.
+# 
+# If you have existing ML or scientific code with data stored in NumPy
+# ndarrays, you may wish to express that same data as PyTorch tensors,
+# whether to take advantage of PyTorch’s GPU acceleration, or its
+# efficient abstractions for building ML models. It’s easy to switch
+# between ndarrays and PyTorch tensors:
+# 
+
+import numpy as np
+
+numpy_array = np.ones((2, 3))
+print(numpy_array)
+
+pytorch_tensor = torch.from_numpy(numpy_array)
+print(pytorch_tensor)
+
+
+##########################################################################
+# PyTorch creates a tensor of the same shape and containing the same data
+# as the NumPy array, going so far as to keep NumPy’s default 64-bit float
+# data type.
+# 
+# The conversion can just as easily go the other way:
+# 
+
+pytorch_rand = torch.rand(2, 3)
+print(pytorch_rand)
+
+numpy_rand = pytorch_rand.numpy()
+print(numpy_rand)
+
+
+##########################################################################
+# It is important to know that these converted objects are using *the same
+# underlying memory* as their source objects, meaning that changes to one
+# are reflected in the other:
+# 
+
+numpy_array[1, 1] = 23
+print(pytorch_tensor)
+
+pytorch_rand[1, 1] = 17
+print(numpy_rand)
diff --git a/beginner_source/introyt/tocyt.txt b/beginner_source/introyt/tocyt.txt
new file mode 100644
index 00000000000..24b47e48913
--- /dev/null
+++ b/beginner_source/introyt/tocyt.txt
@@ -0,0 +1,7 @@
+1. `Introduction to PyTorch <introyt/introyt1_tutorial.html>`_
+2. `Introduction to PyTorch Tensors <introyt/tensors_deeper_tutorial.html>`_
+3. `The Fundamentals of Autograd <introyt/autogradyt_tutorial.html>`_
+4. `Building Models with PyTorch <introyt/modelsyt_tutorial.html>`_
+5. `PyTorch TensorBoard Support <introyt/tensorboardyt_tutorial.html>`_
+6. `Training with PyTorch <introyt/trainingyt.html>`_
+7. `Model Understanding with Captum <introyt/captumyt.html>`_
diff --git a/beginner_source/introyt/trainingyt.py b/beginner_source/introyt/trainingyt.py
new file mode 100644
index 00000000000..d9f585411e8
--- /dev/null
+++ b/beginner_source/introyt/trainingyt.py
@@ -0,0 +1,368 @@
+"""
+`Introduction <introyt1_tutorial.html>`_ ||
+`Tensors <tensors_deeper_tutorial.html>`_ ||
+`Autograd <autogradyt_tutorial.html>`_ ||
+`Building Models <modelsyt_tutorial.html>`_ ||
+`TensorBoard Support <tensorboardyt_tutorial.html>`_ ||
+**Training Models** ||
+`Model Understanding <captumyt.html>`_
+
+Training with PyTorch
+=====================
+
+Follow along with the video below or on `youtube <https://www.youtube.com/watch?v=jF43_wj_DCQ>`__.
+
+.. raw:: html
+
+   <div style="margin-top:10px; margin-bottom:10px;">
+     <iframe width="560" height="315" src="https://www.youtube.com/embed/jF43_wj_DCQ" frameborder="0" allow="accelerometer; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
+   </div>
+
+Introduction
+------------
+
+In past videos, we’ve discussed and demonstrated:
+
+- Building models with the neural network layers and functions of the torch.nn module
+- The mechanics of automated gradient computation, which is central to
+  gradient-based model training 
+- Using TensorBoard to visualize training progress and other activities
+
+In this video, we’ll be adding some new tools to your inventory:
+
+- We’ll get familiar with the dataset and dataloader abstractions, and how
+  they ease the process of feeding data to your model during a training loop 
+- We’ll discuss specific loss functions and when to use them
+- We’ll look at PyTorch optimizers, which implement algorithms to adjust
+  model weights based on the outcome of a loss function
+
+Finally, we’ll pull all of these together and see a full PyTorch
+training loop in action.
+
+
+Dataset and DataLoader
+----------------------
+ 
+The ``Dataset`` and ``DataLoader`` classes encapsulate the process of
+pulling your data from storage and exposing it to your training loop in
+batches.
+
+The ``Dataset`` is responsible for accessing and processing single
+instances of data.
+ 
+The ``DataLoader`` pulls instances of data from the ``Dataset`` (either
+automatically or with a sampler that you define), collects them in
+batches, and returns them for consumption by your training loop. The
+``DataLoader`` works with all kinds of datasets, regardless of the type
+of data they contain.
+ 
+For this tutorial, we’ll be using the Fashion-MNIST dataset provided by
+TorchVision. We use ``torchvision.transforms.Normalize()`` to
+zero-center and normalize the distribution of the image tile content,
+and download both training and validation data splits.
+
+""" 
+
+import torch
+import torchvision
+import torchvision.transforms as transforms
+
+# PyTorch TensorBoard support
+from torch.utils.tensorboard import SummaryWriter
+from datetime import datetime
+
+
+transform = transforms.Compose(
+    [transforms.ToTensor(),
+    transforms.Normalize((0.5,), (0.5,))])
+
+# Create datasets for training & validation, download if necessary
+training_set = torchvision.datasets.FashionMNIST('./data', train=True, transform=transform, download=True)
+validation_set = torchvision.datasets.FashionMNIST('./data', train=False, transform=transform, download=True)
+
+# Create data loaders for our datasets; shuffle for training, not for validation
+training_loader = torch.utils.data.DataLoader(training_set, batch_size=4, shuffle=True)
+validation_loader = torch.utils.data.DataLoader(validation_set, batch_size=4, shuffle=False)
+
+# Class labels
+classes = ('T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat',
+        'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle Boot')
+
+# Report split sizes
+print('Training set has {} instances'.format(len(training_set)))
+print('Validation set has {} instances'.format(len(validation_set)))
+
+
+######################################################################
+# As always, let’s visualize the data as a sanity check:
+# 
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+# Helper function for inline image display
+def matplotlib_imshow(img, one_channel=False):
+    if one_channel:
+        img = img.mean(dim=0)
+    img = img / 2 + 0.5     # unnormalize
+    npimg = img.numpy()
+    if one_channel:
+        plt.imshow(npimg, cmap="Greys")
+    else:
+        plt.imshow(np.transpose(npimg, (1, 2, 0)))
+
+dataiter = iter(training_loader)
+images, labels = next(dataiter)
+
+# Create a grid from the images and show them
+img_grid = torchvision.utils.make_grid(images)
+matplotlib_imshow(img_grid, one_channel=True)
+print('  '.join(classes[labels[j]] for j in range(4)))
+
+
+#########################################################################
+# The Model
+# ---------
+# 
+# The model we’ll use in this example is a variant of LeNet-5 - it should
+# be familiar if you’ve watched the previous videos in this series.
+# 
+
+import torch.nn as nn
+import torch.nn.functional as F
+
+# PyTorch models inherit from torch.nn.Module
+class GarmentClassifier(nn.Module):
+    def __init__(self):
+        super(GarmentClassifier, self).__init__()
+        self.conv1 = nn.Conv2d(1, 6, 5)
+        self.pool = nn.MaxPool2d(2, 2)
+        self.conv2 = nn.Conv2d(6, 16, 5)
+        self.fc1 = nn.Linear(16 * 4 * 4, 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 * 4 * 4)
+        x = F.relu(self.fc1(x))
+        x = F.relu(self.fc2(x))
+        x = self.fc3(x)
+        return x
+    
+
+model = GarmentClassifier()
+
+
+##########################################################################
+# Loss Function
+# -------------
+# 
+# For this example, we’ll be using a cross-entropy loss. For demonstration
+# purposes, we’ll create batches of dummy output and label values, run
+# them through the loss function, and examine the result.
+# 
+
+loss_fn = torch.nn.CrossEntropyLoss()
+
+# NB: Loss functions expect data in batches, so we're creating batches of 4
+# Represents the model's confidence in each of the 10 classes for a given input
+dummy_outputs = torch.rand(4, 10)
+# Represents the correct class among the 10 being tested
+dummy_labels = torch.tensor([1, 5, 3, 7])
+    
+print(dummy_outputs)
+print(dummy_labels)
+
+loss = loss_fn(dummy_outputs, dummy_labels)
+print('Total loss for this batch: {}'.format(loss.item()))
+
+
+#################################################################################
+# Optimizer
+# ---------
+# 
+# For this example, we’ll be using simple `stochastic gradient
+# descent <https://pytorch.org/docs/stable/optim.html>`__ with momentum.
+# 
+# It can be instructive to try some variations on this optimization
+# scheme:
+# 
+# - Learning rate determines the size of the steps the optimizer
+#   takes. What does a different learning rate do to the your training
+#   results, in terms of accuracy and convergence time?
+# - Momentum nudges the optimizer in the direction of strongest gradient over
+#   multiple steps. What does changing this value do to your results? 
+# - Try some different optimization algorithms, such as averaged SGD, Adagrad, or
+#   Adam. How do your results differ?
+# 
+
+# Optimizers specified in the torch.optim package
+optimizer = torch.optim.SGD(model.parameters(), lr=0.001, momentum=0.9)
+
+
+#######################################################################################
+# The Training Loop
+# -----------------
+# 
+# Below, we have a function that performs one training epoch. It
+# enumerates data from the DataLoader, and on each pass of the loop does
+# the following:
+# 
+# - Gets a batch of training data from the DataLoader
+# - Zeros the optimizer’s gradients 
+# - Performs an inference - that is, gets predictions from the model for an input batch
+# - Calculates the loss for that set of predictions vs. the labels on the dataset
+# - Calculates the backward gradients over the learning weights
+# - Tells the optimizer to perform one learning step - that is, adjust the model’s
+#   learning weights based on the observed gradients for this batch, according to the
+#   optimization algorithm we chose
+# - It reports on the loss for every 1000 batches.
+# - Finally, it reports the average per-batch loss for the last
+#   1000 batches, for comparison with a validation run
+# 
+
+def train_one_epoch(epoch_index, tb_writer):
+    running_loss = 0.
+    last_loss = 0.
+    
+    # Here, we use enumerate(training_loader) instead of
+    # iter(training_loader) so that we can track the batch
+    # index and do some intra-epoch reporting
+    for i, data in enumerate(training_loader):
+        # Every data instance is an input + label pair
+        inputs, labels = data
+        
+        # Zero your gradients for every batch!
+        optimizer.zero_grad()
+        
+        # Make predictions for this batch
+        outputs = model(inputs)
+        
+        # Compute the loss and its gradients
+        loss = loss_fn(outputs, labels)
+        loss.backward()
+        
+        # Adjust learning weights
+        optimizer.step()
+        
+        # Gather data and report
+        running_loss += loss.item()
+        if i % 1000 == 999:
+            last_loss = running_loss / 1000 # loss per batch
+            print('  batch {} loss: {}'.format(i + 1, last_loss))
+            tb_x = epoch_index * len(training_loader) + i + 1
+            tb_writer.add_scalar('Loss/train', last_loss, tb_x)
+            running_loss = 0.
+            
+    return last_loss
+
+
+##################################################################################
+# Per-Epoch Activity
+# ~~~~~~~~~~~~~~~~~~
+# 
+# There are a couple of things we’ll want to do once per epoch: 
+#
+# - Perform validation by checking our relative loss on a set of data that was not
+#   used for training, and report this 
+# - Save a copy of the model
+# 
+# Here, we’ll do our reporting in TensorBoard. This will require going to
+# the command line to start TensorBoard, and opening it in another browser
+# tab.
+# 
+
+# Initializing in a separate cell so we can easily add more epochs to the same run
+timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+writer = SummaryWriter('runs/fashion_trainer_{}'.format(timestamp))
+epoch_number = 0
+
+EPOCHS = 5
+
+best_vloss = 1_000_000.
+
+for epoch in range(EPOCHS):
+    print('EPOCH {}:'.format(epoch_number + 1))
+    
+    # Make sure gradient tracking is on, and do a pass over the data
+    model.train(True)
+    avg_loss = train_one_epoch(epoch_number, writer)
+    
+
+    running_vloss = 0.0
+    # Set the model to evaluation mode, disabling dropout and using population 
+    # statistics for batch normalization.
+    model.eval()
+
+    # Disable gradient computation and reduce memory consumption.
+    with torch.no_grad():
+        for i, vdata in enumerate(validation_loader):
+            vinputs, vlabels = vdata
+            voutputs = model(vinputs)
+            vloss = loss_fn(voutputs, vlabels)
+            running_vloss += vloss
+    
+    avg_vloss = running_vloss / (i + 1)
+    print('LOSS train {} valid {}'.format(avg_loss, avg_vloss))
+    
+    # Log the running loss averaged per batch
+    # for both training and validation
+    writer.add_scalars('Training vs. Validation Loss',
+                    { 'Training' : avg_loss, 'Validation' : avg_vloss },
+                    epoch_number + 1)
+    writer.flush()
+    
+    # Track best performance, and save the model's state
+    if avg_vloss < best_vloss:
+        best_vloss = avg_vloss
+        model_path = 'model_{}_{}'.format(timestamp, epoch_number)
+        torch.save(model.state_dict(), model_path)
+    
+    epoch_number += 1
+
+
+#########################################################################
+# To load a saved version of the model:
+#
+# .. code:: python
+#
+#     saved_model = GarmentClassifier()
+#     saved_model.load_state_dict(torch.load(PATH))
+#
+# Once you’ve loaded the model, it’s ready for whatever you need it for -
+# more training, inference, or analysis.
+# 
+# Note that if your model has constructor parameters that affect model
+# structure, you’ll need to provide them and configure the model
+# identically to the state in which it was saved.
+# 
+# Other Resources
+# ---------------
+# 
+# -  Docs on the `data
+#    utilities <https://pytorch.org/docs/stable/data.html>`__, including
+#    Dataset and DataLoader, at pytorch.org
+# -  A `note on the use of pinned
+#    memory <https://pytorch.org/docs/stable/notes/cuda.html#cuda-memory-pinning>`__
+#    for GPU training
+# -  Documentation on the datasets available in
+#    `TorchVision <https://pytorch.org/vision/stable/datasets.html>`__,
+#    `TorchText <https://pytorch.org/text/stable/datasets.html>`__, and
+#    `TorchAudio <https://pytorch.org/audio/stable/datasets.html>`__
+# -  Documentation on the `loss
+#    functions <https://pytorch.org/docs/stable/nn.html#loss-functions>`__
+#    available in PyTorch
+# -  Documentation on the `torch.optim
+#    package <https://pytorch.org/docs/stable/optim.html>`__, which
+#    includes optimizers and related tools, such as learning rate
+#    scheduling
+# -  A detailed `tutorial on saving and loading
+#    models <https://pytorch.org/tutorials/beginner/saving_loading_models.html>`__
+# -  The `Tutorials section of
+#    pytorch.org <https://pytorch.org/tutorials/>`__ contains tutorials on
+#    a broad variety of training tasks, including classification in
+#    different domains, generative adversarial networks, reinforcement
+#    learning, and more 
+# 
diff --git a/beginner_source/knowledge_distillation_tutorial.py b/beginner_source/knowledge_distillation_tutorial.py
new file mode 100644
index 00000000000..19d1553e7a0
--- /dev/null
+++ b/beginner_source/knowledge_distillation_tutorial.py
@@ -0,0 +1,740 @@
+# -*- coding: utf-8 -*-
+"""
+Knowledge Distillation Tutorial
+===============================
+**Author**: `Alexandros Chariton <https://github.com/AlexandrosChrtn>`_
+""" 
+
+######################################################################
+# Knowledge distillation is a technique that enables knowledge transfer from large, computationally expensive
+# models to smaller ones without losing validity. This allows for deployment on less powerful
+# hardware, making evaluation faster and more efficient. 
+#
+# In this tutorial, we will run a number of experiments focused at improving the accuracy of a
+# lightweight neural network, using a more powerful network as a teacher.
+# The computational cost and the speed of the lightweight network will remain unaffected,
+# our intervention only focuses on its weights, not on its forward pass.
+# Applications of this technology can be found in devices such as drones or mobile phones.
+# In this tutorial, we do not use any external packages as everything we need is available in ``torch`` and
+# ``torchvision``.
+#
+# In this tutorial, you will learn:
+#
+# - How to modify model classes to extract hidden representations and use them for further calculations
+# - How to modify regular train loops in PyTorch to include additional losses on top of, for example, cross-entropy for classification 
+# - How to improve the performance of lightweight models by using more complex models as teachers
+#
+# Prerequisites
+# ~~~~~~~~~~~~~
+#
+# * 1 GPU, 4GB of memory
+# * PyTorch v2.0 or later 
+# * CIFAR-10 dataset (downloaded by the script and saved in a directory called ``/data``)
+
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import torchvision.transforms as transforms
+import torchvision.datasets as datasets
+
+# Check if the current `accelerator <https://pytorch.org/docs/stable/torch.html#accelerators>`__
+# is available, and if not, use the CPU
+device = torch.accelerator.current_accelerator().type if torch.accelerator.is_available() else "cpu"
+print(f"Using {device} device")
+
+######################################################################
+# Loading CIFAR-10
+# ----------------
+# CIFAR-10 is a popular image dataset with ten classes. Our objective is to predict one of the following classes for each input image.
+#
+# .. figure:: /../_static/img/cifar10.png 
+#    :align: center
+#    
+#    Example of CIFAR-10 images
+#
+# The input images are RGB, so they have 3 channels and are 32x32 pixels. Basically, each image is described by 3 x 32 x 32 = 3072 numbers ranging from 0 to 255.
+# A common practice in neural networks is to normalize the input, which is done for multiple reasons,
+# including avoiding saturation in commonly used activation functions and increasing numerical stability.
+# Our normalization process consists of subtracting the mean and dividing by the standard deviation along each channel.
+# The tensors "mean=[0.485, 0.456, 0.406]" and "std=[0.229, 0.224, 0.225]" were already computed,
+# and they represent the mean and standard deviation of each channel in the
+# predefined subset of CIFAR-10 intended to be the training set.
+# Notice how we use these values for the test set as well, without recomputing the mean and standard deviation from scratch.
+# This is because the network was trained on features produced by subtracting and dividing the numbers above, and we want to maintain consistency.
+# Furthermore, in real life, we would not be able to compute the mean and standard deviation of the test set since,
+# under our assumptions, this data would not be accessible at that point.
+# 
+# As a closing point, we often refer to this held-out set as the validation set, and we use a separate set,
+# called the test set, after optimizing a model's performance on the validation set.
+# This is done to avoid selecting a model based on the greedy and biased optimization of a single metric.
+
+# Below we are preprocessing data for CIFAR-10. We use an arbitrary batch size of 128.
+transforms_cifar = transforms.Compose([
+    transforms.ToTensor(),
+    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+])
+
+# Loading the CIFAR-10 dataset:
+train_dataset = datasets.CIFAR10(root='./data', train=True, download=True, transform=transforms_cifar)
+test_dataset = datasets.CIFAR10(root='./data', train=False, download=True, transform=transforms_cifar)
+
+########################################################################
+# .. note:: This section is for CPU users only who are interested in quick results. Use this option only if you're interested in a small scale experiment. Keep in mind the code should run fairly quickly using any GPU. Select only the first ``num_images_to_keep`` images from the train/test dataset
+#
+#    .. code-block:: python
+#
+#       #from torch.utils.data import Subset
+#       #num_images_to_keep = 2000
+#       #train_dataset = Subset(train_dataset, range(min(num_images_to_keep, 50_000)))
+#       #test_dataset = Subset(test_dataset, range(min(num_images_to_keep, 10_000)))
+
+#Dataloaders
+train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=128, shuffle=True, num_workers=2)
+test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=128, shuffle=False, num_workers=2)
+
+######################################################################
+# Defining model classes and utility functions
+# --------------------------------------------
+# Next, we need to define our model classes. Several user-defined parameters need to be set here. We use two different architectures, keeping the number of filters fixed across our experiments to ensure fair comparisons.
+# Both architectures are Convolutional Neural Networks (CNNs) with a different number of convolutional layers that serve as feature extractors, followed by a classifier with 10 classes. 
+# The number of filters and neurons is smaller for the students.
+
+# Deeper neural network class to be used as teacher:
+class DeepNN(nn.Module):
+    def __init__(self, num_classes=10):
+        super(DeepNN, self).__init__()
+        self.features = nn.Sequential(
+            nn.Conv2d(3, 128, kernel_size=3, padding=1),
+            nn.ReLU(),
+            nn.Conv2d(128, 64, kernel_size=3, padding=1),
+            nn.ReLU(),
+            nn.MaxPool2d(kernel_size=2, stride=2),
+            nn.Conv2d(64, 64, kernel_size=3, padding=1),
+            nn.ReLU(),
+            nn.Conv2d(64, 32, kernel_size=3, padding=1),
+            nn.ReLU(),
+            nn.MaxPool2d(kernel_size=2, stride=2),
+        )
+        self.classifier = nn.Sequential(
+            nn.Linear(2048, 512),
+            nn.ReLU(),
+            nn.Dropout(0.1),
+            nn.Linear(512, num_classes)
+        )
+
+    def forward(self, x):
+        x = self.features(x)
+        x = torch.flatten(x, 1)
+        x = self.classifier(x)
+        return x
+
+# Lightweight neural network class to be used as student:
+class LightNN(nn.Module):
+    def __init__(self, num_classes=10):
+        super(LightNN, self).__init__()
+        self.features = nn.Sequential(
+            nn.Conv2d(3, 16, kernel_size=3, padding=1),
+            nn.ReLU(),
+            nn.MaxPool2d(kernel_size=2, stride=2),
+            nn.Conv2d(16, 16, kernel_size=3, padding=1),
+            nn.ReLU(),
+            nn.MaxPool2d(kernel_size=2, stride=2),
+        )
+        self.classifier = nn.Sequential(
+            nn.Linear(1024, 256),
+            nn.ReLU(),
+            nn.Dropout(0.1),
+            nn.Linear(256, num_classes)
+        )
+
+    def forward(self, x):
+        x = self.features(x)
+        x = torch.flatten(x, 1)
+        x = self.classifier(x)
+        return x
+
+######################################################################
+# We employ 2 functions to help us produce and evaluate the results on our original classification task.
+# One function is called ``train`` and takes the following arguments:
+#
+# - ``model``: A model instance to train (update its weights) via this function.
+# - ``train_loader``: We defined our ``train_loader`` above, and its job is to feed the data into the model.
+# - ``epochs``: How many times we loop over the dataset.
+# - ``learning_rate``: The learning rate determines how large our steps towards convergence should be. Too large or too small steps can be detrimental.
+# - ``device``: Determines the device to run the workload on. Can be either CPU or GPU depending on availability.
+#
+# Our test function is similar, but it will be invoked with ``test_loader`` to load images from the test set.
+#
+# .. figure:: /../_static/img/knowledge_distillation/ce_only.png 
+#    :align: center
+#    
+#    Train both networks with Cross-Entropy. The student will be used as a baseline:
+#
+
+def train(model, train_loader, epochs, learning_rate, device):
+    criterion = nn.CrossEntropyLoss()
+    optimizer = optim.Adam(model.parameters(), lr=learning_rate)
+
+    model.train()
+
+    for epoch in range(epochs):
+        running_loss = 0.0
+        for inputs, labels in train_loader:
+            # inputs: A collection of batch_size images
+            # labels: A vector of dimensionality batch_size with integers denoting class of each image
+            inputs, labels = inputs.to(device), labels.to(device)
+
+            optimizer.zero_grad()
+            outputs = model(inputs)
+
+            # outputs: Output of the network for the collection of images. A tensor of dimensionality batch_size x num_classes
+            # labels: The actual labels of the images. Vector of dimensionality batch_size
+            loss = criterion(outputs, labels)
+            loss.backward()
+            optimizer.step()
+
+            running_loss += loss.item()
+
+        print(f"Epoch {epoch+1}/{epochs}, Loss: {running_loss / len(train_loader)}")
+
+def test(model, test_loader, device):
+    model.to(device)
+    model.eval()
+
+    correct = 0
+    total = 0
+
+    with torch.no_grad():
+        for inputs, labels in test_loader:
+            inputs, labels = inputs.to(device), labels.to(device)
+
+            outputs = model(inputs)
+            _, predicted = torch.max(outputs.data, 1)
+
+            total += labels.size(0)
+            correct += (predicted == labels).sum().item()
+
+    accuracy = 100 * correct / total
+    print(f"Test Accuracy: {accuracy:.2f}%")
+    return accuracy
+
+######################################################################
+# Cross-entropy runs
+# ------------------
+# For reproducibility, we need to set the torch manual seed. We train networks using different methods, so to compare them fairly,
+# it makes sense to initialize the networks with the same weights.
+# Start by training the teacher network using cross-entropy:
+
+torch.manual_seed(42)
+nn_deep = DeepNN(num_classes=10).to(device)
+train(nn_deep, train_loader, epochs=10, learning_rate=0.001, device=device)
+test_accuracy_deep = test(nn_deep, test_loader, device)
+
+# Instantiate the lightweight network:
+torch.manual_seed(42)
+nn_light = LightNN(num_classes=10).to(device)
+
+######################################################################
+# We instantiate one more lightweight network model to compare their performances.
+# Back propagation is sensitive to weight initialization,
+# so we need to make sure these two networks have the exact same initialization.
+
+torch.manual_seed(42)
+new_nn_light = LightNN(num_classes=10).to(device)
+
+######################################################################
+# To ensure we have created a copy of the first network, we inspect the norm of its first layer.
+# If it matches, then we are safe to conclude that the networks are indeed the same.
+
+# Print the norm of the first layer of the initial lightweight model
+print("Norm of 1st layer of nn_light:", torch.norm(nn_light.features[0].weight).item())
+# Print the norm of the first layer of the new lightweight model
+print("Norm of 1st layer of new_nn_light:", torch.norm(new_nn_light.features[0].weight).item())
+
+######################################################################
+# Print the total number of parameters in each model:
+total_params_deep = "{:,}".format(sum(p.numel() for p in nn_deep.parameters()))
+print(f"DeepNN parameters: {total_params_deep}")
+total_params_light = "{:,}".format(sum(p.numel() for p in nn_light.parameters()))
+print(f"LightNN parameters: {total_params_light}")
+
+######################################################################
+# Train and test the lightweight network with cross entropy loss:
+train(nn_light, train_loader, epochs=10, learning_rate=0.001, device=device)
+test_accuracy_light_ce = test(nn_light, test_loader, device)
+
+######################################################################
+# As we can see, based on test accuracy, we can now compare the deeper network that is to be used as a teacher with the lightweight network that is our supposed student. So far, our student has not intervened with the teacher, therefore this performance is achieved by the student itself.
+# The metrics so far can be seen with the following lines:
+
+print(f"Teacher accuracy: {test_accuracy_deep:.2f}%")
+print(f"Student accuracy: {test_accuracy_light_ce:.2f}%")
+
+######################################################################
+# Knowledge distillation run
+# --------------------------
+# Now let's try to improve the test accuracy of the student network by incorporating the teacher.
+# Knowledge distillation is a straightforward technique to achieve this,
+# based on the fact that both networks output a probability distribution over our classes.
+# Therefore, the two networks share the same number of output neurons.
+# The method works by incorporating an additional loss into the traditional cross entropy loss,
+# which is based on the softmax output of the teacher network.
+# The assumption is that the output activations of a properly trained teacher network carry additional information that can be leveraged by a student network during training.
+# The original work suggests that utilizing ratios of smaller probabilities in the soft targets can help achieve the underlying objective of deep neural networks,
+# which is to create a similarity structure over the data where similar objects are mapped closer together.
+# For example, in CIFAR-10, a truck could be mistaken for an automobile or airplane,
+# if its wheels are present, but it is less likely to be mistaken for a dog. 
+# Therefore, it makes sense to assume that valuable information resides not only in the top prediction of a properly trained model but in the entire output distribution.
+# However, cross entropy alone does not sufficiently exploit this information as the activations for non-predicted classes
+# tend to be so small that propagated gradients do not meaningfully change the weights to construct this desirable vector space.
+#
+# As we continue defining our first helper function that introduces a teacher-student dynamic, we need to include a few extra parameters:
+# 
+# - ``T``: Temperature controls the smoothness of the output distributions. Larger ``T`` leads to smoother distributions, thus smaller probabilities get a larger boost.
+# - ``soft_target_loss_weight``: A weight assigned to the extra objective we're about to include.
+# - ``ce_loss_weight``: A weight assigned to cross-entropy. Tuning these weights pushes the network towards optimizing for either objective.
+#
+# .. figure:: /../_static/img/knowledge_distillation/distillation_output_loss.png 
+#    :align: center
+#    
+#    Distillation loss is calculated from the logits of the networks. It only returns gradients to the student:
+#
+
+def train_knowledge_distillation(teacher, student, train_loader, epochs, learning_rate, T, soft_target_loss_weight, ce_loss_weight, device):
+    ce_loss = nn.CrossEntropyLoss()
+    optimizer = optim.Adam(student.parameters(), lr=learning_rate)
+
+    teacher.eval()  # Teacher set to evaluation mode
+    student.train() # Student to train mode
+
+    for epoch in range(epochs):
+        running_loss = 0.0
+        for inputs, labels in train_loader:
+            inputs, labels = inputs.to(device), labels.to(device)
+
+            optimizer.zero_grad()
+
+            # Forward pass with the teacher model - do not save gradients here as we do not change the teacher's weights
+            with torch.no_grad():
+                teacher_logits = teacher(inputs)
+
+            # Forward pass with the student model
+            student_logits = student(inputs)
+
+            #Soften the student logits by applying softmax first and log() second
+            soft_targets = nn.functional.softmax(teacher_logits / T, dim=-1)
+            soft_prob = nn.functional.log_softmax(student_logits / T, dim=-1)
+
+            # Calculate the soft targets loss. Scaled by T**2 as suggested by the authors of the paper "Distilling the knowledge in a neural network"
+            soft_targets_loss = torch.sum(soft_targets * (soft_targets.log() - soft_prob)) / soft_prob.size()[0] * (T**2)
+
+            # Calculate the true label loss
+            label_loss = ce_loss(student_logits, labels)
+
+            # Weighted sum of the two losses
+            loss = soft_target_loss_weight * soft_targets_loss + ce_loss_weight * label_loss
+
+            loss.backward()
+            optimizer.step()
+
+            running_loss += loss.item()
+
+        print(f"Epoch {epoch+1}/{epochs}, Loss: {running_loss / len(train_loader)}")
+
+# Apply ``train_knowledge_distillation`` with a temperature of 2. Arbitrarily set the weights to 0.75 for CE and 0.25 for distillation loss.
+train_knowledge_distillation(teacher=nn_deep, student=new_nn_light, train_loader=train_loader, epochs=10, learning_rate=0.001, T=2, soft_target_loss_weight=0.25, ce_loss_weight=0.75, device=device)
+test_accuracy_light_ce_and_kd = test(new_nn_light, test_loader, device)
+
+# Compare the student test accuracy with and without the teacher, after distillation
+print(f"Teacher accuracy: {test_accuracy_deep:.2f}%")
+print(f"Student accuracy without teacher: {test_accuracy_light_ce:.2f}%")
+print(f"Student accuracy with CE + KD: {test_accuracy_light_ce_and_kd:.2f}%")
+
+######################################################################
+# Cosine loss minimization run
+# ----------------------------
+# Feel free to play around with the temperature parameter that controls the softness of the softmax function and the loss coefficients.
+# In neural networks, it is easy to include additional loss functions to the main objectives to achieve goals like better generalization.
+# Let's try including an objective for the student, but now let's focus on their hidden states rather than their output layers.
+# Our goal is to convey information from the teacher's representation to the student by including a naive loss function,
+# whose minimization implies that the flattened vectors that are subsequently passed to the classifiers have become more *similar* as the loss decreases.
+# Of course, the teacher does not update its weights, so the minimization depends only on the student's weights.
+# The rationale behind this method is that we are operating under the assumption that the teacher model has a better internal representation that is
+# unlikely to be achieved by the student without external intervention, therefore we artificially push the student to mimic the internal representation of the teacher.
+# Whether or not this will end up helping the student is not straightforward, though, because pushing the lightweight network
+# to reach this point could be a good thing, assuming that we have found an internal representation that leads to better test accuracy,
+# but it could also be harmful because the networks have different architectures and the student does not have the same learning capacity as the teacher.
+# In other words, there is no reason for these two vectors, the student's and the teacher's to match per component.
+# The student could reach an internal representation that is a permutation of the teacher's and it would be just as efficient.
+# Nonetheless, we can still run a quick experiment to figure out the impact of this method.
+# We will be using the ``CosineEmbeddingLoss`` which is given by the following formula:
+#
+# .. figure:: /../_static/img/knowledge_distillation/cosine_embedding_loss.png 
+#    :align: center
+#    :width: 450px
+#    
+#    Formula for CosineEmbeddingLoss
+#
+# Obviously, there is one thing that we need to resolve first.
+# When we applied distillation to the output layer we mentioned that both networks have the same number of neurons, equal to the number of classes.
+# However, this is not the case for the layer following our convolutional layers. Here, the teacher has more neurons than the student
+# after the flattening of the final convolutional layer. Our loss function accepts two vectors of equal dimensionality as inputs,
+# therefore we need to somehow match them. We will solve this by including an average pooling layer after the teacher's convolutional layer to reduce its dimensionality to match that of the student.
+#
+# To proceed, we will modify our model classes, or create new ones.
+# Now, the forward function returns not only the logits of the network but also the flattened hidden representation after the convolutional layer. We include the aforementioned pooling for the modified teacher.
+
+class ModifiedDeepNNCosine(nn.Module):
+    def __init__(self, num_classes=10):
+        super(ModifiedDeepNNCosine, self).__init__()
+        self.features = nn.Sequential(
+            nn.Conv2d(3, 128, kernel_size=3, padding=1),
+            nn.ReLU(),
+            nn.Conv2d(128, 64, kernel_size=3, padding=1),
+            nn.ReLU(),
+            nn.MaxPool2d(kernel_size=2, stride=2),
+            nn.Conv2d(64, 64, kernel_size=3, padding=1),
+            nn.ReLU(),
+            nn.Conv2d(64, 32, kernel_size=3, padding=1),
+            nn.ReLU(),
+            nn.MaxPool2d(kernel_size=2, stride=2),
+        )
+        self.classifier = nn.Sequential(
+            nn.Linear(2048, 512),
+            nn.ReLU(),
+            nn.Dropout(0.1),
+            nn.Linear(512, num_classes)
+        )
+
+    def forward(self, x):
+        x = self.features(x)
+        flattened_conv_output = torch.flatten(x, 1)
+        x = self.classifier(flattened_conv_output)
+        flattened_conv_output_after_pooling = torch.nn.functional.avg_pool1d(flattened_conv_output, 2)
+        return x, flattened_conv_output_after_pooling
+
+# Create a similar student class where we return a tuple. We do not apply pooling after flattening.
+class ModifiedLightNNCosine(nn.Module):
+    def __init__(self, num_classes=10):
+        super(ModifiedLightNNCosine, self).__init__()
+        self.features = nn.Sequential(
+            nn.Conv2d(3, 16, kernel_size=3, padding=1),
+            nn.ReLU(),
+            nn.MaxPool2d(kernel_size=2, stride=2),
+            nn.Conv2d(16, 16, kernel_size=3, padding=1),
+            nn.ReLU(),
+            nn.MaxPool2d(kernel_size=2, stride=2),
+        )
+        self.classifier = nn.Sequential(
+            nn.Linear(1024, 256),
+            nn.ReLU(),
+            nn.Dropout(0.1),
+            nn.Linear(256, num_classes)
+        )
+
+    def forward(self, x):
+        x = self.features(x)
+        flattened_conv_output = torch.flatten(x, 1)
+        x = self.classifier(flattened_conv_output)
+        return x, flattened_conv_output
+
+# We do not have to train the modified deep network from scratch of course, we just load its weights from the trained instance
+modified_nn_deep = ModifiedDeepNNCosine(num_classes=10).to(device)
+modified_nn_deep.load_state_dict(nn_deep.state_dict())
+
+# Once again ensure the norm of the first layer is the same for both networks
+print("Norm of 1st layer for deep_nn:", torch.norm(nn_deep.features[0].weight).item())
+print("Norm of 1st layer for modified_deep_nn:", torch.norm(modified_nn_deep.features[0].weight).item())
+
+# Initialize a modified lightweight network with the same seed as our other lightweight instances. This will be trained from scratch to examine the effectiveness of cosine loss minimization.
+torch.manual_seed(42)
+modified_nn_light = ModifiedLightNNCosine(num_classes=10).to(device)
+print("Norm of 1st layer:", torch.norm(modified_nn_light.features[0].weight).item())
+
+######################################################################
+# Naturally, we need to change the train loop because now the model returns a tuple ``(logits, hidden_representation)``. Using a sample input tensor
+# we can print their shapes.
+
+# Create a sample input tensor
+sample_input = torch.randn(128, 3, 32, 32).to(device) # Batch size: 128, Filters: 3, Image size: 32x32
+
+# Pass the input through the student
+logits, hidden_representation = modified_nn_light(sample_input)
+
+# Print the shapes of the tensors
+print("Student logits shape:", logits.shape) # batch_size x total_classes
+print("Student hidden representation shape:", hidden_representation.shape) # batch_size x hidden_representation_size
+
+# Pass the input through the teacher
+logits, hidden_representation = modified_nn_deep(sample_input)
+
+# Print the shapes of the tensors
+print("Teacher logits shape:", logits.shape) # batch_size x total_classes
+print("Teacher hidden representation shape:", hidden_representation.shape) # batch_size x hidden_representation_size
+
+######################################################################
+# In our case, ``hidden_representation_size`` is ``1024``. This is the flattened feature map of the final convolutional layer of the student and as you can see,
+# it is the input for its classifier. It is ``1024`` for the teacher too, because we made it so with ``avg_pool1d`` from ``2048``.
+# The loss applied here only affects the weights of the student prior to the loss calculation. In other words, it does not affect the classifier of the student.
+# The modified training loop is the following:
+#
+# .. figure:: /../_static/img/knowledge_distillation/cosine_loss_distillation.png 
+#    :align: center
+#    
+#    In Cosine Loss minimization, we want to maximize the cosine similarity of the two representations by returning gradients to the student:
+#
+
+def train_cosine_loss(teacher, student, train_loader, epochs, learning_rate, hidden_rep_loss_weight, ce_loss_weight, device):
+    ce_loss = nn.CrossEntropyLoss()
+    cosine_loss = nn.CosineEmbeddingLoss()
+    optimizer = optim.Adam(student.parameters(), lr=learning_rate)
+
+    teacher.to(device)
+    student.to(device)
+    teacher.eval()  # Teacher set to evaluation mode
+    student.train() # Student to train mode
+
+    for epoch in range(epochs):
+        running_loss = 0.0
+        for inputs, labels in train_loader:
+            inputs, labels = inputs.to(device), labels.to(device)
+
+            optimizer.zero_grad()
+
+            # Forward pass with the teacher model and keep only the hidden representation
+            with torch.no_grad():
+                _, teacher_hidden_representation = teacher(inputs)
+
+            # Forward pass with the student model
+            student_logits, student_hidden_representation = student(inputs)
+
+            # Calculate the cosine loss. Target is a vector of ones. From the loss formula above we can see that is the case where loss minimization leads to cosine similarity increase.
+            hidden_rep_loss = cosine_loss(student_hidden_representation, teacher_hidden_representation, target=torch.ones(inputs.size(0)).to(device))
+
+            # Calculate the true label loss
+            label_loss = ce_loss(student_logits, labels)
+
+            # Weighted sum of the two losses
+            loss = hidden_rep_loss_weight * hidden_rep_loss + ce_loss_weight * label_loss
+
+            loss.backward()
+            optimizer.step()
+
+            running_loss += loss.item()
+
+        print(f"Epoch {epoch+1}/{epochs}, Loss: {running_loss / len(train_loader)}")
+
+######################################################################
+#We need to modify our test function for the same reason. Here we ignore the hidden representation returned by the model.
+
+def test_multiple_outputs(model, test_loader, device):
+    model.to(device)
+    model.eval()
+
+    correct = 0
+    total = 0
+
+    with torch.no_grad():
+        for inputs, labels in test_loader:
+            inputs, labels = inputs.to(device), labels.to(device)
+
+            outputs, _ = model(inputs) # Disregard the second tensor of the tuple
+            _, predicted = torch.max(outputs.data, 1)
+
+            total += labels.size(0)
+            correct += (predicted == labels).sum().item()
+
+    accuracy = 100 * correct / total
+    print(f"Test Accuracy: {accuracy:.2f}%")
+    return accuracy
+
+######################################################################
+# In this case, we could easily include both knowledge distillation and cosine loss minimization in the same function. It is common to combine methods to achieve better performance in teacher-student paradigms.
+# For now, we can run a simple train-test session.
+
+# Train and test the lightweight network with cross entropy loss
+train_cosine_loss(teacher=modified_nn_deep, student=modified_nn_light, train_loader=train_loader, epochs=10, learning_rate=0.001, hidden_rep_loss_weight=0.25, ce_loss_weight=0.75, device=device)
+test_accuracy_light_ce_and_cosine_loss = test_multiple_outputs(modified_nn_light, test_loader, device)
+
+######################################################################
+# Intermediate regressor run
+# --------------------------
+# Our naive minimization does not guarantee better results for several reasons, one being the dimensionality of the vectors.
+# Cosine similarity generally works better than Euclidean distance for vectors of higher dimensionality,
+# but we were dealing with vectors with 1024 components each, so it is much harder to extract meaningful similarities.
+# Furthermore, as we mentioned, pushing towards a match of the hidden representation of the teacher and the student is not supported by theory.
+# There are no good reasons why we should be aiming for a 1:1 match of these vectors.
+# We will provide a final example of training intervention by including an extra network called regressor.
+# The objective is to first extract the feature map of the teacher after a convolutional layer,
+# then extract a feature map of the student after a convolutional layer, and finally try to match these maps.
+# However, this time, we will introduce a regressor between the networks to facilitate the matching process.
+# The regressor will be trainable and ideally will do a better job than our naive cosine loss minimization scheme.
+# Its main job is to match the dimensionality of these feature maps so that we can properly define a loss function between the teacher and the student.
+# Defining such a loss function provides a teaching "path," which is basically a flow to back-propagate gradients that will change the student's weights.
+# Focusing on the output of the convolutional layers right before each classifier for our original networks, we have the following shapes:
+#
+
+# Pass the sample input only from the convolutional feature extractor
+convolutional_fe_output_student = nn_light.features(sample_input)
+convolutional_fe_output_teacher = nn_deep.features(sample_input)
+
+# Print their shapes
+print("Student's feature extractor output shape: ", convolutional_fe_output_student.shape)
+print("Teacher's feature extractor output shape: ", convolutional_fe_output_teacher.shape)
+
+######################################################################
+# We have 32 filters for the teacher and 16 filters for the student.
+# We will include a trainable layer that converts the feature map of the student to the shape of the feature map of the teacher.
+# In practice, we modify the lightweight class to return the hidden state after an intermediate regressor that matches the sizes of the convolutional
+# feature maps and the teacher class to return the output of the final convolutional layer without pooling or flattening.
+#
+# .. figure:: /../_static/img/knowledge_distillation/fitnets_knowledge_distill.png 
+#    :align: center
+#    
+#    The trainable layer matches the shapes of the intermediate tensors and Mean Squared Error (MSE) is properly defined:
+#
+
+class ModifiedDeepNNRegressor(nn.Module):
+    def __init__(self, num_classes=10):
+        super(ModifiedDeepNNRegressor, self).__init__()
+        self.features = nn.Sequential(
+            nn.Conv2d(3, 128, kernel_size=3, padding=1),
+            nn.ReLU(),
+            nn.Conv2d(128, 64, kernel_size=3, padding=1),
+            nn.ReLU(),
+            nn.MaxPool2d(kernel_size=2, stride=2),
+            nn.Conv2d(64, 64, kernel_size=3, padding=1),
+            nn.ReLU(),
+            nn.Conv2d(64, 32, kernel_size=3, padding=1),
+            nn.ReLU(),
+            nn.MaxPool2d(kernel_size=2, stride=2),
+        )
+        self.classifier = nn.Sequential(
+            nn.Linear(2048, 512),
+            nn.ReLU(),
+            nn.Dropout(0.1),
+            nn.Linear(512, num_classes)
+        )
+
+    def forward(self, x):
+        x = self.features(x)
+        conv_feature_map = x
+        x = torch.flatten(x, 1)
+        x = self.classifier(x)
+        return x, conv_feature_map
+
+class ModifiedLightNNRegressor(nn.Module):
+    def __init__(self, num_classes=10):
+        super(ModifiedLightNNRegressor, self).__init__()
+        self.features = nn.Sequential(
+            nn.Conv2d(3, 16, kernel_size=3, padding=1),
+            nn.ReLU(),
+            nn.MaxPool2d(kernel_size=2, stride=2),
+            nn.Conv2d(16, 16, kernel_size=3, padding=1),
+            nn.ReLU(),
+            nn.MaxPool2d(kernel_size=2, stride=2),
+        )
+        # Include an extra regressor (in our case linear)
+        self.regressor = nn.Sequential(
+            nn.Conv2d(16, 32, kernel_size=3, padding=1)
+        )
+        self.classifier = nn.Sequential(
+            nn.Linear(1024, 256),
+            nn.ReLU(),
+            nn.Dropout(0.1),
+            nn.Linear(256, num_classes)
+        )
+
+    def forward(self, x):
+        x = self.features(x)
+        regressor_output = self.regressor(x)
+        x = torch.flatten(x, 1)
+        x = self.classifier(x)
+        return x, regressor_output
+
+######################################################################
+# After that, we have to update our train loop again. This time, we extract the regressor output of the student, the feature map of the teacher,
+# we calculate the ``MSE`` on these tensors (they have the exact same shape so it's properly defined) and we back propagate gradients based on that loss,
+# in addition to the regular cross entropy loss of the classification task.
+
+def train_mse_loss(teacher, student, train_loader, epochs, learning_rate, feature_map_weight, ce_loss_weight, device):
+    ce_loss = nn.CrossEntropyLoss()
+    mse_loss = nn.MSELoss()
+    optimizer = optim.Adam(student.parameters(), lr=learning_rate)
+
+    teacher.to(device)
+    student.to(device)
+    teacher.eval()  # Teacher set to evaluation mode
+    student.train() # Student to train mode
+
+    for epoch in range(epochs):
+        running_loss = 0.0
+        for inputs, labels in train_loader:
+            inputs, labels = inputs.to(device), labels.to(device)
+
+            optimizer.zero_grad()
+
+            # Again ignore teacher logits
+            with torch.no_grad():
+                _, teacher_feature_map = teacher(inputs)
+
+            # Forward pass with the student model
+            student_logits, regressor_feature_map = student(inputs)
+
+            # Calculate the loss
+            hidden_rep_loss = mse_loss(regressor_feature_map, teacher_feature_map)
+
+            # Calculate the true label loss
+            label_loss = ce_loss(student_logits, labels)
+
+            # Weighted sum of the two losses
+            loss = feature_map_weight * hidden_rep_loss + ce_loss_weight * label_loss
+
+            loss.backward()
+            optimizer.step()
+
+            running_loss += loss.item()
+
+        print(f"Epoch {epoch+1}/{epochs}, Loss: {running_loss / len(train_loader)}")
+
+# Notice how our test function remains the same here with the one we used in our previous case. We only care about the actual outputs because we measure accuracy.
+
+# Initialize a ModifiedLightNNRegressor
+torch.manual_seed(42)
+modified_nn_light_reg = ModifiedLightNNRegressor(num_classes=10).to(device)
+
+# We do not have to train the modified deep network from scratch of course, we just load its weights from the trained instance
+modified_nn_deep_reg = ModifiedDeepNNRegressor(num_classes=10).to(device)
+modified_nn_deep_reg.load_state_dict(nn_deep.state_dict())
+
+# Train and test once again
+train_mse_loss(teacher=modified_nn_deep_reg, student=modified_nn_light_reg, train_loader=train_loader, epochs=10, learning_rate=0.001, feature_map_weight=0.25, ce_loss_weight=0.75, device=device)
+test_accuracy_light_ce_and_mse_loss = test_multiple_outputs(modified_nn_light_reg, test_loader, device)
+
+######################################################################
+# It is expected that the final method will work better than ``CosineLoss`` because now we have allowed a trainable layer between the teacher and the student,
+# which gives the student some wiggle room when it comes to learning, rather than pushing the student to copy the teacher's representation.
+# Including the extra network is the idea behind hint-based distillation.
+
+print(f"Teacher accuracy: {test_accuracy_deep:.2f}%")
+print(f"Student accuracy without teacher: {test_accuracy_light_ce:.2f}%")
+print(f"Student accuracy with CE + KD: {test_accuracy_light_ce_and_kd:.2f}%")
+print(f"Student accuracy with CE + CosineLoss: {test_accuracy_light_ce_and_cosine_loss:.2f}%")
+print(f"Student accuracy with CE + RegressorMSE: {test_accuracy_light_ce_and_mse_loss:.2f}%")
+
+######################################################################
+# Conclusion
+# --------------------------------------------
+# None of the methods above increases the number of parameters for the network or inference time,
+# so the performance increase comes at the little cost of calculating gradients during training.
+# In ML applications, we mostly care about inference time because training happens before the model deployment.
+# If our lightweight model is still too heavy for deployment, we can apply different ideas, such as post-training quantization.
+# Additional losses can be applied in many tasks, not just classification, and you can experiment with quantities like coefficients,
+# temperature, or number of neurons. Feel free to tune any numbers in the tutorial above,
+# but keep in mind, if you change the number of neurons / filters chances are a shape mismatch might occur.
+#
+# For more information, see:
+#
+# * `Hinton, G., Vinyals, O., Dean, J.: Distilling the knowledge in a neural network. In: Neural Information Processing System Deep Learning Workshop (2015) <https://arxiv.org/abs/1503.02531>`_
+#
+# * `Romero, A., Ballas, N., Kahou, S.E., Chassang, A., Gatta, C., Bengio, Y.: Fitnets: Hints for thin deep nets. In: Proceedings of the International Conference on Learning Representations (2015) <https://arxiv.org/abs/1412.6550>`_
diff --git a/beginner_source/nlp/README.txt b/beginner_source/nlp/README.txt
index f690bcb9370..b2f7b19145e 100644
--- a/beginner_source/nlp/README.txt
+++ b/beginner_source/nlp/README.txt
@@ -1,6 +1,28 @@
 Deep Learning for NLP with Pytorch
 ----------------------------------
 
+These tutorials will walk you through the key ideas of deep learning
+programming using Pytorch. Many of the concepts (such as the computation
+graph abstraction and autograd) are not unique to Pytorch and are
+relevant to any deep learning toolkit out there.
+
+They are focused specifically on NLP for people who have never written
+code in any deep learning framework (e.g, TensorFlow,Theano, Keras, DyNet).
+The tutorials assumes working knowledge of core NLP problems: part-of-speech
+tagging, language modeling, etc. It also assumes familiarity with neural
+networks at the level of an intro AI class (such as one from the Russel and
+Norvig book). Usually, these courses cover the basic backpropagation algorithm
+on feed-forward neural networks, and make the point that they are chains of
+compositions of linearities and non-linearities. This tutorial aims to get
+you started writing deep learning code, given you have this prerequisite
+knowledge.
+
+Note these tutorials are about *models*, not data. For all of the models,
+a few test examples are created with small dimensionality so you can see how
+the weights change as it trains. If you have some real data you want to
+try, you should be able to rip out any of the models from this notebook
+and use them on it.
+
 1. pytorch_tutorial.py
 	Introduction to PyTorch
 	https://pytorch.org/tutorials/beginner/nlp/pytorch_tutorial.html
@@ -14,9 +36,9 @@ Deep Learning for NLP with Pytorch
 	https://pytorch.org/tutorials/beginner/nlp/word_embeddings_tutorial.html
 
 4. sequence_models_tutorial.py
-	Sequence Models and Long-Short Term Memory Networks
+	Sequence Models and Long Short-Term Memory Networks
 	https://pytorch.org/tutorials/beginner/nlp/sequence_models_tutorial.html
 
 5. advanced_tutorial.py
 	Advanced: Making Dynamic Decisions and the Bi-LSTM CRF
-	https://pytorch.org/tutorials/beginner/nlp/advanced_tutorial.html
\ No newline at end of file
+	https://pytorch.org/tutorials/beginner/nlp/advanced_tutorial.html
diff --git a/beginner_source/nlp/advanced_tutorial.py b/beginner_source/nlp/advanced_tutorial.py
index 0d03593f9cb..a6c6857128a 100644
--- a/beginner_source/nlp/advanced_tutorial.py
+++ b/beginner_source/nlp/advanced_tutorial.py
@@ -56,7 +56,7 @@
 above is typically sufficient for part-of-speech tagging, but a sequence
 model like the CRF is really essential for strong performance on NER.
 Familiarity with CRF's is assumed. Although this name sounds scary, all
-the model is is a CRF but where an LSTM provides the features. This is
+the model is a CRF but where an LSTM provides the features. This is
 an advanced model though, far more complicated than any earlier model in
 this tutorial. If you want to skip it, that is fine. To see if you're
 ready, see if you can:
diff --git a/beginner_source/nlp/pytorch_tutorial.py b/beginner_source/nlp/pytorch_tutorial.py
index 52fe953f21d..4dd966bc813 100644
--- a/beginner_source/nlp/pytorch_tutorial.py
+++ b/beginner_source/nlp/pytorch_tutorial.py
@@ -9,15 +9,11 @@
 All of deep learning is computations on tensors, which are
 generalizations of a matrix that can be indexed in more than 2
 dimensions. We will see exactly what this means in-depth later. First,
-lets look what we can do with tensors.
+let's look what we can do with tensors.
 """
 # Author: Robert Guthrie
 
 import torch
-import torch.autograd as autograd
-import torch.nn as nn
-import torch.nn.functional as F
-import torch.optim as optim
 
 torch.manual_seed(1)
 
@@ -26,7 +22,7 @@
 # Creating Tensors
 # ~~~~~~~~~~~~~~~~
 #
-# Tensors can be created from Python lists with the torch.Tensor()
+# Tensors can be created from Python lists with the torch.tensor()
 # function.
 #
 
@@ -56,7 +52,7 @@
 # A note on terminology:
 # when I say "tensor" in this tutorial, it refers
 # to any torch.Tensor object. Matrices and vectors are special cases of
-# torch.Tensors, where their dimension is 1 and 2 respectively. When I am
+# torch.Tensors, where their dimension is 2 and 1 respectively. When I am
 # talking about 3D tensors, I will explicitly use the term "3D tensor".
 #
 
@@ -73,9 +69,10 @@
 
 
 ######################################################################
-# You can also create tensors of other datatypes. The default, as you can
-# see, is Float. To create a tensor of integer types, try
-# torch.LongTensor(). Check the documentation for more data types, but
+# You can also create tensors of other data types. To create a tensor of integer types, try
+# torch.tensor([[1, 2], [3, 4]]) (where all elements in the list are integers).
+# You can also specify a data type by passing in ``dtype=torch.data_type``.
+# Check the documentation for more data types, but
 # Float and Long will be the most common.
 #
 
@@ -165,7 +162,7 @@
 # other operation, etc.)
 #
 # If ``requires_grad=True``, the Tensor object keeps track of how it was
-# created. Lets see it in action.
+# created. Let's see it in action.
 #
 
 # Tensor factory methods have a ``requires_grad`` flag
@@ -190,7 +187,7 @@
 # But how does that help us compute a gradient?
 #
 
-# Lets sum up all the entries in z
+# Let's sum up all the entries in z
 s = z.sum()
 print(s)
 print(s.grad_fn)
@@ -225,7 +222,7 @@
 
 
 ######################################################################
-# Lets have Pytorch compute the gradient, and see that we were right:
+# Let's have Pytorch compute the gradient, and see that we were right:
 # (note if you run this block multiple times, the gradient will increment.
 # That is because Pytorch *accumulates* the gradient into the .grad
 # property, since for many models this is very convenient.)
@@ -273,7 +270,7 @@
 
 ###############################################################
 # You can also stop autograd from tracking history on Tensors
-# with ``.requires_grad``=True by wrapping the code block in
+# with ``.requires_grad=True`` by wrapping the code block in
 # ``with torch.no_grad():``
 print(x.requires_grad)
 print((x ** 2).requires_grad)
diff --git a/beginner_source/nlp/sequence_models_tutorial.py b/beginner_source/nlp/sequence_models_tutorial.py
index 4db0361954d..eec811d67a1 100644
--- a/beginner_source/nlp/sequence_models_tutorial.py
+++ b/beginner_source/nlp/sequence_models_tutorial.py
@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 r"""
-Sequence Models and Long-Short Term Memory Networks
+Sequence Models and Long Short-Term Memory Networks
 ===================================================
 
 At this point, we have seen various feed-forward networks. That is,
@@ -13,7 +13,7 @@
 
 A recurrent neural network is a network that maintains some kind of
 state. For example, its output could be used as part of the next input,
-so that information can propogate along as the network passes over the
+so that information can propagate along as the network passes over the
 sequence. In the case of an LSTM, for each element in the sequence,
 there is a corresponding *hidden state* :math:`h_t`, which in principle
 can contain information from arbitrary points earlier in the sequence.
@@ -21,14 +21,14 @@
 part-of-speech tags, and a myriad of other things.
 
 
-LSTM's in Pytorch
+LSTMs in Pytorch
 ~~~~~~~~~~~~~~~~~
 
 Before getting to the example, note a few things. Pytorch's LSTM expects
 all of its inputs to be 3D tensors. The semantics of the axes of these
 tensors is important. The first axis is the sequence itself, the second
 indexes instances in the mini-batch, and the third indexes elements of
-the input. We haven't discussed mini-batching, so lets just ignore that
+the input. We haven't discussed mini-batching, so let's just ignore that
 and assume we will always have just 1 dimension on the second axis. If
 we want to run the sequence model over the sentence "The cow jumped",
 our input should look like
@@ -95,7 +95,9 @@
 # In this section, we will use an LSTM to get part of speech tags. We will
 # not use Viterbi or Forward-Backward or anything like that, but as a
 # (challenging) exercise to the reader, think about how Viterbi could be
-# used after you have seen what is going on.
+# used after you have seen what is going on. In this example, we also refer
+# to embeddings. If you are unfamiliar with embeddings, you can read up 
+# about them `here <https://pytorch.org/tutorials/beginner/nlp/word_embeddings_tutorial.html>`__.
 #
 # The model is as follows: let our input sentence be
 # :math:`w_1, \dots, w_M`, where :math:`w_i \in V`, our vocab. Also, let
@@ -127,16 +129,19 @@ def prepare_sequence(seq, to_ix):
 
 
 training_data = [
+    # Tags are: DET - determiner; NN - noun; V - verb
+    # For example, the word "The" is a determiner 
     ("The dog ate the apple".split(), ["DET", "NN", "V", "DET", "NN"]),
     ("Everybody read that book".split(), ["NN", "V", "DET", "NN"])
 ]
 word_to_ix = {}
+# For each words-list (sentence) and tags-list in each tuple of training_data
 for sent, tags in training_data:
     for word in sent:
-        if word not in word_to_ix:
-            word_to_ix[word] = len(word_to_ix)
+        if word not in word_to_ix:  # word has not been assigned an index yet
+            word_to_ix[word] = len(word_to_ix)  # Assign each word with a unique index
 print(word_to_ix)
-tag_to_ix = {"DET": 0, "NN": 1, "V": 2}
+tag_to_ix = {"DET": 0, "NN": 1, "V": 2}  # Assign each tag with a unique index
 
 # These will usually be more like 32 or 64 dimensional.
 # We will keep them small, so we can see how the weights change as we train.
diff --git a/beginner_source/nlp/word_embeddings_tutorial.py b/beginner_source/nlp/word_embeddings_tutorial.py
index 0b0f841935f..194b0a60f32 100644
--- a/beginner_source/nlp/word_embeddings_tutorial.py
+++ b/beginner_source/nlp/word_embeddings_tutorial.py
@@ -207,11 +207,17 @@
 This were to be new made when thou art old,
 And see thy blood warm when thou feel'st it cold.""".split()
 # we should tokenize the input, but we will ignore that for now
-# build a list of tuples.  Each tuple is ([ word_i-2, word_i-1 ], target word)
-trigrams = [([test_sentence[i], test_sentence[i + 1]], test_sentence[i + 2])
-            for i in range(len(test_sentence) - 2)]
-# print the first 3, just so you can see what they look like
-print(trigrams[:3])
+# build a list of tuples.
+# Each tuple is ([ word_i-CONTEXT_SIZE, ..., word_i-1 ], target word)
+ngrams = [
+    (
+        [test_sentence[i - j - 1] for j in range(CONTEXT_SIZE)],
+        test_sentence[i]
+    )
+    for i in range(CONTEXT_SIZE, len(test_sentence))
+]
+# Print the first 3, just so you can see what they look like.
+print(ngrams[:3])
 
 vocab = set(test_sentence)
 word_to_ix = {word: i for i, word in enumerate(vocab)}
@@ -240,7 +246,7 @@ def forward(self, inputs):
 
 for epoch in range(10):
     total_loss = 0
-    for context, target in trigrams:
+    for context, target in ngrams:
 
         # Step 1. Prepare the inputs to be passed to the model (i.e, turn the words
         # into integer indices and wrap them in tensors)
@@ -268,6 +274,8 @@ def forward(self, inputs):
     losses.append(total_loss)
 print(losses)  # The loss decreased every iteration over the training data!
 
+# To get the embedding of a particular word, e.g. "beauty"
+print(model.embeddings.weight[word_to_ix["beauty"]])
 
 ######################################################################
 # Exercise: Computing Word Embeddings: Continuous Bag-of-Words
@@ -277,7 +285,7 @@ def forward(self, inputs):
 # learning. It is a model that tries to predict words given the context of
 # a few words before and a few words after the target word. This is
 # distinct from language modeling, since CBOW is not sequential and does
-# not have to be probabilistic. Typcially, CBOW is used to quickly train
+# not have to be probabilistic. Typically, CBOW is used to quickly train
 # word embeddings, and these embeddings are used to initialize the
 # embeddings of some more complicated model. Usually, this is referred to
 # as *pretraining embeddings*. It almost always helps performance a couple
@@ -288,7 +296,7 @@ def forward(self, inputs):
 # and :math:`w_{i+1}, \dots, w_{i+N}`, referring to all context words
 # collectively as :math:`C`, CBOW tries to minimize
 #
-# .. math::  -\log p(w_i | C) = -\log \text{Softmax}(A(\sum_{w \in C} q_w) + b)
+# .. math::  -\log p(w_i | C) = -\log \text{Softmax}\left(A(\sum_{w \in C} q_w) + b\right)
 #
 # where :math:`q_w` is the embedding for word :math:`w`.
 #
@@ -314,9 +322,11 @@ def forward(self, inputs):
 
 word_to_ix = {word: i for i, word in enumerate(vocab)}
 data = []
-for i in range(2, len(raw_text) - 2):
-    context = [raw_text[i - 2], raw_text[i - 1],
-               raw_text[i + 1], raw_text[i + 2]]
+for i in range(CONTEXT_SIZE, len(raw_text) - CONTEXT_SIZE):
+    context = (
+        [raw_text[i - j - 1] for j in range(CONTEXT_SIZE)]
+        + [raw_text[i + j + 1] for j in range(CONTEXT_SIZE)]
+    )
     target = raw_text[i]
     data.append((context, target))
 print(data[:5])
@@ -330,8 +340,8 @@ def __init__(self):
     def forward(self, inputs):
         pass
 
-# create your model and train.  here are some functions to help you make
-# the data ready for use by your module
+# Create your model and train. Here are some functions to help you make
+# the data ready for use by your module.
 
 
 def make_context_vector(context, word_to_ix):
diff --git a/beginner_source/nn_tutorial.py b/beginner_source/nn_tutorial.py
index 5f915a3d3ea..e04815bd27e 100644
--- a/beginner_source/nn_tutorial.py
+++ b/beginner_source/nn_tutorial.py
@@ -2,10 +2,12 @@
 """
 What is `torch.nn` *really*?
 ============================
-by Jeremy Howard, `fast.ai <https://www.fast.ai>`_. Thanks to Rachel Thomas and Francisco Ingham.
+
+**Authors:** Jeremy Howard, `fast.ai <https://www.fast.ai>`_. Thanks to Rachel Thomas and Francisco Ingham.
 """
+
 ###############################################################################
-# We recommend running this tutorial as a notebook, not a script. To download the notebook (.ipynb) file,
+# We recommend running this tutorial as a notebook, not a script. To download the notebook (``.ipynb``) file,
 # click the link at the top of the page.
 #
 # PyTorch provides the elegantly designed modules and classes `torch.nn <https://pytorch.org/docs/stable/nn.html>`_ ,
@@ -29,7 +31,7 @@
 # MNIST data setup
 # ----------------
 #
-# We will use the classic `MNIST <http://deeplearning.net/data/mnist/>`_ dataset,
+# We will use the classic `MNIST <https://yann.lecun.com/exdb/mnist/index.html>`_ dataset,
 # which consists of black-and-white images of hand-drawn digits (between 0 and 9).
 #
 # We will use `pathlib <https://docs.python.org/3/library/pathlib.html>`_
@@ -47,7 +49,7 @@
 
 PATH.mkdir(parents=True, exist_ok=True)
 
-URL = "http://deeplearning.net/data/mnist/"
+URL = "https://github.com/pytorch/tutorials/raw/main/_static/"
 FILENAME = "mnist.pkl.gz"
 
 if not (PATH / FILENAME).exists():
@@ -73,6 +75,11 @@
 import numpy as np
 
 pyplot.imshow(x_train[0].reshape((28, 28)), cmap="gray")
+# ``pyplot.show()`` only if not on Colab
+try:
+    import google.colab
+except ImportError:
+    pyplot.show()
 print(x_train.shape)
 
 ###############################################################################
@@ -85,14 +92,13 @@
     torch.tensor, (x_train, y_train, x_valid, y_valid)
 )
 n, c = x_train.shape
-x_train, x_train.shape, y_train.min(), y_train.max()
 print(x_train, y_train)
 print(x_train.shape)
 print(y_train.min(), y_train.max())
 
 ###############################################################################
-# Neural net from scratch (no torch.nn)
-# ---------------------------------------------
+# Neural net from scratch (without ``torch.nn``)
+# -----------------------------------------------
 #
 # Let's first create a model using nothing but PyTorch tensor operations. We're assuming
 # you're already familiar with the basics of neural networks. (If you're not, you can
@@ -105,12 +111,12 @@
 # so that it can calculate the gradient during back-propagation *automatically*!
 #
 # For the weights, we set ``requires_grad`` **after** the initialization, since we
-# don't want that step included in the gradient. (Note that a trailling ``_`` in
+# don't want that step included in the gradient. (Note that a trailing ``_`` in
 # PyTorch signifies that the operation is performed in-place.)
 #
 # .. note:: We are initializing the weights here with
 #    `Xavier initialisation <http://proceedings.mlr.press/v9/glorot10a/glorot10a.pdf>`_
-#    (by multiplying with 1/sqrt(n)).
+#    (by multiplying with ``1/sqrt(n)``).
 
 import math
 
@@ -124,9 +130,9 @@
 # let's just write a plain matrix multiplication and broadcasted addition
 # to create a simple linear model. We also need an activation function, so
 # we'll write `log_softmax` and use it. Remember: although PyTorch
-# provides lots of pre-written loss functions, activation functions, and
+# provides lots of prewritten loss functions, activation functions, and
 # so forth, you can easily write your own using plain python. PyTorch will
-# even create fast GPU or vectorized CPU code for your function
+# even create fast accelerator or vectorized CPU code for your function
 # automatically.
 
 def log_softmax(x):
@@ -135,8 +141,8 @@ def log_softmax(x):
 def model(xb):
     return log_softmax(xb @ weights + bias)
 
-###############################################################################
-# In the above, the ``@`` stands for the dot product operation. We will call
+######################################################################################
+# In the above, the ``@`` stands for the matrix multiplication operation. We will call
 # our function on one batch of data (in this case, 64 images).  This is
 # one *forward pass*.  Note that our predictions won't be any better than
 # random at this stage, since we start with random weights.
@@ -243,7 +249,7 @@ def accuracy(out, yb):
 print(loss_func(model(xb), yb), accuracy(model(xb), yb))
 
 ###############################################################################
-# Using torch.nn.functional
+# Using ``torch.nn.functional``
 # ------------------------------
 #
 # We will now refactor our code, so that it does the same thing as before, only
@@ -279,7 +285,7 @@ def model(xb):
 print(loss_func(model(xb), yb), accuracy(model(xb), yb))
 
 ###############################################################################
-# Refactor using nn.Module
+# Refactor using ``nn.Module``
 # -----------------------------
 # Next up, we'll use ``nn.Module`` and ``nn.Parameter``, for a clearer and more
 # concise training loop. We subclass ``nn.Module`` (which itself is a class and
@@ -321,22 +327,26 @@ def forward(self, xb):
 ###############################################################################
 # Previously for our training loop we had to update the values for each parameter
 # by name, and manually zero out the grads for each parameter separately, like this:
-# ::
-#   with torch.no_grad():
-#       weights -= weights.grad * lr
-#       bias -= bias.grad * lr
-#       weights.grad.zero_()
-#       bias.grad.zero_()
+#
+# .. code-block:: python
+#
+#    with torch.no_grad():
+#        weights -= weights.grad * lr
+#        bias -= bias.grad * lr
+#        weights.grad.zero_()
+#        bias.grad.zero_()
 #
 #
 # Now we can take advantage of model.parameters() and model.zero_grad() (which
 # are both defined by PyTorch for ``nn.Module``) to make those steps more concise
 # and less prone to the error of forgetting some of our parameters, particularly
 # if we had a more complicated model:
-# ::
-#   with torch.no_grad():
-#       for p in model.parameters(): p -= p.grad * lr
-#       model.zero_grad()
+#
+# .. code-block:: python
+#
+#    with torch.no_grad():
+#        for p in model.parameters(): p -= p.grad * lr
+#        model.zero_grad()
 #
 #
 # We'll wrap our little training loop in a ``fit`` function so we can run it
@@ -366,8 +376,8 @@ def fit():
 print(loss_func(model(xb), yb))
 
 ###############################################################################
-# Refactor using nn.Linear
-# -------------------------
+# Refactor using ``nn.Linear``
+# ----------------------------
 #
 # We continue to refactor our code.  Instead of manually defining and
 # initializing ``self.weights`` and ``self.bias``, and calculating ``xb  @
@@ -399,7 +409,7 @@ def forward(self, xb):
 print(loss_func(model(xb), yb))
 
 ###############################################################################
-# Refactor using optim
+# Refactor using ``torch.optim``
 # ------------------------------
 #
 # Pytorch also has a package with various optimization algorithms, ``torch.optim``.
@@ -407,15 +417,19 @@ def forward(self, xb):
 # of manually updating each parameter.
 #
 # This will let us replace our previous manually coded optimization step:
-# ::
-#   with torch.no_grad():
-#       for p in model.parameters(): p -= p.grad * lr
-#       model.zero_grad()
+#
+# .. code-block:: python
+#
+#    with torch.no_grad():
+#        for p in model.parameters(): p -= p.grad * lr
+#        model.zero_grad()
 #
 # and instead use just:
-# ::
-#   opt.step()
-#   opt.zero_grad()
+#
+# .. code-block:: python
+#
+#    opt.step()
+#    opt.zero_grad()
 #
 # (``optim.zero_grad()`` resets the gradient to 0 and we need to call it before
 # computing the gradient for the next minibatch.)
@@ -474,15 +488,19 @@ def get_model():
 train_ds = TensorDataset(x_train, y_train)
 
 ###############################################################################
-# Previously, we had to iterate through minibatches of x and y values separately:
-# ::
-#     xb = x_train[start_i:end_i]
-#     yb = y_train[start_i:end_i]
+# Previously, we had to iterate through minibatches of ``x`` and ``y`` values separately:
+#
+# .. code-block:: python
+#
+#    xb = x_train[start_i:end_i]
+#    yb = y_train[start_i:end_i]
 #
 #
 # Now, we can do these two steps together:
-# ::
-#     xb,yb = train_ds[i*bs : i*bs+bs]
+#
+# .. code-block:: python
+#
+#    xb,yb = train_ds[i*bs : i*bs+bs]
 #
 
 model, opt = get_model()
@@ -500,13 +518,13 @@ def get_model():
 print(loss_func(model(xb), yb))
 
 ###############################################################################
-# Refactor using DataLoader
+# Refactor using ``DataLoader``
 # ------------------------------
 #
-# Pytorch's ``DataLoader`` is responsible for managing batches. You can
+# PyTorch's ``DataLoader`` is responsible for managing batches. You can
 # create a ``DataLoader`` from any ``Dataset``. ``DataLoader`` makes it easier
 # to iterate over batches. Rather than having to use ``train_ds[i*bs : i*bs+bs]``,
-# the DataLoader gives us each minibatch automatically.
+# the ``DataLoader`` gives us each minibatch automatically.
 
 from torch.utils.data import DataLoader
 
@@ -514,16 +532,20 @@ def get_model():
 train_dl = DataLoader(train_ds, batch_size=bs)
 
 ###############################################################################
-# Previously, our loop iterated over batches (xb, yb) like this:
-# ::
-#       for i in range((n-1)//bs + 1):
-#           xb,yb = train_ds[i*bs : i*bs+bs]
-#           pred = model(xb)
+# Previously, our loop iterated over batches ``(xb, yb)`` like this:
+#
+# .. code-block:: python
 #
-# Now, our loop is much cleaner, as (xb, yb) are loaded automatically from the data loader:
-# ::
-#       for xb,yb in train_dl:
-#           pred = model(xb)
+#    for i in range((n-1)//bs + 1):
+#        xb,yb = train_ds[i*bs : i*bs+bs]
+#        pred = model(xb)
+#
+# Now, our loop is much cleaner, as ``(xb, yb)`` are loaded automatically from the data loader:
+#
+# .. code-block:: python
+#
+#    for xb,yb in train_dl:
+#        pred = model(xb)
 
 model, opt = get_model()
 
@@ -539,9 +561,9 @@ def get_model():
 print(loss_func(model(xb), yb))
 
 ###############################################################################
-# Thanks to Pytorch's ``nn.Module``, ``nn.Parameter``, ``Dataset``, and ``DataLoader``,
+# Thanks to PyTorch's ``nn.Module``, ``nn.Parameter``, ``Dataset``, and ``DataLoader``,
 # our training loop is now dramatically smaller and easier to understand. Let's
-# now try to add the basic features necessary to create effecive models in practice.
+# now try to add the basic features necessary to create effective models in practice.
 #
 # Add validation
 # -----------------------
@@ -574,7 +596,7 @@ def get_model():
 #
 # (Note that we always call ``model.train()`` before training, and ``model.eval()``
 # before inference, because these are used by layers such as ``nn.BatchNorm2d``
-# and ``nn.Dropout`` to ensure appropriate behaviour for these different phases.)
+# and ``nn.Dropout`` to ensure appropriate behavior for these different phases.)
 
 model, opt = get_model()
 
@@ -668,11 +690,11 @@ def get_data(train_ds, valid_ds, bs):
 # Because none of the functions in the previous section assume anything about
 # the model form, we'll be able to use them to train a CNN without any modification.
 #
-# We will use Pytorch's predefined
+# We will use PyTorch's predefined
 # `Conv2d <https://pytorch.org/docs/stable/nn.html#torch.nn.Conv2d>`_ class
 # as our convolutional layer. We define a CNN with 3 convolutional layers.
 # Each convolution is followed by a ReLU.  At the end, we perform an
-# average pooling.  (Note that ``view`` is PyTorch's version of numpy's
+# average pooling.  (Note that ``view`` is PyTorch's version of Numpy's
 # ``reshape``)
 
 class Mnist_CNN(nn.Module):
@@ -703,10 +725,10 @@ def forward(self, xb):
 fit(epochs, model, loss_func, opt, train_dl, valid_dl)
 
 ###############################################################################
-# nn.Sequential
+# Using ``nn.Sequential``
 # ------------------------
 #
-# ``torch.nn`` has another handy class we can use to simply our code:
+# ``torch.nn`` has another handy class we can use to simplify our code:
 # `Sequential <https://pytorch.org/docs/stable/nn.html#torch.nn.Sequential>`_ .
 # A ``Sequential`` object runs each of the modules contained within it, in a
 # sequential manner. This is a simpler way of writing our neural network.
@@ -730,7 +752,7 @@ def preprocess(x):
     return x.view(-1, 1, 28, 28)
 
 ###############################################################################
-# The model created with ``Sequential`` is simply:
+# The model created with ``Sequential`` is simple:
 
 model = nn.Sequential(
     Lambda(preprocess),
@@ -749,16 +771,15 @@ def preprocess(x):
 fit(epochs, model, loss_func, opt, train_dl, valid_dl)
 
 ###############################################################################
-# Wrapping DataLoader
+# Wrapping ``DataLoader``
 # -----------------------------
 #
 # Our CNN is fairly concise, but it only works with MNIST, because:
 #  - It assumes the input is a 28\*28 long vector
-#  - It assumes that the final CNN grid size is 4\*4 (since that's the average
-# pooling kernel size we used)
+#  - It assumes that the final CNN grid size is 4\*4 (since that's the average pooling kernel size we used)
 #
 # Let's get rid of these two assumptions, so our model works with any 2d
-# single channel image. First, we can remove the initial Lambda layer but
+# single channel image. First, we can remove the initial Lambda layer by
 # moving the data preprocessing into a generator:
 
 def preprocess(x, y):
@@ -774,8 +795,7 @@ def __len__(self):
         return len(self.dl)
 
     def __iter__(self):
-        batches = iter(self.dl)
-        for b in batches:
+        for b in self.dl:
             yield (self.func(*b))
 
 train_dl, valid_dl = get_data(train_ds, valid_ds, bs)
@@ -807,28 +827,25 @@ def __iter__(self):
 fit(epochs, model, loss_func, opt, train_dl, valid_dl)
 
 ###############################################################################
-# Using your GPU
+# Using your `Accelerator <https://pytorch.org/docs/stable/torch.html#accelerators>`__
 # ---------------
 #
-# If you're lucky enough to have access to a CUDA-capable GPU (you can
+# If you're lucky enough to have access to an accelerator such as CUDA (you can
 # rent one for about $0.50/hour from most cloud providers) you can
-# use it to speed up your code. First check that your GPU is working in
+# use it to speed up your code. First check that your accelerator is working in
 # Pytorch:
 
-print(torch.cuda.is_available())
-
-###############################################################################
-# And then create a device object for it:
+# If the current accelerator is available, we will use it. Otherwise, we use the CPU.
+device = torch.accelerator.current_accelerator().type if torch.accelerator.is_available() else "cpu"
+print(f"Using {device} device")
 
-dev = torch.device(
-    "cuda") if torch.cuda.is_available() else torch.device("cpu")
 
 ###############################################################################
-# Let's update ``preprocess`` to move batches to the GPU:
+# Let's update ``preprocess`` to move batches to the accelerator:
 
 
 def preprocess(x, y):
-    return x.view(-1, 1, 28, 28).to(dev), y.to(dev)
+    return x.view(-1, 1, 28, 28).to(device), y.to(device)
 
 
 train_dl, valid_dl = get_data(train_ds, valid_ds, bs)
@@ -836,9 +853,9 @@ def preprocess(x, y):
 valid_dl = WrappedDataLoader(valid_dl, preprocess)
 
 ###############################################################################
-# Finally, we can move our model to the GPU.
+# Finally, we can move our model to the accelerator.
 
-model.to(dev)
+model.to(device)
 opt = optim.SGD(model.parameters(), lr=lr, momentum=0.9)
 
 ###############################################################################
@@ -852,7 +869,7 @@ def preprocess(x, y):
 #
 # We now have a general data pipeline and training loop which you can use for
 # training many types of models using Pytorch. To see how simple training a model
-# can now be, take a look at the `mnist_sample` sample notebook.
+# can now be, take a look at the `mnist_sample notebook <https://github.com/fastai/fastai_dev/blob/master/dev_nb/mnist_sample.ipynb>`__.
 #
 # Of course, there are many things you'll want to add, such as data augmentation,
 # hyperparameter tuning, monitoring training, transfer learning, and so forth.
@@ -864,7 +881,7 @@ def preprocess(x, y):
 # ``torch.nn``, ``torch.optim``, ``Dataset``, and ``DataLoader``. So let's summarize
 # what we've seen:
 #
-#  - **torch.nn**
+#  - ``torch.nn``:
 #
 #    + ``Module``: creates a callable which behaves like a function, but can also
 #      contain state(such as neural net layer weights). It knows what ``Parameter`` (s) it
diff --git a/beginner_source/onnx/README.txt b/beginner_source/onnx/README.txt
new file mode 100644
index 00000000000..96004a239ea
--- /dev/null
+++ b/beginner_source/onnx/README.txt
@@ -0,0 +1,18 @@
+ONNX
+----
+
+1. intro_onnx.py
+    Introduction to ONNX
+    https://pytorch.org/tutorials/beginner/onnx/intro_onnx.html
+
+2. export_simple_model_to_onnx_tutorial.py
+    Exporting a PyTorch model to ONNX
+    https://pytorch.org/tutorials/beginner/onnx/export_simple_model_to_onnx_tutorial.html
+
+3. onnx_registry_tutorial.py
+    Extending the ONNX exporter operator support
+    https://pytorch.org/tutorials/beginner/onnx/onnx_registry_tutorial.html
+
+4. export_control_flow_model_to_onnx_tutorial.py
+    Export a model with control flow to ONNX
+    https://pytorch.org/tutorials/beginner/onnx/export_control_flow_model_to_onnx_tutorial.html
\ No newline at end of file
diff --git a/beginner_source/onnx/export_control_flow_model_to_onnx_tutorial.py b/beginner_source/onnx/export_control_flow_model_to_onnx_tutorial.py
new file mode 100644
index 00000000000..c8057727132
--- /dev/null
+++ b/beginner_source/onnx/export_control_flow_model_to_onnx_tutorial.py
@@ -0,0 +1,172 @@
+# -*- coding: utf-8 -*-
+"""
+`Introduction to ONNX <intro_onnx.html>`_ ||
+`Exporting a PyTorch model to ONNX <export_simple_model_to_onnx_tutorial.html>`_ ||
+`Extending the ONNX exporter operator support <onnx_registry_tutorial.html>`_ ||
+**`Export a model with control flow to ONNX**
+
+Export a model with control flow to ONNX
+========================================
+
+**Author**: `Xavier Dupré <https://github.com/xadupre>`_
+"""
+
+
+###############################################################################
+# Overview
+# --------
+# 
+# This tutorial demonstrates how to handle control flow logic while exporting
+# a PyTorch model to ONNX. It highlights the challenges of exporting
+# conditional statements directly and provides solutions to circumvent them.
+#
+# Conditional logic cannot be exported into ONNX unless they refactored
+# to use :func:`torch.cond`. Let's start with a simple model
+# implementing a test.
+# 
+# What you will learn:
+#
+# - How to refactor the model to use :func:`torch.cond` for exporting.
+# - How to export a model with control flow logic to ONNX.
+# - How to optimize the exported model using the ONNX optimizer.
+#
+# Prerequisites
+# ~~~~~~~~~~~~~
+#
+# * ``torch >= 2.6``
+
+
+import torch
+
+###############################################################################
+# Define the Models
+# -----------------
+#
+# Two models are defined:
+#
+# ``ForwardWithControlFlowTest``: A model with a forward method containing an
+# if-else conditional.
+#
+# ``ModelWithControlFlowTest``: A model that incorporates ``ForwardWithControlFlowTest``
+# as part of a simple MLP. The models are tested with
+# a random input tensor to confirm they execute as expected.
+
+class ForwardWithControlFlowTest(torch.nn.Module):
+    def forward(self, x):
+        if x.sum():
+            return x * 2
+        return -x
+
+
+class ModelWithControlFlowTest(torch.nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.mlp = torch.nn.Sequential(
+            torch.nn.Linear(3, 2),
+            torch.nn.Linear(2, 1),
+            ForwardWithControlFlowTest(),
+        )
+
+    def forward(self, x):
+        out = self.mlp(x)
+        return out
+
+
+model = ModelWithControlFlowTest()
+
+
+###############################################################################
+# Exporting the Model: First Attempt
+# ----------------------------------
+#
+# Exporting this model using torch.export.export fails because the control
+# flow logic in the forward pass creates a graph break that the exporter cannot
+# handle. This behavior is expected, as conditional logic not written using
+# :func:`torch.cond` is unsupported.
+# 
+# A try-except block is used to capture the expected failure during the export
+# process. If the export unexpectedly succeeds, an ``AssertionError`` is raised.
+
+x = torch.randn(3)
+model(x)
+
+try:
+    torch.export.export(model, (x,), strict=False)
+    raise AssertionError("This export should failed unless PyTorch now supports this model.")
+except Exception as e:
+    print(e)
+
+
+###############################################################################
+# Suggested Patch: Refactoring with :func:`torch.cond`
+# --------------------------------------------
+#
+# To make the control flow exportable, the tutorial demonstrates replacing the
+# forward method in ``ForwardWithControlFlowTest`` with a refactored version that
+# uses :func:`torch.cond``.
+#
+# Details of the Refactoring:
+#
+# Two helper functions (identity2 and neg) represent the branches of the conditional logic:
+# * :func:`torch.cond`` is used to specify the condition and the two branches along with the input arguments.
+# * The updated forward method is then dynamically assigned to the ``ForwardWithControlFlowTest`` instance within the model. A list of submodules is printed to confirm the replacement.
+
+def new_forward(x):
+    def identity2(x):
+        return x * 2
+
+    def neg(x):
+        return -x
+
+    return torch.cond(x.sum() > 0, identity2, neg, (x,))
+
+
+print("the list of submodules")
+for name, mod in model.named_modules():
+    print(name, type(mod))
+    if isinstance(mod, ForwardWithControlFlowTest):
+        mod.forward = new_forward
+
+###############################################################################
+# Let's see what the FX graph looks like.
+
+print(torch.export.export(model, (x,), strict=False))  
+
+###############################################################################
+# Let's export again.
+
+onnx_program = torch.onnx.export(model, (x,), dynamo=True)  
+print(onnx_program.model) 
+
+
+###############################################################################
+# We can optimize the model and get rid of the model local functions created to capture the control flow branches.  
+
+onnx_program.optimize()  
+print(onnx_program.model)  
+
+###############################################################################
+# Conclusion
+# ----------
+#
+# This tutorial demonstrates the challenges of exporting models with conditional
+# logic to ONNX and presents a practical solution using :func:`torch.cond`.
+# While the default exporters may fail or produce imperfect graphs, refactoring the
+# model's logic ensures compatibility and generates a faithful ONNX representation.
+#
+# By understanding these techniques, we can overcome common pitfalls when
+# working with control flow in PyTorch models and ensure smooth integration with ONNX workflows.
+#
+# Further reading
+# ---------------
+#
+# The list below refers to tutorials that ranges from basic examples to advanced scenarios,
+# not necessarily in the order they are listed.
+# Feel free to jump directly to specific topics of your interest or
+# sit tight and have fun going through all of them to learn all there is about the ONNX exporter.
+#
+# .. include:: /beginner_source/onnx/onnx_toc.txt
+#
+# .. toctree::
+#    :hidden:
+#
diff --git a/beginner_source/onnx/export_simple_model_to_onnx_tutorial.py b/beginner_source/onnx/export_simple_model_to_onnx_tutorial.py
new file mode 100644
index 00000000000..8948cbaa2c1
--- /dev/null
+++ b/beginner_source/onnx/export_simple_model_to_onnx_tutorial.py
@@ -0,0 +1,212 @@
+# -*- coding: utf-8 -*-
+"""
+`Introduction to ONNX <intro_onnx.html>`_ ||
+**Exporting a PyTorch model to ONNX** ||
+`Extending the ONNX exporter operator support <onnx_registry_tutorial.html>`_ ||
+`Export a model with control flow to ONNX <export_control_flow_model_to_onnx_tutorial.html>`_
+
+Export a PyTorch model to ONNX
+==============================
+
+**Author**: `Ti-Tai Wang <https://github.com/titaiwangms>`_, `Justin Chu <justinchu@microsoft.com>`_, `Thiago Crepaldi <https://github.com/thiagocrepaldi>`_.
+
+.. note::
+    Starting with PyTorch 2.5, there are two ONNX Exporter options available.
+    * ``torch.onnx.export(..., dynamo=True)`` is the recommended exporter that leverages ``torch.export`` and Torch FX for graph capture.
+    * ``torch.onnx.export`` is the legacy approach that relies on the deprecated TorchScript and is no longer recommended for use.
+
+"""
+
+###############################################################################
+# In the `60 Minute Blitz <https://pytorch.org/tutorials/beginner/deep_learning_60min_blitz.html>`_,
+# we had the opportunity to learn about PyTorch at a high level and train a small neural network to classify images.
+# In this tutorial, we are going to expand this to describe how to convert a model defined in PyTorch into the
+# ONNX format using the ``torch.onnx.export(..., dynamo=True)`` ONNX exporter.
+#
+# While PyTorch is great for iterating on the development of models, the model can be deployed to production
+# using different formats, including `ONNX <https://onnx.ai/>`_ (Open Neural Network Exchange)!
+#
+# ONNX is a flexible open standard format for representing machine learning models which standardized representations
+# of machine learning allow them to be executed across a gamut of hardware platforms and runtime environments
+# from large-scale cloud-based supercomputers to resource-constrained edge devices, such as your web browser and phone.
+#
+# In this tutorial, we’ll learn how to:
+#
+# 1. Install the required dependencies.
+# 2. Author a simple image classifier model.
+# 3. Export the model to ONNX format.
+# 4. Save the ONNX model in a file.
+# 5. Visualize the ONNX model graph using `Netron <https://github.com/lutzroeder/netron>`_.
+# 6. Execute the ONNX model with `ONNX Runtime`
+# 7. Compare the PyTorch results with the ones from the ONNX Runtime.
+#
+# 1. Install the required dependencies
+# ------------------------------------
+# Because the ONNX exporter uses ``onnx`` and ``onnxscript`` to translate PyTorch operators into ONNX operators,
+# we will need to install them.
+#
+#  .. code-block:: bash
+#
+#   pip install --upgrade onnx onnxscript
+#
+# 2. Author a simple image classifier model
+# -----------------------------------------
+#
+# Once your environment is set up, let’s start modeling our image classifier with PyTorch,
+# exactly like we did in the `60 Minute Blitz <https://pytorch.org/tutorials/beginner/deep_learning_60min_blitz.html>`_.
+#
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class ImageClassifierModel(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.conv1 = nn.Conv2d(1, 6, 5)
+        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: torch.Tensor):
+        x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
+        x = F.max_pool2d(F.relu(self.conv2(x)), 2)
+        x = torch.flatten(x, 1)
+        x = F.relu(self.fc1(x))
+        x = F.relu(self.fc2(x))
+        x = self.fc3(x)
+        return x
+
+
+######################################################################
+# 3. Export the model to ONNX format
+# ----------------------------------
+#
+# Now that we have our model defined, we need to instantiate it and create a random 32x32 input.
+# Next, we can export the model to ONNX format.
+
+torch_model = ImageClassifierModel()
+# Create example inputs for exporting the model. The inputs should be a tuple of tensors.
+example_inputs = (torch.randn(1, 1, 32, 32),)
+onnx_program = torch.onnx.export(torch_model, example_inputs, dynamo=True)
+
+######################################################################
+# As we can see, we didn't need any code change to the model.
+# The resulting ONNX model is stored within ``torch.onnx.ONNXProgram`` as a binary protobuf file.
+#
+# 4. Save the ONNX model in a file
+# --------------------------------
+#
+# Although having the exported model loaded in memory is useful in many applications,
+# we can save it to disk with the following code:
+
+onnx_program.save("image_classifier_model.onnx")
+
+######################################################################
+# You can load the ONNX file back into memory and check if it is well formed with the following code:
+
+import onnx
+
+onnx_model = onnx.load("image_classifier_model.onnx")
+onnx.checker.check_model(onnx_model)
+
+######################################################################
+# 5. Visualize the ONNX model graph using Netron
+# ----------------------------------------------
+#
+# Now that we have our model saved in a file, we can visualize it with `Netron <https://github.com/lutzroeder/netron>`_.
+# Netron can either be installed on macos, Linux or Windows computers, or run directly from the browser.
+# Let's try the web version by opening the following link: https://netron.app/.
+#
+# .. image:: ../../_static/img/onnx/netron_web_ui.png
+#   :width: 70%
+#   :align: center
+#
+#
+# Once Netron is open, we can drag and drop our ``image_classifier_model.onnx`` file into the browser or select it after
+# clicking the **Open model** button.
+#
+# .. image:: ../../_static/img/onnx/image_classifier_onnx_model_on_netron_web_ui.png
+#   :width: 50%
+#
+#
+# And that is it! We have successfully exported our PyTorch model to ONNX format and visualized it with Netron.
+#
+# 6. Execute the ONNX model with ONNX Runtime
+# -------------------------------------------
+#
+# The last step is executing the ONNX model with `ONNX Runtime`, but before we do that, let's install ONNX Runtime.
+#
+#  .. code-block:: bash
+#
+#   pip install onnxruntime
+#
+# The ONNX standard does not support all the data structure and types that PyTorch does,
+# so we need to adapt PyTorch input's to ONNX format before feeding it to ONNX Runtime.
+# In our example, the input happens to be the same, but it might have more inputs
+# than the original PyTorch model in more complex models.
+#
+# ONNX Runtime requires an additional step that involves converting all PyTorch tensors to Numpy (in CPU)
+# and wrap them on a dictionary with keys being a string with the input name as key and the numpy tensor as the value.
+#
+# Now we can create an *ONNX Runtime Inference Session*, execute the ONNX model with the processed input
+# and get the output. In this tutorial, ONNX Runtime is executed on CPU, but it could be executed on GPU as well.
+
+import onnxruntime
+
+onnx_inputs = [tensor.numpy(force=True) for tensor in example_inputs]
+print(f"Input length: {len(onnx_inputs)}")
+print(f"Sample input: {onnx_inputs}")
+
+ort_session = onnxruntime.InferenceSession(
+    "./image_classifier_model.onnx", providers=["CPUExecutionProvider"]
+)
+
+onnxruntime_input = {input_arg.name: input_value for input_arg, input_value in zip(ort_session.get_inputs(), onnx_inputs)}
+
+# ONNX Runtime returns a list of outputs
+onnxruntime_outputs = ort_session.run(None, onnxruntime_input)[0]
+
+####################################################################
+# 7. Compare the PyTorch results with the ones from the ONNX Runtime
+# ------------------------------------------------------------------
+#
+# The best way to determine whether the exported model is looking good is through numerical evaluation
+# against PyTorch, which is our source of truth.
+#
+# For that, we need to execute the PyTorch model with the same input and compare the results with ONNX Runtime's.
+# Before comparing the results, we need to convert the PyTorch's output to match ONNX's format.
+
+torch_outputs = torch_model(*example_inputs)
+
+assert len(torch_outputs) == len(onnxruntime_outputs)
+for torch_output, onnxruntime_output in zip(torch_outputs, onnxruntime_outputs):
+    torch.testing.assert_close(torch_output, torch.tensor(onnxruntime_output))
+
+print("PyTorch and ONNX Runtime output matched!")
+print(f"Output length: {len(onnxruntime_outputs)}")
+print(f"Sample output: {onnxruntime_outputs}")
+
+######################################################################
+# Conclusion
+# ----------
+#
+# That is about it! We have successfully exported our PyTorch model to ONNX format,
+# saved the model to disk, viewed it using Netron, executed it with ONNX Runtime
+# and finally compared its numerical results with PyTorch's.
+#
+# Further reading
+# ---------------
+#
+# The list below refers to tutorials that ranges from basic examples to advanced scenarios,
+# not necessarily in the order they are listed.
+# Feel free to jump directly to specific topics of your interest or
+# sit tight and have fun going through all of them to learn all there is about the ONNX exporter.
+#
+# .. include:: /beginner_source/onnx/onnx_toc.txt
+#
+# .. toctree::
+#    :hidden:
+#
diff --git a/beginner_source/onnx/intro_onnx.py b/beginner_source/onnx/intro_onnx.py
new file mode 100644
index 00000000000..ecb0be97bf2
--- /dev/null
+++ b/beginner_source/onnx/intro_onnx.py
@@ -0,0 +1,73 @@
+"""
+**Introduction to ONNX** ||
+`Exporting a PyTorch model to ONNX <export_simple_model_to_onnx_tutorial.html>`_ ||
+`Extending the ONNX exporter operator support <onnx_registry_tutorial.html>`_ ||
+`Export a model with control flow to ONNX <export_control_flow_model_to_onnx_tutorial.html>`_
+
+Introduction to ONNX
+====================
+
+Authors:
+`Ti-Tai Wang <https://github.com/titaiwangms>`_, `Thiago Crepaldi <https://github.com/thiagocrepaldi>`_.
+
+`Open Neural Network eXchange (ONNX) <https://onnx.ai/>`_ is an open standard
+format for representing machine learning models. The ``torch.onnx`` module provides APIs to
+capture the computation graph from a native PyTorch :class:`torch.nn.Module` model and convert
+it into an `ONNX graph <https://github.com/onnx/onnx/blob/main/docs/IR.md>`_.
+
+The exported model can be consumed by any of the many
+`runtimes that support ONNX <https://onnx.ai/supported-tools.html#deployModel>`_,
+including Microsoft's `ONNX Runtime <https://www.onnxruntime.ai>`_.
+
+When setting ``dynamo=True``, the exporter will use `torch.export <https://pytorch.org/docs/stable/export.html>`_ to capture an ``ExportedProgram``,
+before translating the graph into ONNX representations. This approach is the new and recommended way to export models to ONNX.
+It works with PyTorch 2.0 features more robustly, has better support for newer ONNX operator sets, and consumes less resources
+to make exporting larger models possible.
+
+Dependencies
+------------
+
+PyTorch 2.5.0 or newer is required.
+
+The ONNX exporter depends on extra Python packages:
+
+  - `ONNX <https://onnx.ai>`_ standard library
+  - `ONNX Script <https://onnxscript.ai>`_ library that enables developers to author ONNX operators,
+    functions and models using a subset of Python in an expressive, and yet simple fashion
+  - `ONNX Runtime <https://onnxruntime.ai>`_ accelerated machine learning library.
+
+They can be installed through `pip <https://pypi.org/project/pip/>`_:
+
+.. code-block:: bash
+
+  pip install --upgrade onnx onnxscript onnxruntime
+
+To validate the installation, run the following commands:
+
+.. code-block:: python
+
+  import torch
+  print(torch.__version__)
+
+  import onnxscript
+  print(onnxscript.__version__)
+
+  import onnxruntime
+  print(onnxruntime.__version__)
+
+Each `import` must succeed without any errors and the library versions must be printed out.
+
+Further reading
+---------------
+
+The list below refers to tutorials that ranges from basic examples to advanced scenarios,
+not necessarily in the order they are listed.
+Feel free to jump directly to specific topics of your interest or
+sit tight and have fun going through all of them to learn all there is about the ONNX exporter.
+
+.. include:: /beginner_source/onnx/onnx_toc.txt
+
+.. toctree::
+   :hidden:
+
+"""
\ No newline at end of file
diff --git a/beginner_source/onnx/onnx_registry_tutorial.py b/beginner_source/onnx/onnx_registry_tutorial.py
new file mode 100644
index 00000000000..e82bc6257de
--- /dev/null
+++ b/beginner_source/onnx/onnx_registry_tutorial.py
@@ -0,0 +1,271 @@
+# -*- coding: utf-8 -*-
+"""
+`Introduction to ONNX <intro_onnx.html>`_ ||
+`Exporting a PyTorch model to ONNX <export_simple_model_to_onnx_tutorial.html>`_ ||
+**Extending the ONNX exporter operator support** ||
+`Export a model with control flow to ONNX <export_control_flow_model_to_onnx_tutorial.html>`_
+
+Extending the ONNX Exporter Operator Support
+============================================
+
+**Authors:** `Ti-Tai Wang <titaiwang@microsoft.com>`_, `Justin Chu <justinchu@microsoft.com>`_
+"""
+
+
+###############################################################################
+# Overview
+# --------
+#
+# This tutorial describes how you can create ONNX implementation for unsupported PyTorch operators
+# or replace existing implementation with your own.
+#
+# We will cover three scenarios that require extending the ONNX exporter's operator support:
+#
+# * Overriding the implementation of an existing PyTorch operator
+# * Using custom ONNX operators
+# * Supporting a custom PyTorch operator
+#
+# What you will learn:
+#
+# - How to override or add support for PyTorch operators in ONNX.
+# - How to integrate custom ONNX operators for specialized runtimes.
+# - How to implement and translate custom PyTorch operators to ONNX.
+#
+# Prerequisites
+# ~~~~~~~~~~~~~
+#
+# Before starting this tutorial, make sure you have completed the following prerequisites:
+#
+# * ``torch >= 2.6``
+# * The target PyTorch operator
+# * Completed the
+#   `ONNX Script tutorial <https://github.com/microsoft/onnxscript/blob/main/docs/tutorial/index.md>`_
+#   before proceeding
+# * The implementation of the operator using `ONNX Script <https://github.com/microsoft/onnxscript>`__
+#
+# Overriding the implementation of an existing PyTorch operator
+# -------------------------------------------------------------
+#
+# Although the ONNX exporter team does their best efforts to support all PyTorch operators, some of them
+# might not be supported yet. In this section, we will demonstrate how you can add
+# unsupported PyTorch operators to the ONNX Registry.
+#
+# .. note::
+#       The steps to implement unsupported PyTorch operators are the same as those for replacing the implementation of an existing 
+#       PyTorch operator with a custom one.  
+#       Because we don't actually have an unsupported PyTorch operator to use in this tutorial, we are going to leverage
+#       this and replace the implementation of ``torch.ops.aten.add.Tensor`` with a custom implementation the same way we would
+#       if the operator was not implemented by the ONNX exporter.
+#
+# When a model cannot be exported to ONNX due to an unsupported operator, the ONNX exporter will show an error message
+# similar to:
+#
+# .. code-block:: python
+#
+#   No decompositions registered for [...]
+#
+# The error message indicates that the unsupported PyTorch operator is ``torch.ops.aten.add.Tensor``.
+# The operator is of type ``<class 'torch._ops.OpOverload'>``, and this operator is what we will use as the
+# target to register our custom implementation.
+
+import torch
+import onnxscript
+
+# Opset 18 is the standard supported version as of PyTorch 2.6
+from onnxscript import opset18 as op
+
+
+# Create a model that uses the operator torch.ops.aten.add.Tensor
+class Model(torch.nn.Module):
+    def forward(self, input_x, input_y):
+        return torch.ops.aten.add.Tensor(input_x, input_y)
+
+
+# NOTE: The function signature (including parameter names) must match the signature of the unsupported PyTorch operator.
+# https://github.com/pytorch/pytorch/blob/main/aten/src/ATen/native/native_functions.yaml
+# All attributes must be annotated with type hints.
+def custom_aten_add(self, other, alpha: float = 1.0):
+    if alpha != 1.0:
+        alpha = op.CastLike(alpha, other)
+        other = op.Mul(other, alpha)
+    # To distinguish the custom implementation from the builtin one, we switch the order of the inputs
+    return op.Add(other, self)
+
+
+x = torch.tensor([1.0])
+y = torch.tensor([2.0])
+
+# Then we provide the custom implementation to the ONNX exporter as a ``custom_translation_table``.
+onnx_program = torch.onnx.export(
+    Model().eval(),
+    (x, y),
+    dynamo=True,
+    custom_translation_table={
+        torch.ops.aten.add.Tensor: custom_aten_add,
+    },
+)
+# Optimize the ONNX graph to remove redundant nodes
+onnx_program.optimize()
+
+######################################################################
+# Now let's inspect the model and verify the model is using the custom implementation.
+
+print(onnx_program.model)
+
+######################################################################
+# The translation is using our custom implementation: In node ``node_Add_0``, ``input_y`` now
+# comes first, and ``input_x`` comes second.
+#
+# We can use ONNX Runtime to run the model and verify the results by calling
+# the :class:`torch.onnx.ONNXProgram` directly on the input tensors.
+
+result = onnx_program(x, y)[0]
+torch.testing.assert_close(result, torch.tensor([3.0]))
+
+
+######################################################################
+# Using custom ONNX operators
+# ---------------------------
+#
+# In this case, we create a model with standard PyTorch operators, but the runtime
+# (such as Microsoft's ONNX Runtime) can provide a custom implementation for that kernel, effectively replacing the
+# existing implementation.
+#
+# In the following example, we use the ``com.microsoft.Gelu`` operator provided by ONNX Runtime,
+# which is not the same ``Gelu`` from ONNX spec.
+
+
+class GeluModel(torch.nn.Module):
+    def forward(self, input_x):
+        return torch.ops.aten.gelu(input_x)
+
+
+# Create a namespace for the custom operator using ONNX Script
+# ``com.microsoft`` is an official ONNX Runtime namespace
+microsoft_op = onnxscript.values.Opset(domain="com.microsoft", version=1)
+
+# NOTE: The function signature (including parameter names) must match the signature of the unsupported PyTorch operator.
+# https://github.com/pytorch/pytorch/blob/main/aten/src/ATen/native/native_functions.yaml
+# NOTE: All attributes must be annotated with type hints.
+# The function must be scripted using the ``@onnxscript.script()`` decorator when
+# using operators from custom domains. This may be improved in future versions.
+from onnxscript import FLOAT
+
+
+@onnxscript.script(microsoft_op)
+def custom_aten_gelu(self: FLOAT, approximate: str = "none") -> FLOAT:
+    return microsoft_op.Gelu(self)
+
+
+onnx_program = torch.onnx.export(
+    GeluModel().eval(),
+    (x,),
+    dynamo=True,
+    custom_translation_table={
+        torch.ops.aten.gelu.default: custom_aten_gelu,
+    },
+)
+
+# Optimize the ONNX graph to remove redundant nodes
+onnx_program.optimize()
+
+
+######################################################################
+# Let's inspect the model and verify the model uses op_type ``Gelu``
+# from namespace ``com.microsoft``.
+#
+
+print(onnx_program.model)
+
+######################################################################
+# Similar to the previous example, we can use ONNX Runtime to run the model and verify the results.
+
+result = onnx_program(x)[0]
+torch.testing.assert_close(result, torch.ops.aten.gelu(x))
+
+
+######################################################################
+# Supporting a custom PyTorch operator
+# ------------------------------------
+#
+# In this case, the operator is an operator that is user implemented and registered to PyTorch.
+#
+# In the following example, we would like to use a custom operator
+# that takes one tensor input, and returns one output. The operator adds
+# the input to itself, and returns the rounded result.
+#
+# Firstly, we assume the custom operator is implemented and registered with ``torch.library.custom_op()``.
+# You can refer to `Creating new custom ops in Python <https://pytorch.org/docs/stable/library.html#torch.library.custom_op>`_
+# for a detailed guide on how to create custom operators.
+
+
+# Define and use the operator in PyTorch
+@torch.library.custom_op("mylibrary::add_and_round_op", mutates_args=())
+def add_and_round_op(input: torch.Tensor) -> torch.Tensor:
+    return torch.round(input + input)
+
+
+@add_and_round_op.register_fake
+def _add_and_round_op_fake(tensor_x):
+    return torch.empty_like(tensor_x)
+
+
+class AddAndRoundModel(torch.nn.Module):
+    def forward(self, input):
+        return add_and_round_op(input)
+
+
+# Implement the custom operator in ONNX using ONNX Script
+def onnx_add_and_round(input):
+    return op.Round(op.Add(input, input))
+
+
+onnx_program = torch.onnx.export(
+    AddAndRoundModel().eval(),
+    (x,),
+    dynamo=True,
+    custom_translation_table={
+        torch.ops.mylibrary.add_and_round_op.default: onnx_add_and_round,
+    },
+)
+
+# Optimize the ONNX graph to remove redundant nodes
+onnx_program.optimize()
+print(onnx_program)
+
+######################################################################
+# The translation is using our custom implementation to translate the ``torch.ops.mylibrary.add_and_round_op.default``
+# operator in the :class:`torch.export.ExportedProgram`` to the ONNX operator ``Add`` and ``Round``.
+#
+
+######################################################################
+# Finally we verify the results.
+
+result = onnx_program(x)[0]
+torch.testing.assert_close(result, add_and_round_op(x))
+
+######################################################################
+# Conclusion
+# ----------
+#
+# Congratulations! In this tutorial, we explored the ``custom_translation_table`` option and
+# discovered how to create custom implementations for unsupported or existing PyTorch operators
+# using ONNX Script.
+#
+# Finally, we leveraged ONNX Runtime to execute the model and compare the results with PyTorch,
+# providing us with a comprehensive understanding of handling unsupported
+# operators in the ONNX ecosystem.
+#
+# Further reading
+# ---------------
+#
+# The list below refers to tutorials that ranges from basic examples to advanced scenarios,
+# not necessarily in the order they are listed.
+# Feel free to jump directly to specific topics of your interest or
+# sit tight and have fun going through all of them to learn all there is about the ONNX exporter.
+#
+# .. include:: /beginner_source/onnx/onnx_toc.txt
+#
+# .. toctree::
+#    :hidden:
+#
diff --git a/beginner_source/onnx/onnx_toc.txt b/beginner_source/onnx/onnx_toc.txt
new file mode 100644
index 00000000000..ac293fbedd7
--- /dev/null
+++ b/beginner_source/onnx/onnx_toc.txt
@@ -0,0 +1,3 @@
+| 1. `Exporting a PyTorch model to ONNX <export_simple_model_to_onnx_tutorial.html>`_
+| 2. `Extending the ONNX exporter operator support <onnx_registry_tutorial.html>`_
+| 3. `Export a model with control flow to ONNX <export_control_flow_model_to_onnx_tutorial.html>`_
\ No newline at end of file
diff --git a/beginner_source/profiler.py b/beginner_source/profiler.py
new file mode 100644
index 00000000000..b395edbaca6
--- /dev/null
+++ b/beginner_source/profiler.py
@@ -0,0 +1,321 @@
+"""
+Profiling your PyTorch Module
+-----------------------------
+
+**Author:** `Suraj Subramanian <https://github.com/suraj813>`_
+
+PyTorch includes a profiler API that is useful to identify the time and
+memory costs of various PyTorch operations in your code. Profiler can be
+easily integrated in your code, and the results can be printed as a table
+or returned in a JSON trace file.
+
+.. note::
+    Profiler supports multithreaded models. Profiler runs in the
+    same thread as the operation but it will also profile child operators
+    that might run in another thread. Concurrently-running profilers will be
+    scoped to their own thread to prevent mixing of results.
+
+.. note::
+    PyTorch 1.8 introduces the new API that will replace the older profiler API
+    in the future releases. Check the new API at `this page <https://pytorch.org/docs/master/profiler.html>`__.
+
+Head on over to `this
+recipe <https://pytorch.org/tutorials/recipes/recipes/profiler_recipe.html>`__
+for a quicker walkthrough of Profiler API usage.
+
+
+--------------
+"""
+
+import torch
+import numpy as np
+from torch import nn
+import torch.autograd.profiler as profiler
+
+
+######################################################################
+# Performance debugging using Profiler
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# Profiler can be useful to identify performance bottlenecks in your
+# models. In this example, we build a custom module that performs two
+# sub-tasks:
+#
+# - a linear transformation on the input, and
+# - use the transformation result to get indices on a mask tensor.
+#
+# We wrap the code for each sub-task in separate labelled context managers using
+# ``profiler.record_function("label")``. In the profiler output, the
+# aggregate performance metrics of all operations in the sub-task will
+# show up under its corresponding label.
+#
+#
+# Note that using Profiler incurs some overhead, and is best used only for investigating
+# code. Remember to remove it if you are benchmarking runtimes.
+#
+
+class MyModule(nn.Module):
+    def __init__(self, in_features: int, out_features: int, bias: bool = True):
+        super(MyModule, self).__init__()
+        self.linear = nn.Linear(in_features, out_features, bias)
+
+    def forward(self, input, mask):
+        with profiler.record_function("LINEAR PASS"):
+            out = self.linear(input)
+
+        with profiler.record_function("MASK INDICES"):
+            threshold = out.sum(axis=1).mean().item()
+            hi_idx = np.argwhere(mask.cpu().numpy() > threshold)
+            hi_idx = torch.from_numpy(hi_idx).cuda()
+
+        return out, hi_idx
+
+
+######################################################################
+# Profile the forward pass
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# We initialize random input and mask tensors, and the model.
+#
+# Before we run the profiler, we warm-up CUDA to ensure accurate
+# performance benchmarking. We wrap the forward pass of our module in the
+# ``profiler.profile`` context manager. The ``with_stack=True`` parameter appends the
+# file and line number of the operation in the trace.
+#
+# .. warning::
+#     ``with_stack=True`` incurs an additional overhead, and is better suited for investigating code.
+#     Remember to remove it if you are benchmarking performance.
+#
+
+model = MyModule(500, 10).cuda()
+input = torch.rand(128, 500).cuda()
+mask = torch.rand((500, 500, 500), dtype=torch.double).cuda()
+
+# warm-up
+model(input, mask)
+
+with profiler.profile(with_stack=True, profile_memory=True) as prof:
+    out, idx = model(input, mask)
+
+
+######################################################################
+# Print profiler results
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# Finally, we print the profiler results. ``profiler.key_averages``
+# aggregates the results by operator name, and optionally by input
+# shapes and/or stack trace events.
+# Grouping by input shapes is useful to identify which tensor shapes
+# are utilized by the model.
+#
+# Here, we use ``group_by_stack_n=5`` which aggregates runtimes by the
+# operation and its traceback (truncated to the most recent 5 events), and
+# display the events in the order they are registered. The table can also
+# be sorted by passing a ``sort_by`` argument (refer to the
+# `docs <https://pytorch.org/docs/stable/autograd.html#profiler>`__ for
+# valid sorting keys).
+#
+# .. note::
+#   When running profiler in a notebook, you might see entries like ``<ipython-input-18-193a910735e8>(13): forward``
+#   instead of filenames in the stacktrace. These correspond to ``<notebook-cell>(line number): calling-function``.
+
+print(prof.key_averages(group_by_stack_n=5).table(sort_by='self_cpu_time_total', row_limit=5))
+
+"""
+(Some columns are omitted)
+
+-------------  ------------  ------------  ------------  ---------------------------------
+         Name    Self CPU %      Self CPU  Self CPU Mem   Source Location
+-------------  ------------  ------------  ------------  ---------------------------------
+ MASK INDICES        87.88%        5.212s    -953.67 Mb  /mnt/xarfuse/.../torch/au
+                                                         <ipython-input-...>(10): forward
+                                                         /mnt/xarfuse/.../torch/nn
+                                                         <ipython-input-...>(9): <module>
+                                                         /mnt/xarfuse/.../IPython/
+
+  aten::copy_        12.07%     715.848ms           0 b  <ipython-input-...>(12): forward
+                                                         /mnt/xarfuse/.../torch/nn
+                                                         <ipython-input-...>(9): <module>
+                                                         /mnt/xarfuse/.../IPython/
+                                                         /mnt/xarfuse/.../IPython/
+
+  LINEAR PASS         0.01%     350.151us         -20 b  /mnt/xarfuse/.../torch/au
+                                                         <ipython-input-...>(7): forward
+                                                         /mnt/xarfuse/.../torch/nn
+                                                         <ipython-input-...>(9): <module>
+                                                         /mnt/xarfuse/.../IPython/
+
+  aten::addmm         0.00%     293.342us           0 b  /mnt/xarfuse/.../torch/nn
+                                                         /mnt/xarfuse/.../torch/nn
+                                                         /mnt/xarfuse/.../torch/nn
+                                                         <ipython-input-...>(8): forward
+                                                         /mnt/xarfuse/.../torch/nn
+
+   aten::mean         0.00%     235.095us           0 b  <ipython-input-...>(11): forward
+                                                         /mnt/xarfuse/.../torch/nn
+                                                         <ipython-input-...>(9): <module>
+                                                         /mnt/xarfuse/.../IPython/
+                                                         /mnt/xarfuse/.../IPython/
+
+-----------------------------  ------------  ---------- ----------------------------------
+Self CPU time total: 5.931s
+
+"""
+
+######################################################################
+# Improve memory performance
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# Note that the most expensive operations - in terms of memory and time -
+# are at ``forward (10)`` representing the operations within MASK INDICES. Let’s try to
+# tackle the memory consumption first. We can see that the ``.to()``
+# operation at line 12 consumes 953.67 Mb. This operation copies ``mask`` to the CPU.
+# ``mask`` is initialized with a ``torch.double`` datatype. Can we reduce the memory footprint by casting
+# it to ``torch.float`` instead?
+#
+
+model = MyModule(500, 10).cuda()
+input = torch.rand(128, 500).cuda()
+mask = torch.rand((500, 500, 500), dtype=torch.float).cuda()
+
+# warm-up
+model(input, mask)
+
+with profiler.profile(with_stack=True, profile_memory=True) as prof:
+    out, idx = model(input, mask)
+
+print(prof.key_averages(group_by_stack_n=5).table(sort_by='self_cpu_time_total', row_limit=5))
+
+"""
+(Some columns are omitted)
+
+-----------------  ------------  ------------  ------------  --------------------------------
+             Name    Self CPU %      Self CPU  Self CPU Mem   Source Location
+-----------------  ------------  ------------  ------------  --------------------------------
+     MASK INDICES        93.61%        5.006s    -476.84 Mb  /mnt/xarfuse/.../torch/au
+                                                             <ipython-input-...>(10): forward
+                                                             /mnt/xarfuse/  /torch/nn
+                                                             <ipython-input-...>(9): <module>
+                                                             /mnt/xarfuse/.../IPython/
+
+      aten::copy_         6.34%     338.759ms           0 b  <ipython-input-...>(12): forward
+                                                             /mnt/xarfuse/.../torch/nn
+                                                             <ipython-input-...>(9): <module>
+                                                             /mnt/xarfuse/.../IPython/
+                                                             /mnt/xarfuse/.../IPython/
+
+ aten::as_strided         0.01%     281.808us           0 b  <ipython-input-...>(11): forward
+                                                             /mnt/xarfuse/.../torch/nn
+                                                             <ipython-input-...>(9): <module>
+                                                             /mnt/xarfuse/.../IPython/
+                                                             /mnt/xarfuse/.../IPython/
+
+      aten::addmm         0.01%     275.721us           0 b  /mnt/xarfuse/.../torch/nn
+                                                             /mnt/xarfuse/.../torch/nn
+                                                             /mnt/xarfuse/.../torch/nn
+                                                             <ipython-input-...>(8): forward
+                                                             /mnt/xarfuse/.../torch/nn
+
+      aten::_local        0.01%     268.650us           0 b  <ipython-input-...>(11): forward
+      _scalar_dense                                          /mnt/xarfuse/.../torch/nn
+                                                             <ipython-input-...>(9): <module>
+                                                             /mnt/xarfuse/.../IPython/
+                                                             /mnt/xarfuse/.../IPython/
+
+-----------------  ------------  ------------  ------------  --------------------------------
+Self CPU time total: 5.347s
+
+"""
+
+######################################################################
+#
+# The CPU memory footprint for this operation has halved.
+#
+# Improve time performance
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# While the time consumed has also reduced a bit, it’s still too high.
+# Turns out copying a matrix from CUDA to CPU is pretty expensive!
+# The ``aten::copy_`` operator in ``forward (12)`` copies ``mask`` to CPU
+# so that it can use the NumPy ``argwhere`` function. ``aten::copy_`` at ``forward(13)``
+# copies the array back to CUDA as a tensor. We could eliminate both of these if we use a
+# ``torch`` function ``nonzero()`` here instead.
+#
+
+class MyModule(nn.Module):
+    def __init__(self, in_features: int, out_features: int, bias: bool = True):
+        super(MyModule, self).__init__()
+        self.linear = nn.Linear(in_features, out_features, bias)
+
+    def forward(self, input, mask):
+        with profiler.record_function("LINEAR PASS"):
+            out = self.linear(input)
+
+        with profiler.record_function("MASK INDICES"):
+            threshold = out.sum(axis=1).mean()
+            hi_idx = (mask > threshold).nonzero(as_tuple=True)
+
+        return out, hi_idx
+
+
+model = MyModule(500, 10).cuda()
+input = torch.rand(128, 500).cuda()
+mask = torch.rand((500, 500, 500), dtype=torch.float).cuda()
+
+# warm-up
+model(input, mask)
+
+with profiler.profile(with_stack=True, profile_memory=True) as prof:
+    out, idx = model(input, mask)
+
+print(prof.key_averages(group_by_stack_n=5).table(sort_by='self_cpu_time_total', row_limit=5))
+
+"""
+(Some columns are omitted)
+
+--------------  ------------  ------------  ------------  ---------------------------------
+          Name    Self CPU %      Self CPU  Self CPU Mem   Source Location
+--------------  ------------  ------------  ------------  ---------------------------------
+      aten::gt        57.17%     129.089ms           0 b  <ipython-input-...>(12): forward
+                                                          /mnt/xarfuse/.../torch/nn
+                                                          <ipython-input-...>(25): <module>
+                                                          /mnt/xarfuse/.../IPython/
+                                                          /mnt/xarfuse/.../IPython/
+
+ aten::nonzero        37.38%      84.402ms           0 b  <ipython-input-...>(12): forward
+                                                          /mnt/xarfuse/.../torch/nn
+                                                          <ipython-input-...>(25): <module>
+                                                          /mnt/xarfuse/.../IPython/
+                                                          /mnt/xarfuse/.../IPython/
+
+   INDEX SCORE         3.32%       7.491ms    -119.21 Mb  /mnt/xarfuse/.../torch/au
+                                                          <ipython-input-...>(10): forward
+                                                          /mnt/xarfuse/.../torch/nn
+                                                          <ipython-input-...>(25): <module>
+                                                          /mnt/xarfuse/.../IPython/
+
+aten::as_strided         0.20%    441.587us          0 b  <ipython-input-...>(12): forward
+                                                          /mnt/xarfuse/.../torch/nn
+                                                          <ipython-input-...>(25): <module>
+                                                          /mnt/xarfuse/.../IPython/
+                                                          /mnt/xarfuse/.../IPython/
+
+ aten::nonzero
+     _numpy             0.18%     395.602us           0 b  <ipython-input-...>(12): forward
+                                                          /mnt/xarfuse/.../torch/nn
+                                                          <ipython-input-...>(25): <module>
+                                                          /mnt/xarfuse/.../IPython/
+                                                          /mnt/xarfuse/.../IPython/
+--------------  ------------  ------------  ------------  ---------------------------------
+Self CPU time total: 225.801ms
+
+"""
+
+
+######################################################################
+# Further Reading
+# ~~~~~~~~~~~~~~~~~
+# We have seen how Profiler can be used to investigate time and memory bottlenecks in PyTorch models.
+# Read more about Profiler here:
+#
+# - `Profiler Usage Recipe <https://pytorch.org/tutorials/recipes/recipes/profiler.html>`__
+# - `Profiling RPC-Based Workloads <https://pytorch.org/tutorials/recipes/distributed_rpc_profiling.html>`__
+# - `Profiler API Docs <https://pytorch.org/docs/stable/autograd.html?highlight=profiler#profiler>`__
diff --git a/beginner_source/ptcheat.rst b/beginner_source/ptcheat.rst
deleted file mode 100644
index fc30ec83935..00000000000
--- a/beginner_source/ptcheat.rst
+++ /dev/null
@@ -1,283 +0,0 @@
-PyTorch Cheat Sheet
-******************************
-
-Imports
-=========
-
-General
--------
-
-.. code-block:: python
-
-    import torch                                        # root package
-    from torch.utils.data import Dataset, Dataloader    # dataset representation and loading
-
-Neural Network API
-------------------
-
-.. code-block:: python
-
-    import torch.autograd as autograd         # computation graph
-    from torch.autograd import Variable       # variable node in computation graph
-    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>`__
-
-Hybrid frontend
----------------
-
-.. 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 `hybrid frontend <https://pytorch.org/docs/stable/hybridfrontend>`__
-
-ONNX
-----
-
-.. code-block:: python
-
-    torch.onnx.export(model, dummy data, xxxx.proto)       # exports an ONNX formatted  
-                                                           # model using a trained model, dummy
-                                                           # data and the desired file name
-
-    model = onnx.load("alexnet.proto")                     # load an ONNX model
-    onnx.checker.check_model(model)                        # check that the model 
-                                                           # IR is well formed  
-                    
-    onnx.helper.printable_graph(model.graph)               # print a human readable 
-                                                           # representation of the graph
-
-See `onnx <https://pytorch.org/docs/stable/onnx.html>`__
-
-Vision
-------
-
-.. code-block:: python
-
-    from torchvision import datasets, models, transforms     # vision datasets, 
-                                                             # architectures & 
-                                                             # transforms
-
-    import torchvision.transforms as transforms              # composable transforms
-
-See
-`torchvision <https://pytorch.org/docs/stable/torchvision/index.html>`__
-
-Distributed Training
---------------------
-
-.. code-block:: python
-
-    import torch.distributed as dist          # distributed communication
-    from multiprocessing import Process       # memory sharing processes
-
-See `distributed <https://pytorch.org/docs/stable/distributed.html>`__
-and
-`multiprocessing <https://pytorch.org/docs/stable/multiprocessing.html>`__
-
-Tensors
-=========
-
-Creation
---------
-
-.. code-block:: python
-
-    torch.randn(*size)              # tensor with independent N(0,1) entries
-    torch.[ones|zeros](*size)       # tensor with all 1's [or 0's]
-    torch.Tensor(L)                 # create tensor from [nested] list or ndarray L
-    x.clone()                       # clone of x
-    with torch.no_grad():           # code wrap that stops autograd from tracking tensor history
-    requires_grad=True              # arg, when set to True, tracks computation 
-                                    # history for future derivative calculations
-
-See `tensor <https://pytorch.org/docs/stable/tensors.html>`__
-
-Dimensionality
---------------
-
-.. code-block:: python
-
-    x.size()                              # return tuple-like object of dimensions
-    torch.cat(tensor_seq, dim=0)          # concatenates tensors along dim
-    x.view(a,b,...)                       # reshapes x into size (a,b,...)
-    x.view(-1,a)                          # reshapes x into size (b,a) for some b
-    x.transpose(a,b)                      # swaps dimensions a and b
-    x.permute(*dims)                      # permutes dimensions
-    x.unsqueeze(dim)                      # tensor with added axis
-    x.unsqueeze(dim=2)                    # (a,b,c) tensor -> (a,b,1,c) tensor
-
-See `tensor <https://pytorch.org/docs/stable/tensors.html>`__
-
-Algebra
--------
-
-
-.. code-block:: python
-
-    A.mm(B)       # matrix multiplication
-    A.mv(x)       # matrix-vector multiplication
-    x.t()         # matrix transpose
-
-See `math
-operations <https://pytorch.org/docs/stable/torch.html?highlight=mm#math-operations>`__
-
-GPU Usage
----------
-
-.. code-block:: python
-
-    torch.cuda.is_available                                 # check for cuda
-    x.cuda()                                                # move x's data from 
-                                                            # CPU to GPU and return new object
-
-    x.cpu()                                                 # move x's data from GPU to CPU 
-                                                            # and return new object
-
-    if not args.disable_cuda and torch.cuda.is_available(): # device agnostic code 
-        args.device = torch.device('cuda')                  # and modularity
-    else:                                                   #
-        args.device = torch.device('cpu')                   #
-
-    net.to(device)                                          # recursively convert their 
-                                                            # parameters and buffers to 
-                                                            # device specific tensors
-
-    mytensor.to(device)                                     # copy your tensors to a device 
-                                                            # (gpu, cpu)
-
-See `cuda <https://pytorch.org/docs/stable/cuda.html>`__
-
-Deep Learning
-=============
-
-.. code-block:: python
-
-    nn.Linear(m,n)                                # fully connected layer from 
-                                                  # m to n units
-
-    nn.ConvXd(m,n,s)                              # X dimensional conv layer from 
-                                                  # m to n channels where X⍷{1,2,3} 
-                                                  # and the kernel size is s
-
-    nn.MaxPoolXd(s)                               # X dimension pooling layer 
-                                                  # (notation as above)
-
-    nn.BatchNorm                                  # batch norm layer
-    nn.RNN/LSTM/GRU                               # recurrent layers
-    nn.Dropout(p=0.5, inplace=False)              # dropout layer for any dimensional input
-    nn.Dropout2d(p=0.5, inplace=False)            # 2-dimensional channel-wise dropout
-    nn.Embedding(num_embeddings, embedding_dim)   # (tensor-wise) mapping from 
-                                                  # indices to embedding vectors
-
-See `nn <https://pytorch.org/docs/stable/nn.html>`__
-
-Loss Functions
---------------
-
-.. code-block:: python
-
-    nn.X                                  # where X is BCELoss, CrossEntropyLoss, 
-                                          # L1Loss, MSELoss, NLLLoss, SoftMarginLoss,
-                                          # MultiLabelSoftMarginLoss, CosineEmbeddingLoss, 
-                                          # KLDivLoss, MarginRankingLoss, HingeEmbeddingLoss 
-                                          # or CosineEmbeddingLoss
- 
-See `loss
-functions <https://pytorch.org/docs/stable/nn.html#loss-functions>`__
-
-Activation Functions
---------------------
-
-.. code-block:: python
-
-    nn.X                                  # where X is ReLU, ReLU6, ELU, SELU, PReLU, LeakyReLU, 
-                                          # Threshold, HardTanh, Sigmoid, Tanh, 
-                                          # LogSigmoid, Softplus, SoftShrink, 
-                                          # Softsign, TanhShrink, Softmin, Softmax, 
-                                          # Softmax2d or LogSoftmax
-
-See `activation
-functions <https://pytorch.org/docs/stable/nn.html#non-linear-activations-weighted-sum-nonlinearity>`__
-
-Optimizers
-----------
-
-.. code-block:: python
-
-    opt = optim.x(model.parameters(), ...)      # create optimizer
-    opt.step()                                  # update weights
-    optim.X                                     # where X is SGD, Adadelta, Adagrad, Adam, 
-                                                # SparseAdam, Adamax, ASGD, 
-                                                # LBFGS, RMSProp or Rprop
-
-See `optimizers <https://pytorch.org/docs/stable/optim.html>`__
-
-Learning rate scheduling
-------------------------
-
-.. code-block:: python
-
-    scheduler = optim.X(optimizer,...)      # create lr scheduler
-    scheduler.step()                        # update lr at start of epoch
-    optim.lr_scheduler.X                    # where X is LambdaLR, StepLR, MultiStepLR, 
-                  # ExponentialLR or ReduceLROnPLateau
-
-See `learning rate
-scheduler <https://pytorch.org/docs/stable/optim.html#how-to-adjust-learning-rate>`__
-
-Data Utilities
-==============
-
-Datasets
---------
-
-.. code-block:: python
-
-    Dataset                    # abstract class representing dataset
-    TensorDataset              # labelled dataset in the form of tensors
-    Concat Dataset             # concatenation of Datasets
-
-See
-`datasets <https://pytorch.org/docs/stable/data.html?highlight=dataset#torch.utils.data.Dataset>`__
-
-Dataloaders and DataSamplers
-----------------------------
-
-.. code-block:: python
-
-    DataLoader(dataset, batch_size=1, ...)      # loads data batches agnostic 
-                                                # of structure of individual data points
-
-    sampler.Sampler(dataset,...)                # abstract class dealing with 
-                                                # ways to sample from dataset
-
-    sampler.XSampler where ...                  # Sequential, Random, Subset, 
-                                                # WeightedRandom or Distributed
-
-See
-`dataloader <https://pytorch.org/docs/stable/data.html?highlight=dataloader#torch.utils.data.DataLoader>`__
-
-Also see
---------
-
--  `Deep Learning with PyTorch: A 60 Minute
-   Blitz <https://pytorch.org/tutorials/beginner/deep_learning_60min_blitz.html>`__
-   *(pytorch.org)*
--  `PyTorch Forums <https://discuss.pytorch.org/>`__
-   *(discuss.pytorch.org)*
--  `PyTorch for Numpy
-   users <https://github.com/wkentaro/pytorch-for-numpy-users>`__
-   *(github.com/wkentaro/pytorch-for-numpy-users)*
diff --git a/beginner_source/pytorch_with_examples.rst b/beginner_source/pytorch_with_examples.rst
index 772ec58966e..d65a959b957 100644
--- a/beginner_source/pytorch_with_examples.rst
+++ b/beginner_source/pytorch_with_examples.rst
@@ -1,7 +1,13 @@
 Learning PyTorch with Examples
-******************************
+==============================
+
 **Author**: `Justin Johnson <https://github.com/jcjohnson/pytorch-examples>`_
 
+.. note::
+   This is one of our older PyTorch tutorials. You can view our latest
+   beginner content in 
+   `Learn the Basics <https://pytorch.org/tutorials/beginner/basics/intro.html>`_.
+
 This tutorial introduces the fundamental concepts of
 `PyTorch <https://github.com/pytorch/pytorch>`__ through self-contained
 examples.
@@ -11,20 +17,26 @@ At its core, PyTorch provides two main features:
 - An n-dimensional Tensor, similar to numpy but can run on GPUs
 - Automatic differentiation for building and training neural networks
 
-We will use a fully-connected ReLU network as our running example. The
-network will have a single hidden layer, and will be trained with
+We will use a problem of fitting :math:`y=\sin(x)` with a third order polynomial
+as our running example. The network will have four parameters, and will be trained with
 gradient descent to fit random data by minimizing the Euclidean distance
 between the network output and the true output.
 
-.. Note::
-	You can browse the individual examples at the
-	:ref:`end of this page <examples-download>`.
+.. note::
+   You can browse the individual examples at the
+   :ref:`end of this page <examples-download>`.
+
+To run the tutorials below, make sure you have the `torch`_
+and `numpy`_ packages installed.
+
+.. _torch: https://github.com/pytorch/pytorch
+.. _numpy: https://github.com/numpy/numpy
 
 .. contents:: Table of Contents
-	:local:
+   :local:
 
 Tensors
-=======
+~~~~~~~
 
 Warm-up: numpy
 --------------
@@ -36,10 +48,10 @@ Numpy provides an n-dimensional array object, and many functions for
 manipulating these arrays. Numpy is a generic framework for scientific
 computing; it does not know anything about computation graphs, or deep
 learning, or gradients. However we can easily use numpy to fit a
-two-layer network to random data by manually implementing the forward
+third order polynomial to sine function by manually implementing the forward
 and backward passes through the network using numpy operations:
 
-.. includenodoc:: /beginner/examples_tensor/two_layer_net_numpy.py
+.. includenodoc:: /beginner/examples_tensor/polynomial_numpy.py
 
 
 PyTorch: Tensors
@@ -47,8 +59,7 @@ PyTorch: Tensors
 
 Numpy is a great framework, but it cannot utilize GPUs to accelerate its
 numerical computations. For modern deep neural networks, GPUs often
-provide speedups of `50x or
-greater <https://github.com/jcjohnson/cnn-benchmarks>`__, so
+provide speedups of `50x or greater <https://github.com/jcjohnson/cnn-benchmarks>`__, so
 unfortunately numpy won't be enough for modern deep learning.
 
 Here we introduce the most fundamental PyTorch concept: the **Tensor**.
@@ -60,17 +71,17 @@ generic tool for scientific computing.
 
 Also unlike numpy, PyTorch Tensors can utilize GPUs to accelerate
 their numeric computations. To run a PyTorch Tensor on GPU, you simply
-need to cast it to a new datatype.
+need to specify the correct device.
 
-Here we use PyTorch Tensors to fit a two-layer network to random data.
+Here we use PyTorch Tensors to fit a third order polynomial to sine function.
 Like the numpy example above we need to manually implement the forward
 and backward passes through the network:
 
-.. includenodoc:: /beginner/examples_tensor/two_layer_net_tensor.py
+.. includenodoc:: /beginner/examples_tensor/polynomial_tensor.py
 
 
 Autograd
-========
+~~~~~~~~
 
 PyTorch: Tensors and autograd
 -------------------------------
@@ -95,11 +106,11 @@ represents a node in a computational graph. If ``x`` is a Tensor that has
 ``x.requires_grad=True`` then ``x.grad`` is another Tensor holding the
 gradient of ``x`` with respect to some scalar value.
 
-Here we use PyTorch Tensors and autograd to implement our two-layer
-network; now we no longer need to manually implement the backward pass
-through the network:
+Here we use PyTorch Tensors and autograd to implement our fitting sine wave
+with third order polynomial example; now we no longer need to manually
+implement the backward pass through the network:
 
-.. includenodoc:: /beginner/examples_autograd/two_layer_net_autograd.py
+.. includenodoc:: /beginner/examples_autograd/polynomial_autograd.py
 
 PyTorch: Defining new autograd functions
 ----------------------------------------
@@ -117,54 +128,22 @@ and ``backward`` functions. We can then use our new autograd operator by
 constructing an instance and calling it like a function, passing
 Tensors containing input data.
 
-In this example we define our own custom autograd function for
-performing the ReLU nonlinearity, and use it to implement our two-layer
-network:
-
-.. includenodoc:: /beginner/examples_autograd/two_layer_net_custom_function.py
-
-TensorFlow: Static Graphs
--------------------------
-
-PyTorch autograd looks a lot like TensorFlow: in both frameworks we
-define a computational graph, and use automatic differentiation to
-compute gradients. The biggest difference between the two is that
-TensorFlow's computational graphs are **static** and PyTorch uses
-**dynamic** computational graphs.
+In this example we define our model as :math:`y=a+b P_3(c+dx)` instead of
+:math:`y=a+bx+cx^2+dx^3`, where :math:`P_3(x)=\frac{1}{2}\left(5x^3-3x\right)`
+is the `Legendre polynomial`_ of degree three. We write our own custom autograd
+function for computing forward and backward of :math:`P_3`, and use it to implement
+our model:
 
-In TensorFlow, we define the computational graph once and then execute
-the same graph over and over again, possibly feeding different input
-data to the graph. In PyTorch, each forward pass defines a new
-computational graph.
+.. _Legendre polynomial:
+    https://en.wikipedia.org/wiki/Legendre_polynomials
 
-Static graphs are nice because you can optimize the graph up front; for
-example a framework might decide to fuse some graph operations for
-efficiency, or to come up with a strategy for distributing the graph
-across many GPUs or many machines. If you are reusing the same graph
-over and over, then this potentially costly up-front optimization can be
-amortized as the same graph is rerun over and over.
+.. includenodoc:: /beginner/examples_autograd/polynomial_custom_function.py
 
-One aspect where static and dynamic graphs differ is control flow. For
-some models we may wish to perform different computation for each data
-point; for example a recurrent network might be unrolled for different
-numbers of time steps for each data point; this unrolling can be
-implemented as a loop. With a static graph the loop construct needs to
-be a part of the graph; for this reason TensorFlow provides operators
-such as ``tf.scan`` for embedding loops into the graph. With dynamic
-graphs the situation is simpler: since we build graphs on-the-fly for
-each example, we can use normal imperative flow control to perform
-computation that differs for each input.
+``nn`` module
+~~~~~~~~~~~~~
 
-To contrast with the PyTorch autograd example above, here we use
-TensorFlow to fit a simple two-layer net:
-
-.. includenodoc:: /beginner/examples_autograd/tf_two_layer_net.py
-
-`nn` module
-===========
-
-PyTorch: nn
------------
+PyTorch: ``nn``
+---------------
 
 Computational graphs and autograd are a very powerful paradigm for
 defining complex operators and automatically taking derivatives; however
@@ -176,7 +155,7 @@ which will be optimized during learning.
 
 In TensorFlow, packages like
 `Keras <https://github.com/fchollet/keras>`__,
-`TensorFlow-Slim <https://github.com/tensorflow/tensorflow/tree/master/tensorflow/contrib/slim>`__,
+`TensorFlow-Slim <https://github.com/google-research/tf-slim>`__,
 and `TFLearn <http://tflearn.org/>`__ provide higher-level abstractions
 over raw computational graphs that are useful for building neural
 networks.
@@ -189,33 +168,32 @@ containing learnable parameters. The ``nn`` package also defines a set
 of useful loss functions that are commonly used when training neural
 networks.
 
-In this example we use the ``nn`` package to implement our two-layer
+In this example we use the ``nn`` package to implement our polynomial model
 network:
 
-.. includenodoc:: /beginner/examples_nn/two_layer_net_nn.py
+.. includenodoc:: /beginner/examples_nn/polynomial_nn.py
 
 PyTorch: optim
 --------------
 
 Up to this point we have updated the weights of our models by manually
-mutating the Tensors holding learnable parameters (with ``torch.no_grad()``
-or ``.data`` to avoid tracking history in autograd). This is not a huge
-burden for simple optimization algorithms like stochastic gradient descent,
-but in practice we often train neural networks using more sophisticated
-optimizers like AdaGrad, RMSProp, Adam, etc.
+mutating the Tensors holding learnable parameters with ``torch.no_grad()``.
+This is not a huge burden for simple optimization algorithms like stochastic
+gradient descent, but in practice we often train neural networks using more
+sophisticated optimizers like ``AdaGrad``, ``RMSProp``, ``Adam``, and other.
 
 The ``optim`` package in PyTorch abstracts the idea of an optimization
 algorithm and provides implementations of commonly used optimization
 algorithms.
 
 In this example we will use the ``nn`` package to define our model as
-before, but we will optimize the model using the Adam algorithm provided
+before, but we will optimize the model using the ``RMSprop`` algorithm provided
 by the ``optim`` package:
 
-.. includenodoc:: /beginner/examples_nn/two_layer_net_optim.py
+.. includenodoc:: /beginner/examples_nn/polynomial_optim.py
 
-PyTorch: Custom nn Modules
---------------------------
+PyTorch: Custom ``nn`` Modules
+------------------------------
 
 Sometimes you will want to specify models that are more complex than a
 sequence of existing Modules; for these cases you can define your own
@@ -223,33 +201,34 @@ Modules by subclassing ``nn.Module`` and defining a ``forward`` which
 receives input Tensors and produces output Tensors using other
 modules or other autograd operations on Tensors.
 
-In this example we implement our two-layer network as a custom Module
+In this example we implement our third order polynomial as a custom Module
 subclass:
 
-.. includenodoc:: /beginner/examples_nn/two_layer_net_module.py
+.. includenodoc:: /beginner/examples_nn/polynomial_module.py
 
 PyTorch: Control Flow + Weight Sharing
 --------------------------------------
 
 As an example of dynamic graphs and weight sharing, we implement a very
-strange model: a fully-connected ReLU network that on each forward pass
-chooses a random number between 1 and 4 and uses that many hidden
-layers, reusing the same weights multiple times to compute the innermost
-hidden layers.
+strange model: a third-fifth order polynomial that on each forward pass
+chooses a random number between 3 and 5 and uses that many orders, reusing
+the same weights multiple times to compute the fourth and fifth order.
 
 For this model we can use normal Python flow control to implement the loop,
-and we can implement weight sharing among the innermost layers by simply
-reusing the same Module multiple times when defining the forward pass.
+and we can implement weight sharing by simply reusing the same parameter multiple
+times when defining the forward pass.
 
 We can easily implement this model as a Module subclass:
 
 .. includenodoc:: /beginner/examples_nn/dynamic_net.py
 
 
+
+
 .. _examples-download:
 
 Examples
-========
+~~~~~~~~
 
 You can browse the above examples here.
 
@@ -258,14 +237,13 @@ Tensors
 
 .. toctree::
    :maxdepth: 2
-   :hidden:
 
-   /beginner/examples_tensor/two_layer_net_numpy
-   /beginner/examples_tensor/two_layer_net_tensor
+   /beginner/examples_tensor/polynomial_numpy
+   /beginner/examples_tensor/polynomial_tensor
 
-.. galleryitem:: /beginner/examples_tensor/two_layer_net_numpy.py
+.. galleryitem:: /beginner/examples_tensor/polynomial_numpy.py
 
-.. galleryitem:: /beginner/examples_tensor/two_layer_net_tensor.py
+.. galleryitem:: /beginner/examples_tensor/polynomial_tensor.py
 
 .. raw:: html
 
@@ -276,44 +254,39 @@ Autograd
 
 .. toctree::
    :maxdepth: 2
-   :hidden:
-
-   /beginner/examples_autograd/two_layer_net_autograd
-   /beginner/examples_autograd/two_layer_net_custom_function
-   /beginner/examples_autograd/tf_two_layer_net
 
+   /beginner/examples_autograd/polynomial_autograd
+   /beginner/examples_autograd/polynomial_custom_function
 
-.. galleryitem:: /beginner/examples_autograd/two_layer_net_autograd.py
 
-.. galleryitem:: /beginner/examples_autograd/two_layer_net_custom_function.py
+.. galleryitem:: /beginner/examples_autograd/polynomial_autograd.py
 
-.. galleryitem:: /beginner/examples_autograd/tf_two_layer_net.py
+.. galleryitem:: /beginner/examples_autograd/polynomial_custom_function.py
 
 .. raw:: html
 
     <div style='clear:both'></div>
 
-`nn` module
------------
+``nn`` module
+--------------
 
 .. toctree::
    :maxdepth: 2
-   :hidden:
 
-   /beginner/examples_nn/two_layer_net_nn
-   /beginner/examples_nn/two_layer_net_optim
-   /beginner/examples_nn/two_layer_net_module
+   /beginner/examples_nn/polynomial_nn
+   /beginner/examples_nn/polynomial_optim
+   /beginner/examples_nn/polynomial_module
    /beginner/examples_nn/dynamic_net
 
 
-.. galleryitem:: /beginner/examples_nn/two_layer_net_nn.py
+.. galleryitem:: /beginner/examples_nn/polynomial_nn.py
 
-.. galleryitem:: /beginner/examples_nn/two_layer_net_optim.py
+.. galleryitem:: /beginner/examples_nn/polynomial_optim.py
 
-.. galleryitem:: /beginner/examples_nn/two_layer_net_module.py
+.. galleryitem:: /beginner/examples_nn/polynomial_module.py
 
 .. galleryitem:: /beginner/examples_nn/dynamic_net.py
 
 .. raw:: html
 
-    <div style='clear:both'></div>
+    <div style='clear:both'></div>
\ No newline at end of file
diff --git a/beginner_source/saving_loading_models.py b/beginner_source/saving_loading_models.py
index 73d3554ceab..d09f9ca4491 100644
--- a/beginner_source/saving_loading_models.py
+++ b/beginner_source/saving_loading_models.py
@@ -24,7 +24,7 @@
    `Saving & Loading Model Across
    Devices <#saving-loading-model-across-devices>`__).
 
-3) `torch.nn.Module.load_state_dict <https://pytorch.org/docs/stable/nn.html?highlight=load_state_dict#torch.nn.Module.load_state_dict>`__:
+3) `torch.nn.Module.load_state_dict <https://pytorch.org/docs/stable/generated/torch.nn.Module.html?highlight=load_state_dict#torch.nn.Module.load_state_dict>`__:
    Loads a model’s parameter dictionary using a deserialized
    *state_dict*. For more information on *state_dict*, see `What is a
    state_dict? <#what-is-a-state-dict>`__.
@@ -60,7 +60,7 @@
 # linear layers, etc.) and registered buffers (batchnorm's running_mean)
 # have entries in the model’s *state_dict*. Optimizer
 # objects (``torch.optim``) also have a *state_dict*, which contains
-# information about the optimizer’s state, as well as the hyperparameters
+# information about the optimizer's state, as well as the hyperparameters
 # used.
 #
 # Because *state_dict* objects are Python dictionaries, they can be easily
@@ -115,7 +115,7 @@
 #
 # **Output:**
 #
-# ::
+# .. code-block:: sh
 #
 #    Model's state_dict:
 #    conv1.weight     torch.Size([6, 3, 5, 5])
@@ -153,9 +153,15 @@
 # .. code:: python
 #
 #    model = TheModelClass(*args, **kwargs)
-#    model.load_state_dict(torch.load(PATH))
+#    model.load_state_dict(torch.load(PATH, weights_only=True))
 #    model.eval()
 #
+# .. note::
+#     The 1.6 release of PyTorch switched ``torch.save`` to use a new
+#     zip file-based format. ``torch.load`` still retains the ability to
+#     load files in the old format. If for any reason you want ``torch.save``
+#     to use the old format, pass the ``kwarg`` parameter ``_use_new_zipfile_serialization=False``.
+#
 # When saving a model for inference, it is only necessary to save the
 # trained model’s learned parameters. Saving the model’s *state_dict* with
 # the ``torch.save()`` function will give you the most flexibility for
@@ -169,7 +175,7 @@
 # normalization layers to evaluation mode before running inference.
 # Failing to do this will yield inconsistent inference results.
 #
-# .. Note ::
+# .. note::
 #
 #    Notice that the ``load_state_dict()`` function takes a dictionary
 #    object, NOT a path to a saved object. This means that you must
@@ -177,6 +183,14 @@
 #    ``load_state_dict()`` function. For example, you CANNOT load using
 #    ``model.load_state_dict(PATH)``.
 #
+# .. note::
+#    
+#    If you only plan to keep the best performing model (according to the 
+#    acquired validation loss), don't forget that ``best_model_state = model.state_dict()``
+#    returns a reference to the state and not its copy! You must serialize 
+#    ``best_model_state`` or use ``best_model_state = deepcopy(model.state_dict())`` otherwise
+#    your best ``best_model_state`` will keep getting updated by the subsequent training 
+#    iterations. As a result, the final model state will be the state of the overfitted model. 
 #
 # Save/Load Entire Model
 # ^^^^^^^^^^^^^^^^^^^^^^
@@ -192,7 +206,7 @@
 # .. code:: python
 #
 #    # Model class must be defined somewhere
-#    model = torch.load(PATH)
+#    model = torch.load(PATH, weights_only=False)
 #    model.eval()
 #
 # This save/load process uses the most intuitive syntax and involves the
@@ -213,7 +227,30 @@
 # normalization layers to evaluation mode before running inference.
 # Failing to do this will yield inconsistent inference results.
 #
-
+# Saving an Exported Program
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# If you are using ``torch.export``, you can save and load your ``ExportedProgram`` using the
+# ``torch.export.save()`` and ``torch.export.load()`` APIs. with the ``.pt2`` file extension:
+#
+# .. code-block:: python
+# 
+#    class SimpleModel(torch.nn.Module):
+#         def forward(self, x):
+#             return x + 10
+#
+#    # Create a sample input
+#    sample_input = torch.randn(5)
+# 
+#    # Export the model
+#    exported_program = torch.export.export(SimpleModel(), sample_input)
+#
+#    # Save the exported program
+#    torch.export.save(exported_program, 'exported_program.pt2')
+#
+#    # Load the exported program
+#    saved_exported_program = torch.export.load('exported_program.pt2')
+#
 
 ######################################################################
 # Saving & Loading a General Checkpoint for Inference and/or Resuming Training
@@ -240,7 +277,7 @@
 #    model = TheModelClass(*args, **kwargs)
 #    optimizer = TheOptimizerClass(*args, **kwargs)
 #
-#    checkpoint = torch.load(PATH)
+#    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']
@@ -252,11 +289,12 @@
 #
 # When saving a general checkpoint, to be used for either inference or
 # resuming training, you must save more than just the model’s
-# *state_dict*. It is important to also save the optimizer’s *state_dict*,
+# *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, etc.
+# layers, etc. As a result, such a checkpoint is often 2~3 times larger 
+# than the model alone.
 #
 # To save multiple components, organize them in a dictionary and use
 # ``torch.save()`` to serialize the dictionary. A common PyTorch
@@ -303,7 +341,7 @@
 #    optimizerA = TheOptimizerAClass(*args, **kwargs)
 #    optimizerB = TheOptimizerBClass(*args, **kwargs)
 #
-#    checkpoint = torch.load(PATH)
+#    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'])
@@ -356,7 +394,7 @@
 # .. code:: python
 #
 #    modelB = TheModelBClass(*args, **kwargs)
-#    modelB.load_state_dict(torch.load(PATH), strict=False)
+#    modelB.load_state_dict(torch.load(PATH, weights_only=True), strict=False)
 #
 # Partially loading a model or loading a partial model are common
 # scenarios when transfer learning or training a new complex model.
@@ -395,7 +433,7 @@
 #
 #    device = torch.device('cpu')
 #    model = TheModelClass(*args, **kwargs)
-#    model.load_state_dict(torch.load(PATH, map_location=device))
+#    model.load_state_dict(torch.load(PATH, map_location=device, weights_only=True))
 #
 # When loading a model on a CPU that was trained with a GPU, pass
 # ``torch.device('cpu')`` to the ``map_location`` argument in the
@@ -418,7 +456,7 @@
 #
 #    device = torch.device("cuda")
 #    model = TheModelClass(*args, **kwargs)
-#    model.load_state_dict(torch.load(PATH))
+#    model.load_state_dict(torch.load(PATH, weights_only=True))
 #    model.to(device)
 #    # Make sure to call input = input.to(device) on any input tensors that you feed to the model
 #
@@ -446,13 +484,13 @@
 #
 #    device = torch.device("cuda")
 #    model = TheModelClass(*args, **kwargs)
-#    model.load_state_dict(torch.load(PATH, map_location="cuda:0"))  # Choose whatever GPU device number you want
+#    model.load_state_dict(torch.load(PATH, weights_only=True, map_location="cuda:0"))  # Choose whatever GPU device number you want
 #    model.to(device)
 #    # Make sure to call input = input.to(device) on any input tensors that you feed to the model
 #
 # 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. Next, be
+# ``cuda:device_id``. This loads the model to a given GPU device. Next, be
 # sure to call ``model.to(torch.device('cuda'))`` to convert the model’s
 # parameter tensors to CUDA tensors. Finally, be sure to use the
 # ``.to(torch.device('cuda'))`` function on all model inputs to prepare
diff --git a/beginner_source/t5_tutoria.rst b/beginner_source/t5_tutoria.rst
new file mode 100644
index 00000000000..65de42b9320
--- /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/template_tutorial.py b/beginner_source/template_tutorial.py
new file mode 100644
index 00000000000..d7fae7c4c5e
--- /dev/null
+++ b/beginner_source/template_tutorial.py
@@ -0,0 +1,94 @@
+# -*- coding: utf-8 -*-
+
+"""
+Template Tutorial
+=================
+
+**Author:** `FirstName LastName <https://github.com/username>`_
+
+.. grid:: 2
+
+    .. grid-item-card:: :octicon:`mortar-board;1em;` What you will learn
+       :class-card: card-prerequisites
+
+       * Item 1
+       * Item 2
+       * Item 3
+
+    .. grid-item-card:: :octicon:`list-unordered;1em;` Prerequisites
+       :class-card: card-prerequisites
+
+       * PyTorch v2.0.0
+       * GPU ???
+       * Other items 3
+
+If you have a video, add it here like this:
+
+.. raw:: html
+
+   <div style="margin-top:10px; margin-bottom:10px;">
+     <iframe width="560" height="315" src="https://www.youtube.com/embed/IC0_FRiX-sw" frameborder="0" allow="accelerometer; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
+   </div>
+
+To test your tutorial locally, you can do one of the following:
+
+*  You can control specific files that generate the results by using
+   ``GALLERY_PATTERN`` environment variable. The GALLERY_PATTERN variable
+   respects regular expressions.
+   For example to run only ``neural_style_transfer_tutorial.py``,
+   use the following command:
+
+   .. code-block:: sh
+
+      GALLERY_PATTERN="neural_style_transfer_tutorial.py" make html
+
+   or
+
+   .. code-block:: sh
+
+      GALLERY_PATTERN="neural_style_transfer_tutorial.py" sphinx-build . _build
+
+* Make a copy of this repository and add only your
+  tutorial to the `beginner_source` directory removing all other tutorials.
+  Then run ``make html``.
+  
+Verify that all outputs were generated correctly in the created HTML.
+"""
+
+#########################################################################
+# Overview
+# --------
+#
+# Describe Why is this topic important? Add Links to relevant research papers.
+#
+# This tutorial walks you through the process of....
+#
+# Steps
+# -----
+#
+# Example code (the output below is generated automatically):
+# 
+import torch
+x = torch.rand(5, 3)
+print(x)
+
+######################################################################
+# (Optional) Additional Exercises
+# -------------------------------
+#
+# Add additional practice exercises for users to test their knowledge.
+# Example: `NLP from Scratch <https://pytorch.org/tutorials/intermediate/char_rnn_generation_tutorial.html#exercises>`__.
+#
+
+######################################################################
+# Conclusion
+# ----------
+# 
+# Summarize the steps and concepts covered. Highlight key takeaways.
+#
+# Further Reading
+# ---------------
+#
+# * Link1
+# * Link2
+
diff --git a/beginner_source/text_sentiment_ngrams_tutorial.rst b/beginner_source/text_sentiment_ngrams_tutorial.rst
new file mode 100644
index 00000000000..024d04056c5
--- /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.rst b/beginner_source/torchtext_custom_dataset_tutorial.rst
new file mode 100644
index 00000000000..9f014f3ff9a
--- /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/transfer_learning_tutorial.py b/beginner_source/transfer_learning_tutorial.py
index 755d4d5d67e..8a344d3d88a 100644
--- a/beginner_source/transfer_learning_tutorial.py
+++ b/beginner_source/transfer_learning_tutorial.py
@@ -1,12 +1,12 @@
 # -*- coding: utf-8 -*-
 """
-Transfer Learning Tutorial
-==========================
+Transfer Learning for Computer Vision Tutorial
+==============================================
 **Author**: `Sasank Chilamkurthy <https://chsasank.github.io>`_
 
-In this tutorial, you will learn how to train your network using
-transfer learning. You can read more about the transfer learning at `cs231n
-notes <https://cs231n.github.io/transfer-learning/>`__
+In this tutorial, you will learn how to train a convolutional neural network for
+image classification using transfer learning. You can read more about the transfer
+learning at `cs231n notes <https://cs231n.github.io/transfer-learning/>`__
 
 Quoting these notes,
 
@@ -20,7 +20,7 @@
 
 These two major transfer learning scenarios look as follows:
 
--  **Finetuning the convnet**: Instead of random initializaion, we
+-  **Finetuning the ConvNet**: Instead of random initialization, we
    initialize the network with a pretrained network, like the one that is
    trained on imagenet 1000 dataset. Rest of the training looks as
    usual.
@@ -33,20 +33,21 @@
 # License: BSD
 # Author: Sasank Chilamkurthy
 
-from __future__ import print_function, division
-
 import torch
 import torch.nn as nn
 import torch.optim as optim
 from torch.optim import lr_scheduler
+import torch.backends.cudnn as cudnn
 import numpy as np
 import torchvision
 from torchvision import datasets, models, transforms
 import matplotlib.pyplot as plt
 import time
 import os
-import copy
+from PIL import Image
+from tempfile import TemporaryDirectory
 
+cudnn.benchmark = True
 plt.ion()   # interactive mode
 
 ######################################################################
@@ -97,7 +98,11 @@
 dataset_sizes = {x: len(image_datasets[x]) for x in ['train', 'val']}
 class_names = image_datasets['train'].classes
 
-device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+# We want to be able to train our model on an `accelerator <https://pytorch.org/docs/stable/torch.html#accelerators>`__
+# such as CUDA, MPS, MTIA, or XPU. If the current accelerator is available, we will use it. Otherwise, we use the CPU.
+
+device = torch.accelerator.current_accelerator().type if torch.accelerator.is_available() else "cpu"
+print(f"Using {device} device")
 
 ######################################################################
 # Visualize a few images
@@ -106,7 +111,7 @@
 # augmentations.
 
 def imshow(inp, title=None):
-    """Imshow for Tensor."""
+    """Display image for Tensor."""
     inp = inp.numpy().transpose((1, 2, 0))
     mean = np.array([0.485, 0.456, 0.406])
     std = np.array([0.229, 0.224, 0.225])
@@ -144,68 +149,71 @@ def imshow(inp, title=None):
 def train_model(model, criterion, optimizer, scheduler, num_epochs=25):
     since = time.time()
 
-    best_model_wts = copy.deepcopy(model.state_dict())
-    best_acc = 0.0
-
-    for epoch in range(num_epochs):
-        print('Epoch {}/{}'.format(epoch, num_epochs - 1))
-        print('-' * 10)
-
-        # Each epoch has a training and validation phase
-        for phase in ['train', 'val']:
-            if phase == 'train':
-                scheduler.step()
-                model.train()  # Set model to training mode
-            else:
-                model.eval()   # Set model to evaluate mode
-
-            running_loss = 0.0
-            running_corrects = 0
-
-            # Iterate over data.
-            for inputs, labels in dataloaders[phase]:
-                inputs = inputs.to(device)
-                labels = labels.to(device)
-
-                # zero the parameter gradients
-                optimizer.zero_grad()
-
-                # forward
-                # track history if only in train
-                with torch.set_grad_enabled(phase == 'train'):
-                    outputs = model(inputs)
-                    _, preds = torch.max(outputs, 1)
-                    loss = criterion(outputs, labels)
-
-                    # backward + optimize only if in training phase
-                    if phase == 'train':
-                        loss.backward()
-                        optimizer.step()
-
-                # statistics
-                running_loss += loss.item() * inputs.size(0)
-                running_corrects += torch.sum(preds == labels.data)
-
-            epoch_loss = running_loss / dataset_sizes[phase]
-            epoch_acc = running_corrects.double() / dataset_sizes[phase]
-
-            print('{} Loss: {:.4f} Acc: {:.4f}'.format(
-                phase, epoch_loss, epoch_acc))
-
-            # deep copy the model
-            if phase == 'val' and epoch_acc > best_acc:
-                best_acc = epoch_acc
-                best_model_wts = copy.deepcopy(model.state_dict())
-
-        print()
-
-    time_elapsed = time.time() - since
-    print('Training complete in {:.0f}m {:.0f}s'.format(
-        time_elapsed // 60, time_elapsed % 60))
-    print('Best val Acc: {:4f}'.format(best_acc))
-
-    # load best model weights
-    model.load_state_dict(best_model_wts)
+    # Create a temporary directory to save training checkpoints
+    with TemporaryDirectory() as tempdir:
+        best_model_params_path = os.path.join(tempdir, 'best_model_params.pt')
+    
+        torch.save(model.state_dict(), best_model_params_path)
+        best_acc = 0.0
+
+        for epoch in range(num_epochs):
+            print(f'Epoch {epoch}/{num_epochs - 1}')
+            print('-' * 10)
+
+            # Each epoch has a training and validation phase
+            for phase in ['train', 'val']:
+                if phase == 'train':
+                    model.train()  # Set model to training mode
+                else:
+                    model.eval()   # Set model to evaluate mode
+
+                running_loss = 0.0
+                running_corrects = 0
+
+                # Iterate over data.
+                for inputs, labels in dataloaders[phase]:
+                    inputs = inputs.to(device)
+                    labels = labels.to(device)
+
+                    # zero the parameter gradients
+                    optimizer.zero_grad()
+
+                    # forward
+                    # track history if only in train
+                    with torch.set_grad_enabled(phase == 'train'):
+                        outputs = model(inputs)
+                        _, preds = torch.max(outputs, 1)
+                        loss = criterion(outputs, labels)
+
+                        # backward + optimize only if in training phase
+                        if phase == 'train':
+                            loss.backward()
+                            optimizer.step()
+
+                    # statistics
+                    running_loss += loss.item() * inputs.size(0)
+                    running_corrects += torch.sum(preds == labels.data)
+                if phase == 'train':
+                    scheduler.step()
+
+                epoch_loss = running_loss / dataset_sizes[phase]
+                epoch_acc = running_corrects.double() / dataset_sizes[phase]
+
+                print(f'{phase} Loss: {epoch_loss:.4f} Acc: {epoch_acc:.4f}')
+
+                # deep copy the model
+                if phase == 'val' and epoch_acc > best_acc:
+                    best_acc = epoch_acc
+                    torch.save(model.state_dict(), best_model_params_path)
+
+            print()
+
+        time_elapsed = time.time() - since
+        print(f'Training complete in {time_elapsed // 60:.0f}m {time_elapsed % 60:.0f}s')
+        print(f'Best val Acc: {best_acc:4f}')
+
+        # load best model weights
+        model.load_state_dict(torch.load(best_model_params_path, weights_only=True))
     return model
 
 
@@ -234,7 +242,7 @@ def visualize_model(model, num_images=6):
                 images_so_far += 1
                 ax = plt.subplot(num_images//2, 2, images_so_far)
                 ax.axis('off')
-                ax.set_title('predicted: {}'.format(class_names[preds[j]]))
+                ax.set_title(f'predicted: {class_names[preds[j]]}')
                 imshow(inputs.cpu().data[j])
 
                 if images_so_far == num_images:
@@ -243,14 +251,16 @@ def visualize_model(model, num_images=6):
         model.train(mode=was_training)
 
 ######################################################################
-# Finetuning the convnet
+# Finetuning the ConvNet
 # ----------------------
 #
 # Load a pretrained model and reset final fully connected layer.
 #
 
-model_ft = models.resnet18(pretrained=True)
+model_ft = models.resnet18(weights='IMAGENET1K_V1')
 num_ftrs = model_ft.fc.in_features
+# Here the size of each output sample is set to 2.
+# Alternatively, it can be generalized to ``nn.Linear(num_ftrs, len(class_names))``.
 model_ft.fc = nn.Linear(num_ftrs, 2)
 
 model_ft = model_ft.to(device)
@@ -285,14 +295,14 @@ def visualize_model(model, num_images=6):
 # ----------------------------------
 #
 # Here, we need to freeze all the network except the final layer. We need
-# to set ``requires_grad == False`` to freeze the parameters so that the
+# to set ``requires_grad = False`` to freeze the parameters so that the
 # gradients are not computed in ``backward()``.
 #
 # You can read more about this in the documentation
 # `here <https://pytorch.org/docs/notes/autograd.html#excluding-subgraphs-from-backward>`__.
 #
 
-model_conv = torchvision.models.resnet18(pretrained=True)
+model_conv = torchvision.models.resnet18(weights='IMAGENET1K_V1')
 for param in model_conv.parameters():
     param.requires_grad = False
 
@@ -331,3 +341,54 @@ def visualize_model(model, num_images=6):
 
 plt.ioff()
 plt.show()
+
+
+######################################################################
+# Inference on custom images
+# --------------------------
+#
+# Use the trained model to make predictions on custom images and visualize
+# the predicted class labels along with the images.
+#
+
+def visualize_model_predictions(model,img_path):
+    was_training = model.training
+    model.eval()
+
+    img = Image.open(img_path)
+    img = data_transforms['val'](img)
+    img = img.unsqueeze(0)
+    img = img.to(device)
+
+    with torch.no_grad():
+        outputs = model(img)
+        _, preds = torch.max(outputs, 1)
+
+        ax = plt.subplot(2,2,1)
+        ax.axis('off')
+        ax.set_title(f'Predicted: {class_names[preds[0]]}')
+        imshow(img.cpu().data[0])
+        
+        model.train(mode=was_training)
+
+######################################################################
+#
+
+visualize_model_predictions(
+    model_conv,
+    img_path='data/hymenoptera_data/val/bees/72100438_73de9f17af.jpg'
+)
+
+plt.ioff()
+plt.show()
+
+
+######################################################################
+# Further Learning
+# -----------------
+#
+# If you would like to learn more about the applications of transfer learning,
+# checkout our `Quantized Transfer Learning for Computer Vision Tutorial <https://pytorch.org/tutorials/intermediate/quantized_transfer_learning_tutorial.html>`_.
+#
+#
+
diff --git a/beginner_source/transformer_tutorial.rst b/beginner_source/transformer_tutorial.rst
new file mode 100644
index 00000000000..0bb2ffc784f
--- /dev/null
+++ b/beginner_source/transformer_tutorial.rst
@@ -0,0 +1,8 @@
+Language Modeling with ``nn.Transformer`` and torchtext
+=======================================================
+
+The content is deprecated.
+
+.. raw:: html
+
+   <meta http-equiv="Refresh" content="1; url='https://pytorch.org/tutorials/'" />
diff --git a/beginner_source/translation_transformer.rst b/beginner_source/translation_transformer.rst
new file mode 100644
index 00000000000..892c1b73ca5
--- /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/beginner_source/understanding_leaf_vs_nonleaf_tutorial.py b/beginner_source/understanding_leaf_vs_nonleaf_tutorial.py
new file mode 100644
index 00000000000..740c4d4bd76
--- /dev/null
+++ b/beginner_source/understanding_leaf_vs_nonleaf_tutorial.py
@@ -0,0 +1,339 @@
+"""
+Understanding requires_grad, retain_grad, Leaf, and Non-leaf Tensors
+====================================================================
+
+**Author:** `Justin Silver <https://github.com/j-silv>`__
+
+This tutorial explains the subtleties of ``requires_grad``,
+``retain_grad``, leaf, and non-leaf tensors using a simple example.
+
+Before starting, make sure you understand `tensors and how to manipulate
+them <https://docs.pytorch.org/tutorials/beginner/basics/tensorqs_tutorial.html>`__.
+A basic knowledge of `how autograd
+works <https://docs.pytorch.org/tutorials/beginner/basics/autogradqs_tutorial.html>`__
+would also be useful.
+
+"""
+
+
+######################################################################
+# Setup
+# -----
+#
+# First, make sure `PyTorch is
+# installed <https://pytorch.org/get-started/locally/>`__ and then import
+# the necessary libraries.
+#
+
+import torch
+import torch.nn.functional as F
+
+
+######################################################################
+# Next, we instantiate a simple network to focus on the gradients. This
+# will be an affine layer, followed by a ReLU activation, and ending with
+# a MSE loss between prediction and label tensors.
+#
+# .. math::
+#
+#    \mathbf{y}_{\text{pred}} = \text{ReLU}(\mathbf{x} \mathbf{W} + \mathbf{b})
+#
+# .. math::
+#
+#    L = \text{MSE}(\mathbf{y}_{\text{pred}}, \mathbf{y})
+#
+# Note that the ``requires_grad=True`` is necessary for the parameters
+# (``W`` and ``b``) so that PyTorch tracks operations involving those
+# tensors. We’ll discuss more about this in a future
+# `section <#requires-grad>`__.
+#
+
+# tensor setup
+x = torch.ones(1, 3)                      # input with shape: (1, 3)
+W = torch.ones(3, 2, requires_grad=True)  # weights with shape: (3, 2)
+b = torch.ones(1, 2, requires_grad=True)  # bias with shape: (1, 2)
+y = torch.ones(1, 2)                      # output with shape: (1, 2)
+
+# forward pass
+z = (x @ W) + b                           # pre-activation with shape: (1, 2)
+y_pred = F.relu(z)                        # activation with shape: (1, 2)
+loss = F.mse_loss(y_pred, y)              # scalar loss
+
+
+######################################################################
+# Leaf vs. non-leaf tensors
+# -------------------------
+#
+# After running the forward pass, PyTorch autograd has built up a `dynamic
+# computational
+# graph <https://docs.pytorch.org/tutorials/beginner/blitz/autograd_tutorial.html#computational-graph>`__
+# which is shown below. This is a `Directed Acyclic Graph
+# (DAG) <https://en.wikipedia.org/wiki/Directed_acyclic_graph>`__ which
+# keeps a record of input tensors (leaf nodes), all subsequent operations
+# on those tensors, and the intermediate/output tensors (non-leaf nodes).
+# The graph is used to compute gradients for each tensor starting from the
+# graph roots (outputs) to the leaves (inputs) using the `chain
+# rule <https://en.wikipedia.org/wiki/Chain_rule>`__ from calculus:
+#
+# .. math::
+#
+#    \mathbf{y} = \mathbf{f}_k\bigl(\mathbf{f}_{k-1}(\dots \mathbf{f}_1(\mathbf{x}) \dots)\bigr)
+#
+# .. math::
+#
+#    \frac{\partial \mathbf{y}}{\partial \mathbf{x}} =
+#    \frac{\partial \mathbf{f}_k}{\partial \mathbf{f}_{k-1}} \cdot
+#    \frac{\partial \mathbf{f}_{k-1}}{\partial \mathbf{f}_{k-2}} \cdot
+#    \cdots \cdot
+#    \frac{\partial \mathbf{f}_1}{\partial \mathbf{x}}
+#
+# .. figure:: /_static/img/understanding_leaf_vs_nonleaf/comp-graph-1.png
+#    :alt: Computational graph after forward pass
+#
+#    Computational graph after forward pass
+#
+# PyTorch considers a node to be a *leaf* if it is not the result of a
+# tensor operation with at least one input having ``requires_grad=True``
+# (e.g. ``x``, ``W``, ``b``, and ``y``), and everything else to be
+# *non-leaf* (e.g. ``z``, ``y_pred``, and ``loss``). You can verify this
+# programmatically by probing the ``is_leaf`` attribute of the tensors:
+#
+
+# prints True because new tensors are leafs by convention
+print(f"{x.is_leaf=}")
+
+# prints False because tensor is the result of an operation with at
+# least one input having requires_grad=True
+print(f"{z.is_leaf=}")
+
+
+######################################################################
+# The distinction between leaf and non-leaf determines whether the
+# tensor’s gradient will be stored in the ``grad`` property after the
+# backward pass, and thus be usable for `gradient
+# descent <https://en.wikipedia.org/wiki/Gradient_descent>`__. We’ll cover
+# this some more in the `following section <#retain-grad>`__.
+#
+# Let’s now investigate how PyTorch calculates and stores gradients for
+# the tensors in its computational graph.
+#
+
+
+######################################################################
+# ``requires_grad``
+# -----------------
+#
+# To build the computational graph which can be used for gradient
+# calculation, we need to pass in the ``requires_grad=True`` parameter to
+# a tensor constructor. By default, the value is ``False``, and thus
+# PyTorch does not track gradients on any created tensors. To verify this,
+# try not setting ``requires_grad``, re-run the forward pass, and then run
+# backpropagation. You will see:
+#
+# ::
+#
+#    >>> loss.backward()
+#    RuntimeError: element 0 of tensors does not require grad and does not have a grad_fn
+#
+# This error means that autograd can’t backpropagate to any leaf tensors
+# because ``loss`` is not tracking gradients. If you need to change the
+# property, you can call ``requires_grad_()`` on the tensor (notice the \_
+# suffix).
+#
+# We can sanity check which nodes require gradient calculation, just like
+# we did above with the ``is_leaf`` attribute:
+#
+
+print(f"{x.requires_grad=}") # prints False because requires_grad=False by default
+print(f"{W.requires_grad=}") # prints True because we set requires_grad=True in constructor
+print(f"{z.requires_grad=}") # prints True because tensor is a non-leaf node
+
+
+######################################################################
+# It’s useful to remember that a non-leaf tensor has
+# ``requires_grad=True`` by definition, since backpropagation would fail
+# otherwise. If the tensor is a leaf, then it will only have
+# ``requires_grad=True`` if it was specifically set by the user. Another
+# way to phrase this is that if at least one of the inputs to a tensor
+# requires the gradient, then it will require the gradient as well.
+#
+# There are two exceptions to this rule:
+#
+# 1. Any ``nn.Module`` that has ``nn.Parameter`` will have
+#    ``requires_grad=True`` for its parameters (see
+#    `here <https://docs.pytorch.org/tutorials/beginner/basics/quickstart_tutorial.html#creating-models>`__)
+# 2. Locally disabling gradient computation with context managers (see
+#    `here <https://docs.pytorch.org/docs/stable/notes/autograd.html#locally-disabling-gradient-computation>`__)
+#
+# In summary, ``requires_grad`` tells autograd which tensors need to have
+# their gradients calculated for backpropagation to work. This is
+# different from which tensors have their ``grad`` field populated, which
+# is the topic of the next section.
+#
+
+
+######################################################################
+# ``retain_grad``
+# ---------------
+#
+# To actually perform optimization (e.g. SGD, Adam, etc.), we need to run
+# the backward pass so that we can extract the gradients.
+#
+
+loss.backward()
+
+
+######################################################################
+# Calling ``backward()`` populates the ``grad`` field of all leaf tensors
+# which had ``requires_grad=True``. The ``grad`` is the gradient of the
+# loss with respect to the tensor we are probing. Before running
+# ``backward()``, this attribute is set to ``None``.
+#
+
+print(f"{W.grad=}")
+print(f"{b.grad=}")
+
+
+######################################################################
+# You might be wondering about the other tensors in our network. Let’s
+# check the remaining leaf nodes:
+#
+
+# prints all None because requires_grad=False
+print(f"{x.grad=}")
+print(f"{y.grad=}")
+
+
+######################################################################
+# The gradients for these tensors haven’t been populated because we did
+# not explicitly tell PyTorch to calculate their gradient
+# (``requires_grad=False``).
+#
+# Let’s now look at an intermediate non-leaf node:
+#
+
+print(f"{z.grad=}")
+
+
+######################################################################
+# PyTorch returns ``None`` for the gradient and also warns us that a
+# non-leaf node’s ``grad`` attribute is being accessed. Although autograd
+# has to calculate intermediate gradients for backpropagation to work, it
+# assumes you don’t need to access the values afterwards. To change this
+# behavior, we can use the ``retain_grad()`` function on a tensor. This
+# tells the autograd engine to populate that tensor’s ``grad`` after
+# calling ``backward()``.
+#
+
+# we have to re-run the forward pass
+z = (x @ W) + b
+y_pred = F.relu(z)
+loss = F.mse_loss(y_pred, y)
+
+# tell PyTorch to store the gradients after backward()
+z.retain_grad()
+y_pred.retain_grad()
+loss.retain_grad()
+
+# have to zero out gradients otherwise they would accumulate
+W.grad = None
+b.grad = None
+
+# backpropagation
+loss.backward()
+
+# print gradients for all tensors that have requires_grad=True
+print(f"{W.grad=}")
+print(f"{b.grad=}")
+print(f"{z.grad=}")
+print(f"{y_pred.grad=}")
+print(f"{loss.grad=}")
+
+
+######################################################################
+# We get the same result for ``W.grad`` as before. Also note that because
+# the loss is scalar, the gradient of the loss with respect to itself is
+# simply ``1.0``.
+#
+# If we look at the state of the computational graph now, we see that the
+# ``retains_grad`` attribute has changed for the intermediate tensors. By
+# convention, this attribute will print ``False`` for any leaf node, even
+# if it requires its gradient.
+#
+# .. figure:: /_static/img/understanding_leaf_vs_nonleaf/comp-graph-2.png
+#    :alt: Computational graph after backward pass
+#
+#    Computational graph after backward pass
+#
+# If you call ``retain_grad()`` on a non-leaf node, it results in a no-op.
+# If we call ``retain_grad()`` on a node that has ``requires_grad=False``,
+# PyTorch actually throws an error, since it can’t store the gradient if
+# it is never calculated.
+#
+# ::
+#
+#    >>> x.retain_grad()
+#    RuntimeError: can't retain_grad on Tensor that has requires_grad=False
+#
+
+
+######################################################################
+# Summary table
+# -------------
+#
+# Using ``retain_grad()`` and ``retains_grad`` only make sense for
+# non-leaf nodes, since the ``grad`` attribute will already be populated
+# for leaf tensors that have ``requires_grad=True``. By default, these
+# non-leaf nodes do not retain (store) their gradient after
+# backpropagation. We can change that by rerunning the forward pass,
+# telling PyTorch to store the gradients, and then performing
+# backpropagation.
+#
+# The following table can be used as a reference which summarizes the
+# above discussions. The following scenarios are the only ones that are
+# valid for PyTorch tensors.
+#
+#
+#
+# +----------------+------------------------+------------------------+---------------------------------------------------+-------------------------------------+
+# |  ``is_leaf``   |   ``requires_grad``    |   ``retains_grad``     |  ``require_grad()``                               |   ``retain_grad()``                 |
+# +================+========================+========================+===================================================+=====================================+
+# | ``True``       | ``False``              | ``False``              | sets ``requires_grad`` to ``True`` or ``False``   | no-op                               |
+# +----------------+------------------------+------------------------+---------------------------------------------------+-------------------------------------+
+# | ``True``       | ``True``               | ``False``              | sets ``requires_grad`` to ``True`` or ``False``   | no-op                               |
+# +----------------+------------------------+------------------------+---------------------------------------------------+-------------------------------------+
+# | ``False``      | ``True``               | ``False``              | no-op                                             | sets ``retains_grad`` to ``True``   |
+# +----------------+------------------------+------------------------+---------------------------------------------------+-------------------------------------+
+# | ``False``      | ``True``               | ``True``               | no-op                                             | no-op                               |
+# +----------------+------------------------+------------------------+---------------------------------------------------+-------------------------------------+
+#
+
+
+######################################################################
+# Conclusion
+# ----------
+#
+# In this tutorial, we covered when and how PyTorch computes gradients for
+# leaf and non-leaf tensors. By using ``retain_grad``, we can access the
+# gradients of intermediate tensors within autograd’s computational graph.
+#
+# If you would like to learn more about how PyTorch’s autograd system
+# works, please visit the `references <#references>`__ below. If you have
+# any feedback for this tutorial (improvements, typo fixes, etc.) then
+# please use the `PyTorch Forums <https://discuss.pytorch.org/>`__ and/or
+# the `issue tracker <https://github.com/pytorch/tutorials/issues>`__ to
+# reach out.
+#
+
+
+######################################################################
+# References
+# ----------
+#
+# -  `A Gentle Introduction to
+#    torch.autograd <https://docs.pytorch.org/tutorials/beginner/blitz/autograd_tutorial.html>`__
+# -  `Automatic Differentiation with
+#    torch.autograd <https://docs.pytorch.org/tutorials/beginner/basics/autogradqs_tutorial>`__
+# -  `Autograd
+#    mechanics <https://docs.pytorch.org/docs/stable/notes/autograd.html>`__
+#
\ No newline at end of file
diff --git a/build.sh b/build.sh
old mode 100644
new mode 100755
diff --git a/compilers_index.rst b/compilers_index.rst
new file mode 100644
index 00000000000..7befbbce9f5
--- /dev/null
+++ b/compilers_index.rst
@@ -0,0 +1,216 @@
+Compilers
+=========
+
+Explore PyTorch compilers to optimize and deploy models efficiently.
+Learn about APIs like ``torch.compile`` and ``torch.export``
+that let you enhance model performance and streamline deployment
+processes.
+Explore advanced topics such as compiled autograd, dynamic compilation
+control, as well as third-party backend solutions.
+
+.. warning::
+
+   TorchScript is no longer in active development.
+
+.. raw:: html
+
+    <div id="tutorial-cards-container">
+
+    <nav class="navbar navbar-expand-lg navbar-light tutorials-nav col-12">
+        <div class="tutorial-tags-container">
+            <div id="dropdown-filter-tags">
+                <div class="tutorial-filter-menu">
+                    <div class="tutorial-filter filter-btn all-tag-selected" data-tag="all">All</div>
+                </div>
+            </div>
+        </div>
+    </nav>
+
+    <hr class="tutorials-hr">
+
+    <div class="row">
+
+    <div id="tutorial-cards">
+    <div class="list">
+
+.. customcarditem::
+   :header: torch.compile Tutorial
+   :card_description: Speed up your models with minimal code changes using torch.compile, the latest PyTorch compiler solution.
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: intermediate/torch_compile_tutorial.html
+   :tags: Model-Optimization,torch.compile
+
+.. customcarditem::
+   :header: Compiled Autograd: Capturing a larger backward graph for torch.compile
+   :card_description: Learn how to use compiled autograd to capture a larger backward graph.
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: intermediate/compiled_autograd_tutorial.html
+   :tags: Model-Optimization,CUDA,torch.compile
+
+.. customcarditem::
+   :header: Inductor CPU Backend Debugging and Profiling
+   :card_description: Learn the usage, debugging and performance profiling for ``torch.compile`` with Inductor CPU backend.
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: intermediate/inductor_debug_cpu.html
+   :tags: Model-Optimization,torch.compile
+
+.. customcarditem::
+   :header: Dynamic Compilation Control with torch.compiler.set_stance
+   :card_description: Learn how to use torch.compiler.set_stance
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: recipes/torch_compiler_set_stance_tutorial.html
+   :tags: Model-Optimization,torch.compile
+
+.. customcarditem::
+   :header: Demonstration of torch.export flow, common challenges and the solutions to address them
+   :card_description: Learn how to export models for popular usecases
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: recipes/torch_export_challenges_solutions.html
+   :tags: Model-Optimization,torch.compile
+
+.. customcarditem::
+   :header: (beta) Compiling the Optimizer with torch.compile
+   :card_description: Speed up the optimizer using torch.compile
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: recipes/compiling_optimizer.html
+   :tags: Model-Optimization,torch.compile
+
+.. customcarditem::
+   :header: (beta) Running the compiled optimizer with an LR Scheduler
+   :card_description: Speed up training with LRScheduler and torch.compiled optimizer
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: recipes/compiling_optimizer_lr_scheduler.html
+   :tags: Model-Optimization,torch.compile
+
+.. customcarditem::
+   :header: Using User-Defined Triton Kernels with ``torch.compile``
+   :card_description: Learn how to use user-defined kernels with ``torch.compile``
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: recipes/torch_compile_user_defined_triton_kernel_tutorial.html
+   :tags: Model-Optimization,torch.compile
+
+.. customcarditem::
+   :header: Compile Time Caching in ``torch.compile``
+   :card_description: Learn how to use compile time caching in ``torch.compile``
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: recipes/torch_compile_caching_tutorial.html
+   :tags: Model-Optimization,torch.compile
+
+.. customcarditem::
+   :header: Compile Time Caching Configurations
+   :card_description: Learn how to configure compile time caching in ``torch.compile``
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: recipes/torch_compile_caching_configuration_tutorial.html
+   :tags: Model-Optimization,torch.compile
+
+.. customcarditem::
+   :header: Reducing torch.compile cold start compilation time with regional compilation
+   :card_description: Learn how to use regional compilation to control cold start compile time
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: recipes/regional_compilation.html
+   :tags: Model-Optimization,torch.compile
+
+.. Export
+.. customcarditem::
+   :header: torch.export AOTInductor Tutorial for Python runtime
+   :card_description: Learn an end-to-end example of how to use AOTInductor for python runtime.
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: recipes/torch_export_aoti_python.html
+   :tags: Basics,torch.export
+
+.. customcarditem::
+   :header: Deep dive into torch.export
+   :card_description: Learn how to use torch.export to export PyTorch models into standardized model representations.
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: intermediate/torch_export_tutorial.html
+   :tags: Basics,torch.export
+
+.. ONNX
+.. customcarditem::
+   :header: (optional) Exporting a PyTorch model to ONNX using TorchDynamo backend and Running it using ONNX Runtime
+   :card_description: Build a image classifier model in PyTorch and convert it to ONNX before deploying it with ONNX Runtime.
+   :image: _static/img/thumbnails/cropped/Exporting-PyTorch-Models-to-ONNX-Graphs.png
+   :link: beginner/onnx/export_simple_model_to_onnx_tutorial.html
+   :tags: Production,ONNX,Backends
+
+.. customcarditem::
+   :header: Extending the ONNX exporter operator support
+   :card_description: Demonstrate end-to-end how to address unsupported operators in ONNX.
+   :image: _static/img/thumbnails/cropped/Exporting-PyTorch-Models-to-ONNX-Graphs.png
+   :link: beginner/onnx/onnx_registry_tutorial.html
+   :tags: Production,ONNX,Backends
+
+.. customcarditem::
+   :header: Exporting a model with control flow to ONNX
+   :card_description: Demonstrate how to handle control flow logic while exporting a PyTorch model to ONNX.
+   :image: _static/img/thumbnails/cropped/Exporting-PyTorch-Models-to-ONNX-Graphs.png
+   :link: beginner/onnx/export_control_flow_model_to_onnx_tutorial.html
+   :tags: Production,ONNX,Backends
+
+.. Code Transformations with FX
+.. customcarditem::
+   :header: Building a Convolution/Batch Norm fuser in FX
+   :card_description: Build a simple FX pass that fuses batch norm into convolution to improve performance during inference.
+   :image: _static/img/thumbnails/cropped/Deploying-PyTorch-in-Python-via-a-REST-API-with-Flask.png
+   :link: intermediate/torch_compile_conv_bn_fuser
+   :tags: FX
+
+.. customcarditem::
+   :header: Building a Simple Performance Profiler with FX
+   :card_description: Build a simple FX interpreter to record the runtime of op, module, and function calls and report statistics
+   :image: _static/img/thumbnails/cropped/Deploying-PyTorch-in-Python-via-a-REST-API-with-Flask.png
+   :link: intermediate/fx_profiling_tutorial.html
+   :tags: FX
+
+.. raw:: html
+
+    </div>
+    </div>
+
+.. End of tutorial cards section
+.. -----------------------------------------
+.. Page TOC
+.. -----------------------------------------
+.. toctree::
+   :maxdepth: 2
+   :hidden:
+   :caption: torch.compile
+
+   intermediate/torch_compile_tutorial
+   intermediate/compiled_autograd_tutorial
+   intermediate/inductor_debug_cpu
+   recipes/torch_compiler_set_stance_tutorial
+   recipes/torch_export_challenges_solutions
+   recipes/compiling_optimizer
+   recipes/compiling_optimizer_lr_scheduler
+   recipes/torch_compile_user_defined_triton_kernel_tutorial
+   recipes/torch_compile_caching_tutorial
+   recipes/regional_compilation
+
+.. toctree::
+   :maxdepth: 2
+   :hidden:
+   :caption: torch.export
+
+   intermediate/torch_export_tutorial
+   recipes/torch_export_aoti_python
+   recipes/torch_export_challenges_solutions
+
+.. toctree::
+   :maxdepth: 2
+   :hidden:
+   :caption: ONNX
+
+   beginner/onnx/intro_onnx
+   beginner/onnx/export_simple_model_to_onnx_tutorial
+   beginner/onnx/onnx_registry_tutorial
+   beginner/onnx/export_control_flow_model_to_onnx_tutorial
+
+.. toctree::
+   :maxdepth: 2
+   :includehidden:
+   :hidden:
+   :caption: Code Transforms with FX
+
+   intermediate/torch_compile_conv_bn_fuser
+   intermediate/fx_profiling_tutorial
diff --git a/conf.py b/conf.py
index 5fc4596ab10..0cb34fd02b3 100644
--- a/conf.py
+++ b/conf.py
@@ -12,6 +12,16 @@
 #
 # All configuration values have a default; values that are commented out
 # serve to show the default.
+#
+
+# Because the sphinx gallery might take a long time, you can control specific
+# files that generate the results using `GALLERY_PATTERN` environment variable,
+# For example to run only `neural_style_transfer_tutorial.py`:
+#   GALLERY_PATTERN="neural_style_transfer_tutorial.py" make html
+# or
+#   GALLERY_PATTERN="neural_style_transfer_tutorial.py" sphinx-build . _build
+#
+# GALLERY_PATTERN variable respects regular expressions.
 
 # If extensions (or modules to document with autodoc) are in another directory,
 # add these directories to sys.path here. If the directory is relative to the
@@ -19,20 +29,93 @@
 #
 import os
 import sys
-sys.path.insert(0, os.path.abspath('.'))
-import pytorch_sphinx_theme
-import torch
+
+sys.path.insert(0, os.path.abspath("."))
+sys.path.insert(0, os.path.abspath("./.jenkins"))
+import pytorch_sphinx_theme2
+
+html_theme = "pytorch_sphinx_theme2"
+html_theme_path = [pytorch_sphinx_theme2.get_html_theme_path()]
+import distutils.file_util
 import glob
+import random
+import re
 import shutil
-from custom_directives import IncludeDirective, GalleryItemDirective, CustomGalleryItemDirective
+from pathlib import Path
+
+import pandocfilters
+import plotly.io as pio
+import pypandoc
+import torch
+from get_sphinx_filenames import SPHINX_SHOULD_RUN
 
+pio.renderers.default = "sphinx_gallery"
+import multiprocessing
+
+import sphinx_gallery.gen_rst
+from redirects import redirects
+
+
+# Monkey patch sphinx gallery to run each example in an isolated process so that
+# we don't need to worry about examples changing global state.
+#
+# Alt option 1: Parallelism was added to sphinx gallery (a later version that we
+# are not using yet) using joblib, but it seems to result in errors for us, and
+# it has no effect if you set parallel = 1 (it will not put each file run into
+# its own process and run singly) so you need parallel >= 2, and there may be
+# tutorials that cannot be run in parallel.
+#
+# Alt option 2: Run sphinx gallery once per file (similar to how we shard in CI
+# but with shard sizes of 1), but running sphinx gallery for each file has a
+# ~5min overhead, resulting in the entire suite taking ~2x time
+def call_fn(func, args, kwargs, result_queue):
+    try:
+        result = func(*args, **kwargs)
+        result_queue.put((True, result))
+    except Exception as e:
+        result_queue.put((False, str(e)))
+
+
+def call_in_subprocess(func):
+    def wrapper(*args, **kwargs):
+        result_queue = multiprocessing.Queue()
+        p = multiprocessing.Process(
+            target=call_fn, args=(func, args, kwargs, result_queue)
+        )
+        p.start()
+        p.join()
+        success, result = result_queue.get()
+        if success:
+            return result
+        else:
+            raise RuntimeError(f"Error in subprocess: {result}")
+
+    return wrapper
+
+
+# Windows does not support multiprocessing with fork and mac has issues with
+# fork so we do not monkey patch sphinx gallery to run in subprocesses.
+if (
+    os.getenv("TUTORIALS_ISOLATE_BUILD", "1") == "1"
+    and not sys.platform.startswith("win")
+    and not sys.platform == "darwin"
+):
+    sphinx_gallery.gen_rst.generate_file_rst = call_in_subprocess(
+        sphinx_gallery.gen_rst.generate_file_rst
+    )
 
 try:
     import torchvision
 except ImportError:
     import warnings
+
     warnings.warn('unable to load "torchvision" package')
-import pytorch_sphinx_theme
+
+rst_epilog = """
+.. |edit| image:: /_static/pencil-16.png
+           :width: 16px
+           :height: 16px
+"""
 
 # -- General configuration ------------------------------------------------
 
@@ -40,82 +123,219 @@
 #
 # needs_sphinx = '1.0'
 
+html_meta = {
+    "description": "Master PyTorch with our step-by-step tutorials for all skill levels. Start your journey to becoming a PyTorch expert today!",
+    "keywords": "PyTorch, tutorials, Getting Started, deep learning, AI",
+    "author": "PyTorch Contributors",
+}
+
 # Add any Sphinx extension module names here, as strings. They can be
 # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
 # ones.
-extensions = ['sphinx.ext.mathjax',
-              'sphinx_gallery.gen_gallery']
+extensions = [
+    "sphinxcontrib.katex",
+    "sphinx.ext.intersphinx",
+    "sphinx_copybutton",
+    "sphinx_gallery.gen_gallery",
+    "sphinx_design",
+    "sphinx_sitemap",
+    "sphinx_reredirects",
+    "sphinxcontrib.mermaid",
+]
 
+intersphinx_mapping = {
+    "torch": ("https://docs.pytorch.org/docs/stable/", None),
+    "tensordict": ("https://docs.pytorch.org/tensordict/stable", None),
+    "torchrl": ("https://docs.pytorch.org/rl/stable", None),
+    "torchaudio": ("https://docs.pytorch.org/audio/stable/", None),
+    "torchtext": ("https://docs.pytorch.org/text/stable/", None),
+    "torchvision": ("https://docs.pytorch.org/vision/stable/", None),
+}
+
+html_meta = {
+    "description": "Master PyTorch with our step-by-step tutorials for all skill levels. Start your journey to becoming a PyTorch expert today!",
+    "keywords": "PyTorch, tutorials, Getting Started, deep learning, AI",
+    "author": "PyTorch Contributors",
+}
 
-# -- Sphinx-gallery configuration --------------------------------------------
 
 
+# -- Sphinx-gallery configuration --------------------------------------------
+
 sphinx_gallery_conf = {
-    'examples_dirs': ['beginner_source', 'intermediate_source',
-                      'advanced_source'],
-    'gallery_dirs': ['beginner', 'intermediate', 'advanced'],
-    'filename_pattern': 'tutorial.py',
-    'backreferences_dir': False
+    "examples_dirs": [
+        "beginner_source",
+        "intermediate_source",
+        "advanced_source",
+        "recipes_source",
+        "unstable_source",
+    ],
+    "gallery_dirs": ["beginner", "intermediate", "advanced", "recipes", "unstable"],
+    "filename_pattern": re.compile(SPHINX_SHOULD_RUN),
+    "promote_jupyter_magic": True,
+    "backreferences_dir": None,
+    "write_computation_times": True,
+    "download_all_examples": False,
+    "show_signature": False,
+    "first_notebook_cell": (
+        "# For tips on running notebooks in Google Colab, see\n"
+        "# https://docs.pytorch.org/tutorials/beginner/colab\n"
+        "%matplotlib inline"
+    ),
+    "ignore_pattern": r"_torch_export_nightly_tutorial.py",
+    "pypandoc": {
+        "extra_args": ["--mathjax", "--toc"],
+        "filters": [".jenkins/custom_pandoc_filter.py"],
+    },
 }
 
-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
+html_additional_pages = {
+    "404": "404.html",
+}
 
-    # Copy rst files from source dir to gallery dir
-    for f in glob.glob(os.path.join(source_dir, '*.rst')):
-        shutil.copy(f, gallery_dir)
 
+html_baseurl = "https://docs.pytorch.org/tutorials/"  # needed for sphinx-sitemap
+sitemap_locales = [None]
+sitemap_excludes = [
+    "search.html",
+    "genindex.html",
+]
+sitemap_url_scheme = "{link}"
 
-# Add any paths that contain templates here, relative to this directory.
+html_theme_options = {
+    "navigation_with_keys": False,
+    "analytics_id": "GTM-T8XT4PS",
+    "logo": {
+        "text": "",
+    },
+    "icon_links": [
+        {
+            "name": "X",
+            "url": "https://x.com/PyTorch",
+            "icon": "fa-brands fa-x-twitter",
+        },
+        {
+            "name": "GitHub",
+            "url": "https://github.com/pytorch/tutorials",
+            "icon": "fa-brands fa-github",
+        },
+        {
+            "name": "Discourse",
+            "url": "https://dev-discuss.pytorch.org/",
+            "icon": "fa-brands fa-discourse",
+        },
+        {
+            "name": "PyPi",
+            "url": "https://pypi.org/project/torch/",
+            "icon": "fa-brands fa-python",
+        },
+    ],
+    "use_edit_page_button": True,
+    "header_links_before_dropdown": 9,
+    "navbar_start": ["pytorch_version"],
+    "navbar_center": "navbar-nav",
+    "display_version": True,
+    "pytorch_project": "tutorials",
+    "canonical_url": "https://docs.pytorch.org/tutorials/",
+}
+
+theme_variables = pytorch_sphinx_theme2.get_theme_variables()
+
+html_context = {
+    "theme_variables": theme_variables,
+    "display_github": True,
+    "github_url": "https://github.com",
+    "github_user": "pytorch",
+    "github_repo": "tutorials",
+    "feedback_url": "https://github.com/pytorch/tutorials",
+    "github_version": "main",
+    "doc_path": ".",
+    "library_links": theme_variables.get("library_links", []),
+    #"pytorch_project": "tutorials",
+}
 
 
-templates_path = ['_templates']
+if os.getenv("GALLERY_PATTERN"):
+    # GALLERY_PATTERN is to be used when you want to work on a single
+    # tutorial.  Previously this was fed into filename_pattern, but
+    # if you do that, you still end up parsing all of the other Python
+    # files which takes a few seconds.  This strategy is better, as
+    # ignore_pattern also skips parsing.
+    # See https://github.com/sphinx-gallery/sphinx-gallery/issues/721
+    # for a more detailed description of the issue.
+    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 = 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 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",
+    os.path.join(os.path.dirname(pytorch_sphinx_theme2.__file__), "templates"),
+]
 
 # The suffix(es) of source filenames.
 # You can specify multiple suffix as a list of string:
 #
 # source_suffix = ['.rst', '.md']
-source_suffix = '.rst'
+source_suffix = ".rst"
 
 # The master toctree document.
-master_doc = 'index'
+master_doc = "index"
 
 # General information about the project.
-project = 'PyTorch Tutorials'
-copyright = '2017, PyTorch'
-author = 'PyTorch contributors'
+project = "PyTorch Tutorials"
+copyright = "2024, PyTorch"
+author = "PyTorch contributors"
 
 # The version info for the project you're documenting, acts as replacement for
 # |version| and |release|, also used in various other places throughout the
 # built documents.
 #
 # The short X.Y version.
-version = torch.__version__
+version = "v" + str(torch.__version__)
 # The full version, including alpha/beta/rc tags.
-release = torch.__version__
+release = str(torch.__version__)
 
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.
 #
 # This is also used if you do content translation via gettext catalogs.
 # Usually you set "language" from the command line for these cases.
-language = None
+language = "en"
 
 # List of patterns, relative to source directory, that match files and
 # directories to ignore when looking for source files.
 # This patterns also effect to html_static_path and html_extra_path
-exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
-exclude_patterns += sphinx_gallery_conf['examples_dirs']
-exclude_patterns += ['*/index.rst']
+exclude_patterns = [
+    "_build",
+    "Thumbs.db",
+    ".DS_Store",
+    "src/pytorch-sphinx-theme/docs*",
+]
+exclude_patterns += sphinx_gallery_conf["examples_dirs"]
+exclude_patterns += ["*/index.rst"]
+
+
+# Handling for HuggingFace Hub jinja templates
+def handle_jinja_templates(app, docname, source):
+    if "huggingface_hub/templates" in docname:
+        # Replace Jinja templates with quoted strings
+        source[0] = re.sub(r"(\{\{.*?\}\})", r'"\1"', source[0])
+
 
 # The name of the Pygments (syntax highlighting) style to use.
-pygments_style = 'sphinx'
+pygments_style = "sphinx"
 
 # If true, `todo` and `todoList` produce output, else they produce nothing.
 todo_include_todos = False
@@ -143,7 +363,7 @@
 # # Add any paths that contain custom static files (such as style sheets) here,
 # # relative to this directory. They are copied after the builtin static files,
 # # so a file named "default.css" will overwrite the builtin "default.css".
-html_static_path = ['_static']
+html_static_path = ["_static"]
 
 # # Custom sidebar templates, maps document names to template names.
 # html_sidebars = {
@@ -152,21 +372,10 @@
 # }
 
 
-html_theme = 'pytorch_sphinx_theme'
-html_theme_path = [pytorch_sphinx_theme.get_html_theme_path()]
-html_logo = '_static/img/pytorch-logo-dark.svg'
-html_theme_options = {
-    'pytorch_project': 'tutorials',
-    'collapse_navigation': False,
-    'display_version': True,
-    'logo_only': False,
-}
-
-
 # -- Options for HTMLHelp output ------------------------------------------
 
 # Output file base name for HTML help builder.
-htmlhelp_basename = 'PyTorchTutorialsdoc'
+htmlhelp_basename = "PyTorchTutorialsdoc"
 
 
 # -- Options for LaTeX output ---------------------------------------------
@@ -175,15 +384,12 @@
     # The paper size ('letterpaper' or 'a4paper').
     #
     # 'papersize': 'letterpaper',
-
     # The font size ('10pt', '11pt' or '12pt').
     #
     # 'pointsize': '10pt',
-
     # Additional stuff for the LaTeX preamble.
     #
     # 'preamble': '',
-
     # Latex figure (float) alignment
     #
     # 'figure_align': 'htbp',
@@ -193,8 +399,13 @@
 # (source start file, target name, title,
 #  author, documentclass [howto, manual, or own class]).
 latex_documents = [
-    (master_doc, 'PyTorchTutorials.tex', 'PyTorch Tutorials',
-     'Sasank, PyTorch contributors', 'manual'),
+    (
+        master_doc,
+        "PyTorchTutorials.tex",
+        "PyTorch Tutorials",
+        "Sasank, PyTorch contributors",
+        "manual",
+    ),
 ]
 
 
@@ -202,10 +413,7 @@
 
 # One entry per manual page. List of tuples
 # (source start file, name, description, authors, manual section).
-man_pages = [
-    (master_doc, 'pytorchtutorials', 'PyTorch Tutorials',
-     [author], 1)
-]
+man_pages = [(master_doc, "pytorchtutorials", "PyTorch Tutorials", [author], 1)]
 
 
 # -- Options for Texinfo output -------------------------------------------
@@ -214,17 +422,48 @@
 # (source start file, target name, title, author,
 #  dir menu entry, description, category)
 texinfo_documents = [
-    (master_doc, 'PyTorchTutorials', 'PyTorch Tutorials',
-     author, 'PyTorchTutorials', 'One line description of project.',
-     'Miscellaneous'),
+    (
+        master_doc,
+        "PyTorchTutorials",
+        "PyTorch Tutorials",
+        author,
+        "PyTorchTutorials",
+        "One line description of project.",
+        "Miscellaneous",
+    ),
 ]
 
+html_css_files = [
+    "https://cdn.jsdelivr.net/npm/katex@0.10.0-beta/dist/katex.min.css",
+]
+
+
+def html_page_context(app, pagename, templatename, context, doctree):
+    # Check if the page is in gallery directories
+    for gallery_dir in sphinx_gallery_conf["gallery_dirs"]:
+        if pagename.startswith(gallery_dir):
+            # Get corresponding examples directory
+            examples_dir = sphinx_gallery_conf["examples_dirs"][
+                sphinx_gallery_conf["gallery_dirs"].index(gallery_dir)
+            ]
+
+            # Calculate relative path within the gallery
+            rel_path = (
+                pagename[len(gallery_dir) + 1 :] if pagename != gallery_dir else ""
+            )
+
+            # Check for .py file in examples directory
+            py_path = os.path.join(app.srcdir, examples_dir, rel_path + ".py")
+
+            # If a .py file exists, this page was generated from Python
+            if os.path.exists(py_path):
+                context["display_github"] = False
+                return
+
+    # Enable for all other pages
+    context["display_github"] = True
+
 
 def setup(app):
-    # Custom CSS
-    # app.add_stylesheet('css/pytorch_theme.css')
-    # app.add_stylesheet('https://fonts.googleapis.com/css?family=Lato')
-    # Custom directives
-    app.add_directive('includenodoc', IncludeDirective)
-    app.add_directive('galleryitem', GalleryItemDirective)
-    app.add_directive('customgalleryitem', CustomGalleryItemDirective)
+    app.connect("source-read", handle_jinja_templates)
+    app.connect("html-page-context", html_page_context)
diff --git a/custom_directives.py b/custom_directives.py
deleted file mode 100644
index 943b14d7e4c..00000000000
--- a/custom_directives.py
+++ /dev/null
@@ -1,208 +0,0 @@
-from docutils.parsers.rst import Directive, directives
-from docutils.statemachine import StringList 
-from docutils import nodes
-import re
-import os
-import sphinx_gallery
-
-try:
-    FileNotFoundError
-except NameError:
-    FileNotFoundError = IOError
-
-
-class IncludeDirective(Directive):
-    """Include source file without docstring at the top of file.
-
-    Implementation just replaces the first docstring found in file
-    with '' once.
-
-    Example usage:
-
-    .. includenodoc:: /beginner/examples_tensor/two_layer_net_tensor.py
-
-    """
-
-    # defines the parameter the directive expects
-    # directives.unchanged means you get the raw value from RST
-    required_arguments = 1
-    optional_arguments = 0
-    final_argument_whitespace = True
-    has_content = False
-    add_index = False
-
-    docstring_pattern = r'"""(?P<docstring>(?:.|[\r\n])*?)"""\n'
-    docstring_regex = re.compile(docstring_pattern)
-
-    def run(self):
-        document = self.state.document
-        env = document.settings.env
-        rel_filename, filename = env.relfn2path(self.arguments[0])
-
-        try:
-            text = open(filename).read()
-            text_no_docstring = self.docstring_regex.sub('', text, count=1)
-
-            code_block = nodes.literal_block(text=text_no_docstring)
-            return [code_block]
-        except FileNotFoundError as e:
-            print(e)
-            return []
-
-
-class GalleryItemDirective(Directive):
-    """
-    Create a sphinx gallery thumbnail for insertion anywhere in docs.
-
-    Optionally, you can specify the custom figure and intro/tooltip for the
-    thumbnail.
-
-    Example usage:
-
-    .. galleryitem:: intermediate/char_rnn_generation_tutorial.py
-        :figure: _static/img/char_rnn_generation.png
-        :intro: Put your custom intro here.
-
-    If figure is specified, a thumbnail will be made out of it and stored in
-    _static/thumbs. Therefore, consider _static/thumbs as a 'built' directory.
-    """
-
-    required_arguments = 1
-    optional_arguments = 0
-    final_argument_whitespace = True
-    option_spec = {'figure': directives.unchanged,
-                   'intro': directives.unchanged}
-    has_content = False
-    add_index = False
-
-    def run(self):
-        args = self.arguments
-        fname = args[-1]
-
-        env = self.state.document.settings.env
-        fname, abs_fname = env.relfn2path(fname)
-        basename = os.path.basename(fname)
-        dirname = os.path.dirname(fname)
-
-        try:
-            if 'intro' in self.options:
-                intro = self.options['intro'][:195] + '...'
-            else:
-                _, blocks = sphinx_gallery.gen_rst.split_code_and_text_blocks(abs_fname)
-                intro, _ = sphinx_gallery.gen_rst.extract_intro_and_title(abs_fname, blocks[0][1])
-
-            thumbnail_rst = sphinx_gallery.backreferences._thumbnail_div(
-                dirname, basename, intro)
-
-            if 'figure' in self.options:
-                rel_figname, figname = env.relfn2path(self.options['figure'])
-                save_figname = os.path.join('_static/thumbs/',
-                                            os.path.basename(figname))
-
-                try:
-                    os.makedirs('_static/thumbs')
-                except OSError:
-                    pass
-
-                sphinx_gallery.gen_rst.scale_image(figname, save_figname,
-                                                   400, 280)
-                # replace figure in rst with simple regex
-                thumbnail_rst = re.sub(r'..\sfigure::\s.*\.png',
-                                       '.. figure:: /{}'.format(save_figname),
-                                       thumbnail_rst)
-
-            thumbnail = StringList(thumbnail_rst.split('\n'))
-            thumb = nodes.paragraph()
-            self.state.nested_parse(thumbnail, self.content_offset, thumb)
-
-            return [thumb]
-        except FileNotFoundError as e:
-            print(e)
-            return []
-
-
-GALLERY_TEMPLATE = """
-.. raw:: html
-
-    <div class="sphx-glr-thumbcontainer" tooltip="{tooltip}">
-
-.. only:: html
-
-    .. figure:: {thumbnail}
-
-        {description}
-
-.. raw:: html
-
-    </div>
-"""
-
-
-class CustomGalleryItemDirective(Directive):
-    """Create a sphinx gallery style thumbnail.
-
-    tooltip and figure are self explanatory. Description could be a link to
-    a document like in below example. 
-
-    Example usage:
-
-    .. customgalleryitem::
-        :tooltip: I am writing this tutorial to focus specifically on NLP for people who have never written code in any deep learning framework
-        :figure: /_static/img/thumbnails/babel.jpg
-        :description: :doc:`/beginner/deep_learning_nlp_tutorial`
-
-    If figure is specified, a thumbnail will be made out of it and stored in
-    _static/thumbs. Therefore, consider _static/thumbs as a 'built' directory.
-    """
-
-    required_arguments = 0
-    optional_arguments = 0
-    final_argument_whitespace = True
-    option_spec = {'tooltip': directives.unchanged,
-                   'figure': directives.unchanged,
-                   'description': directives.unchanged}
-
-    has_content = False
-    add_index = False
-
-    def run(self):
-        try:
-            if 'tooltip' in self.options:
-                tooltip = self.options['tooltip'][:195] + '...'
-            else:
-                raise ValueError('tooltip not found')
-
-            if 'figure' in self.options:
-                env = self.state.document.settings.env
-                rel_figname, figname = env.relfn2path(self.options['figure'])
-                thumbnail = os.path.join('_static/thumbs/', os.path.basename(figname))
-
-                try:
-                    os.makedirs('_static/thumbs')
-                except FileExistsError:
-                    pass
-
-                sphinx_gallery.gen_rst.scale_image(figname, thumbnail, 400, 280)
-            else:
-                thumbnail = '_static/img/thumbnails/default.png'
-
-            if 'description' in self.options:
-                description = self.options['description']
-            else:
-                raise ValueError('description not doc found')
-
-        except FileNotFoundError as e:
-            print(e)
-            return []
-        except ValueError as e:
-            print(e)
-            raise
-            return []
-
-        thumbnail_rst = GALLERY_TEMPLATE.format(tooltip=tooltip,
-                                                thumbnail=thumbnail,
-                                                description=description)
-        thumbnail = StringList(thumbnail_rst.split('\n'))
-        thumb = nodes.paragraph()
-        self.state.nested_parse(thumbnail, self.content_offset, thumb)
-        return [thumb]
diff --git a/deep-dive.rst b/deep-dive.rst
new file mode 100644
index 00000000000..89a18d48e29
--- /dev/null
+++ b/deep-dive.rst
@@ -0,0 +1,163 @@
+:orphan:
+
+Deep Dive
+=========
+
+Focused on enhancing model performance, this section includes
+tutorials on profiling, hyperparameter tuning, quantization,
+and other techniques to optimize PyTorch models for better efficiency
+and speed.
+
+.. raw:: html
+
+    <div id="tutorial-cards-container">
+
+    <nav class="navbar navbar-expand-lg navbar-light tutorials-nav col-12">
+        <div class="tutorial-tags-container">
+            <div id="dropdown-filter-tags">
+                <div class="tutorial-filter-menu">
+                    <div class="tutorial-filter filter-btn all-tag-selected" data-tag="all">All</div>
+                </div>
+            </div>
+        </div>
+    </nav>
+
+    <hr class="tutorials-hr">
+
+    <div class="row">
+
+    <div id="tutorial-cards">
+    <div class="list">
+
+.. Add tutorial cards below this line
+.. customcarditem::
+   :header: Profiling PyTorch
+   :card_description: Learn how to profile a PyTorch application
+   :link: beginner/profiler.html
+   :image: _static/img/thumbnails/cropped/pytorch-logo.png
+   :tags: Profiling
+
+.. customcarditem::
+   :header: Parametrizations Tutorial
+   :card_description: Learn how to use torch.nn.utils.parametrize to put constraints on your parameters (e.g. make them orthogonal, symmetric positive definite, low-rank...)
+   :image: _static/img/thumbnails/cropped/parametrizations.png
+   :link: intermediate/parametrizations.html
+   :tags: Model-Optimization,Best-Practice
+
+.. customcarditem::
+   :header: Pruning Tutorial
+   :card_description: Learn how to use torch.nn.utils.prune to sparsify your neural networks, and how to extend it to implement your own custom pruning technique.
+   :image: _static/img/thumbnails/cropped/Pruning-Tutorial.png
+   :link: intermediate/pruning_tutorial.html
+   :tags: Model-Optimization,Best-Practice
+
+
+.. customcarditem::
+   :header: Inductor CPU Backend Debugging and Profiling
+   :card_description: Learn the usage, debugging and performance profiling for ``torch.compile`` with Inductor CPU backend.
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: intermediate/inductor_debug_cpu.html
+   :tags: Model-Optimization,inductor
+
+.. customcarditem::
+   :header: (beta) Implementing High-Performance Transformers with SCALED DOT PRODUCT ATTENTION
+   :card_description: This tutorial explores the new torch.nn.functional.scaled_dot_product_attention and how it can be used to construct Transformer components.
+   :image: _static/img/thumbnails/cropped/pytorch-logo.png
+   :link: intermediate/scaled_dot_product_attention_tutorial.html
+   :tags: Model-Optimization,Attention,Transformer
+
+.. customcarditem::
+   :header: Knowledge Distillation in Convolutional Neural Networks
+   :card_description:  Learn how to improve the accuracy of lightweight models using more powerful models as teachers.
+   :image: _static/img/thumbnails/cropped/knowledge_distillation_pytorch_logo.png
+   :link: beginner/knowledge_distillation_tutorial.html
+   :tags: Model-Optimization,Image/Video
+
+.. Frontend APIs
+.. customcarditem::
+   :header: (beta) Channels Last Memory Format in PyTorch
+   :card_description: Get an overview of Channels Last memory format and understand how it is used to order NCHW tensors in memory preserving dimensions.
+   :image: _static/img/thumbnails/cropped/experimental-Channels-Last-Memory-Format-in-PyTorch.png
+   :link: intermediate/memory_format_tutorial.html
+   :tags: Memory-Format,Best-Practice,Frontend-APIs
+
+.. customcarditem::
+   :header: Forward-mode Automatic Differentiation
+   :card_description: Learn how to use forward-mode automatic differentiation.
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: intermediate/forward_ad_usage.html
+   :tags: Frontend-APIs
+
+.. customcarditem::
+   :header: Jacobians, Hessians, hvp, vhp, and more
+   :card_description: Learn how to compute advanced autodiff quantities using torch.func
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: intermediate/jacobians_hessians.html
+   :tags: Frontend-APIs
+
+.. customcarditem::
+   :header: Model Ensembling
+   :card_description: Learn how to ensemble models using torch.vmap
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: intermediate/ensembling.html
+   :tags: Frontend-APIs
+
+.. customcarditem::
+   :header: Per-Sample-Gradients
+   :card_description: Learn how to compute per-sample-gradients using torch.func
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: intermediate/per_sample_grads.html
+   :tags: Frontend-APIs
+
+.. customcarditem::
+   :header: Neural Tangent Kernels
+   :card_description: Learn how to compute neural tangent kernels using torch.func
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: intermediate/neural_tangent_kernels.html
+   :tags: Frontend-APIs
+
+.. customcarditem::
+   :header: Using the PyTorch C++ Frontend
+   :card_description: Walk through an end-to-end example of training a model with the C++ frontend by training a DCGAN – a kind of generative model – to generate images of MNIST digits.
+   :image: _static/img/thumbnails/cropped/Using-the-PyTorch-Cpp-Frontend.png
+   :link: advanced/cpp_frontend.html
+   :tags: Frontend-APIs,C++
+
+.. customcarditem::
+   :header: Autograd in C++ Frontend
+   :card_description: The autograd package helps build flexible and dynamic nerural netorks. In this tutorial, exploreseveral examples of doing autograd in PyTorch C++ frontend
+   :image: _static/img/thumbnails/cropped/Autograd-in-Cpp-Frontend.png
+   :link: advanced/cpp_autograd.html
+   :tags: Frontend-APIs,C++
+
+.. End of tutorial card section
+.. -----------------------------------------
+.. Page TOC
+.. -----------------------------------------
+.. toctree::
+   :maxdepth: 2
+   :includehidden:
+   :hidden:
+
+   beginner/profiler
+   beginner/vt_tutorial
+   intermediate/parametrizations
+   intermediate/pruning_tutorial
+   intermediate/inductor_debug_cpu
+   intermediate/scaled_dot_product_attention_tutorial
+   beginner/knowledge_distillation_tutorial
+
+.. toctree::
+   :maxdepth: 2
+   :includehidden:
+   :hidden:
+   :caption: Frontend APIs
+
+   intermediate/memory_format_tutorial
+   intermediate/forward_ad_usage
+   intermediate/jacobians_hessians
+   intermediate/ensembling
+   intermediate/per_sample_grads
+   intermediate/neural_tangent_kernels.py
+   advanced/cpp_frontend
+   advanced/cpp_autograd
diff --git a/distributed.rst b/distributed.rst
new file mode 100644
index 00000000000..af4d9772506
--- /dev/null
+++ b/distributed.rst
@@ -0,0 +1,197 @@
+Distributed
+===========
+
+Distributed training is a model training paradigm that involves
+spreading training workload across multiple worker nodes, therefore
+significantly improving the speed of training and model accuracy. While
+distributed training can be used for any type of ML model training, it
+is most beneficial to use it for large models and compute demanding
+tasks as deep learning.
+
+There are a few ways you can perform distributed training in
+PyTorch with each method having their advantages in certain use cases:
+
+* `DistributedDataParallel (DDP) <#learn-ddp>`__
+* `Fully Sharded Data Parallel (FSDP2) <#learn-fsdp>`__
+* `Tensor Parallel (TP) <#learn-tp>`__
+* `Device Mesh <#device-mesh>`__
+* `Remote Procedure Call (RPC) distributed training <#learn-rpc>`__
+* `Custom Extensions <#custom-extensions>`__
+
+Read more about these options in `Distributed Overview <https://docs.pytorch.org/tutorials/beginner/dist_overview.html?utm_source=distr_landing>`__.
+
+.. _learn-ddp:
+
+Learn DDP
+---------
+
+.. grid:: 3
+
+     .. grid-item-card:: :octicon:`file-code;1em`
+        DDP Intro Video Tutorials
+        :link: https://pytorch.org/tutorials/beginner/ddp_series_intro.html?utm_source=distr_landing&utm_medium=ddp_series_intro
+        :link-type: url
+
+        A step-by-step video series on how to get started with
+        `DistributedDataParallel` and advance to more complex topics
+        +++
+        :octicon:`code;1em` Code :octicon:`square-fill;1em` :octicon:`video;1em` Video
+
+     .. grid-item-card:: :octicon:`file-code;1em`
+        Getting Started with Distributed Data Parallel
+        :link: https://pytorch.org/tutorials/intermediate/ddp_tutorial.html?utm_source=distr_landing&utm_medium=intermediate_ddp_tutorial
+        :link-type: url
+
+        This tutorial provides a short and gentle intro to the PyTorch
+        DistributedData Parallel.
+        +++
+        :octicon:`code;1em` Code
+
+     .. grid-item-card:: :octicon:`file-code;1em`
+        Distributed Training with Uneven Inputs Using
+        the Join Context Manager
+        :link: https://pytorch.org/tutorials/advanced/generic_join.html?utm_source=distr_landing&utm_medium=generic_join
+        :link-type: url
+
+        This tutorial describes the Join context manager and
+        demonstrates it's use with DistributedData Parallel.
+        +++
+        :octicon:`code;1em` Code
+
+.. _learn-fsdp:
+
+Learn FSDP2
+----------
+
+.. grid:: 3
+
+     .. grid-item-card:: :octicon:`file-code;1em`
+        Getting Started with FSDP2
+        :link: https://pytorch.org/tutorials/intermediate/FSDP_tutorial.html?utm_source=distr_landing&utm_medium=FSDP_getting_started
+        :link-type: url
+
+        This tutorial demonstrates how you can perform distributed training
+        with FSDP2 on a transformer model
+        +++
+        :octicon:`code;1em` Code
+
+
+.. _learn-tp:
+
+Learn Tensor Parallel (TP)
+---------------
+
+.. grid:: 3
+
+     .. grid-item-card:: :octicon:`file-code;1em`
+        Large Scale Transformer model training with Tensor Parallel (TP)
+        :link: https://pytorch.org/tutorials/intermediate/TP_tutorial.html
+        :link-type: url
+
+        This tutorial demonstrates how to train a large Transformer-like model across hundreds to thousands of GPUs using Tensor Parallel and Fully Sharded Data Parallel.
+        +++
+        :octicon:`code;1em` Code
+
+
+.. _device-mesh:
+
+Learn DeviceMesh
+----------------
+
+.. grid:: 3
+
+     .. grid-item-card:: :octicon:`file-code;1em`
+        Getting Started with DeviceMesh
+        :link: https://pytorch.org/tutorials/recipes/distributed_device_mesh.html?highlight=devicemesh
+        :link-type: url
+
+        In this tutorial you will learn about `DeviceMesh`
+        and how it can help with distributed training.
+        +++
+        :octicon:`code;1em` Code
+
+.. _learn-rpc:
+
+Learn RPC
+---------
+
+.. grid:: 3
+
+     .. grid-item-card:: :octicon:`file-code;1em`
+        Getting Started with Distributed RPC Framework
+        :link: https://pytorch.org/tutorials/intermediate/rpc_tutorial.html?utm_source=distr_landing&utm_medium=rpc_getting_started
+        :link-type: url
+
+        This tutorial demonstrates how to get started with RPC-based distributed
+        training.
+        +++
+        :octicon:`code;1em` Code
+
+     .. grid-item-card:: :octicon:`file-code;1em`
+        Implementing a Parameter Server Using Distributed RPC Framework
+        :link: https://pytorch.org/tutorials/intermediate/rpc_param_server_tutorial.html?utm_source=distr_landing&utm_medium=rpc_param_server_tutorial
+        :link-type: url
+
+        This tutorial walks you through a simple example of implementing a
+        parameter server using PyTorch’s Distributed RPC framework.
+        +++
+        :octicon:`code;1em` Code
+
+     .. grid-item-card:: :octicon:`file-code;1em`
+        Implementing Batch RPC Processing Using Asynchronous Executions
+        :link: https://pytorch.org/tutorials/intermediate/rpc_async_execution.html?utm_source=distr_landing&utm_medium=rpc_async_execution
+        :link-type: url
+
+        In this tutorial you will build batch-processing RPC applications
+        with the @rpc.functions.async_execution decorator.
+        +++
+        :octicon:`code;1em` Code
+
+.. grid:: 3
+
+     .. grid-item-card:: :octicon:`file-code;1em`
+        Combining Distributed DataParallel with Distributed RPC Framework
+        :link: https://pytorch.org/tutorials/advanced/rpc_ddp_tutorial.html?utm_source=distr_landing&utm_medium=rpc_plus_ddp
+        :link-type: url
+
+        In this tutorial you will learn how to combine distributed data
+        parallelism with distributed model parallelism.
+        +++
+        :octicon:`code;1em` Code
+
+.. _custom-extensions:
+
+Custom Extensions
+-----------------
+
+.. grid:: 3
+
+     .. grid-item-card:: :octicon:`file-code;1em`
+        Customize Process Group Backends Using Cpp Extensions
+        :link: https://pytorch.org/tutorials/intermediate/process_group_cpp_extension_tutorial.html?utm_source=distr_landing&utm_medium=custom_extensions_cpp
+        :link-type: url
+
+        In this tutorial you will learn to implement a custom `ProcessGroup`
+        backend and plug that into PyTorch distributed package using
+        cpp extensions.
+        +++
+        :octicon:`code;1em` Code
+
+.. toctree::
+   :hidden:
+   :maxdepth: 2
+
+   beginner/dist_overview
+   beginner/ddp_series_intro
+   intermediate/ddp_tutorial
+   intermediate/dist_tuto
+   intermediate/FSDP_tutorial
+   intermediate/TCPStore_libuv_backend
+   intermediate/TP_tutorial
+   intermediate/pipelining_tutorial
+   intermediate/process_group_cpp_extension_tutorial
+   intermediate/rpc_tutorial
+   intermediate/rpc_param_server_tutorial
+   intermediate/rpc_async_execution
+   advanced/rpc_ddp_tutorial
+   advanced/generic_join
diff --git a/docathon-leaderboard.md b/docathon-leaderboard.md
new file mode 100644
index 00000000000..de12a13cca8
--- /dev/null
+++ b/docathon-leaderboard.md
@@ -0,0 +1,164 @@
+# 🎉 PyTorch Docathon Leaderboard 2025 🎉
+
+This is the list of the docathon contributors that have participated and contributed to the PyTorch H1 2025 docathon. A big shout out to everyone who have participated!
+We have awarded points for each merged PR as follows:
+
+* easy - 2 points
+* medium - 5 points
+* advanced - 10 points
+
+We have granted half points (1, 2, and 5 respectively) for all additional PRs merged against the same issue.
+In some cases, we have awarded credit for the PRs that were not merged or issues that have been closed without a merged PR.
+
+| Rank | Author | Points | PRs |
+|:---:|:------------|------:|:----|
+| 🥇 | [j-silv](https://github.com/j-silv) | 31 | [#155753](https://github.com/pytorch/pytorch/pull/155753), [#155659](https://github.com/pytorch/pytorch/pull/155659), [#155567](https://github.com/pytorch/pytorch/pull/155567), [#155540](https://github.com/pytorch/pytorch/pull/155540), [#155528](https://github.com/pytorch/pytorch/pull/155528), [#155198](https://github.com/pytorch/pytorch/pull/155198), [#155093](https://github.com/pytorch/pytorch/pull/155093), [#3389](https://github.com/pytorch/tutorials/pull/3389) |
+| 🥇 | [windsonsea](https://github.com/windsonsea) | 19 | [#155789](https://github.com/pytorch/pytorch/pull/155789), [#155520](https://github.com/pytorch/pytorch/pull/155520), [#156039](https://github.com/pytorch/pytorch/pull/156039), [#156009](https://github.com/pytorch/pytorch/pull/156009), [#155653](https://github.com/pytorch/pytorch/pull/155653) |
+| 🥇 | [kiszk](https://github.com/kiszk) | 16 | [#155762](https://github.com/pytorch/pytorch/pull/155762), [#155514](https://github.com/pytorch/pytorch/pull/155514), [#155351](https://github.com/pytorch/pytorch/pull/155351), [#155348](https://github.com/pytorch/pytorch/pull/155348), [#155347](https://github.com/pytorch/pytorch/pull/155347) |
+| 🥈 | [Rachel0619](https://github.com/Rachel0619) | 14 | [#155764](https://github.com/pytorch/pytorch/pull/155764), [#155482](https://github.com/pytorch/pytorch/pull/155482), [#3385](https://github.com/pytorch/tutorials/pull/3385), [#3381](https://github.com/pytorch/tutorials/pull/3381) |
+| 🥈 | [jafraustro](https://github.com/jafraustro) | 14 | [#155523](https://github.com/pytorch/pytorch/pull/155523), [#155369](https://github.com/pytorch/pytorch/pull/155369), [#133563](https://github.com/pytorch/pytorch/issues/133563), [#129446](https://github.com/pytorch/pytorch/issues/129446) |
+| 🥈 | [Dhia-naouali](https://github.com/Dhia-naouali) | 12 | [#155911](https://github.com/pytorch/pytorch/pull/155911), [#155840](https://github.com/pytorch/pytorch/pull/155840), [#155505](https://github.com/pytorch/pytorch/pull/155505) |
+| 🥈 | [loganthomas](https://github.com/loganthomas) | 12 | [#155702](https://github.com/pytorch/pytorch/pull/155702), [#155088](https://github.com/pytorch/pytorch/pull/155088), [#155649](https://github.com/pytorch/pytorch/pull/155649) |
+| 🥈 | [nirajkamal](https://github.com/nirajkamal) | 12 | [#155430](https://github.com/pytorch/pytorch/pull/155430), [#155228](https://github.com/pytorch/pytorch/pull/155228), [#3376](https://github.com/pytorch/tutorials/pull/3376) |
+| 🥉 | [Juliandlb](https://github.com/Juliandlb) | 10 | [#155987](https://github.com/pytorch/pytorch/pull/155987), [#155618](https://github.com/pytorch/pytorch/pull/155618) |
+| 🥉 | [ggsmith842](https://github.com/ggsmith842) | 7 | [#155767](https://github.com/pytorch/pytorch/pull/155767), [#155297](https://github.com/pytorch/pytorch/pull/155297) |
+| 🥉 | [ParagEkbote](https://github.com/ParagEkbote) | 7 | [#155683](https://github.com/pytorch/pytorch/pull/155683), [#155341](https://github.com/pytorch/pytorch/pull/155341) |
+| ⭐ | [GdoongMathew](https://github.com/GdoongMathew) | 5 | [#155813](https://github.com/pytorch/pytorch/pull/155813) |
+| ⭐ | [eromomon](https://github.com/eromomon) | 5 | [#155696](https://github.com/pytorch/pytorch/pull/155696) |
+| ⭐ | [dggaytan](https://github.com/dggaytan) | 5 | [#155377](https://github.com/pytorch/pytorch/pull/155377) |
+| ⭐ | [spzala](https://github.com/spzala) | 5 | [#155335](https://github.com/pytorch/pytorch/pull/155335) |
+| ⭐ | [framoncg](https://github.com/framoncg) | 5 | [#155298](https://github.com/pytorch/pytorch/pull/155298) |
+| ⭐ | [abhinav-TB](https://github.com/abhinav-TB) | 5 | [#155252](https://github.com/pytorch/pytorch/pull/155252) |
+| ⭐ | [aagalleg](https://github.com/aagalleg) | 5 | [#155137](https://github.com/pytorch/pytorch/pull/155137) |
+| ⭐ | [kiersten-stokes](https://github.com/kiersten-stokes) | 5 | [#155067](https://github.com/pytorch/pytorch/pull/155067) |
+| ⭐ | [krishnakalyan3](https://github.com/krishnakalyan3) | 5 | [#3387](https://github.com/pytorch/tutorials/pull/3387) |
+| ⭐ | [splion-360](https://github.com/splion-360) | 5 | [#3384](https://github.com/pytorch/tutorials/pull/3384) |
+| ⭐ | [harshaljanjani](https://github.com/harshaljanjani) | 5 | [#3377](https://github.com/pytorch/tutorials/pull/3377) |
+| ⭐ | [b-koopman](https://github.com/b-koopman) | 4 | [#155100](https://github.com/pytorch/pytorch/pull/155100), [#155889](https://github.com/pytorch/pytorch/pull/155889) |
+| ⭐ | [thatgeeman](https://github.com/thatgeeman) | 4 | [#155404](https://github.com/pytorch/pytorch/pull/155404), [#156094](https://github.com/pytorch/pytorch/pull/156094) |
+| ⭐ | [frost-intel](https://github.com/frost-intel) | 2 | [#3393](https://github.com/pytorch/tutorials/pull/3393) |
+| ⭐ | [ANotFox](https://github.com/ANotFox) | 2 | [#155148](https://github.com/pytorch/pytorch/pull/155148) |
+| ⭐ | [QasimKhan5x](https://github.com/QasimKhan5x) | 2 | [#155074](https://github.com/pytorch/pytorch/pull/155074) |
+| ⭐ | [Ashish-Soni08](https://github.com/Ashish-Soni08) | 2 | [#3379](https://github.com/pytorch/tutorials/pull/3379) |
+| ⭐ | [FORTFANOP](https://github.com/FORTFANOP) | 2 | [#3378](https://github.com/pytorch/tutorials/pull/3378) |
+| ⭐ | [newtdms ](https://github.com/newtdms ) | 2 | [#155497](https://github.com/pytorch/pytorch/pull/155497) |
+| ⭐ | [srini047](https://github.com/srini047) | 2 | [#155554](https://github.com/pytorch/pytorch/pull/155554) |
+
+
+# 🎉 Docathon H1 2024 Leaderboard 🎉
+
+This is the list of the docathon contributors that have participated and contributed to the PyTorch H1 2024 docathon.
+A big shout out to everyone who have participated! We have awarded points for each merged PR.
+For the **easy** label, we have awarded 2 points. For the **medium** label, we have awarded 5 points.
+For the **advanced** label, we have awarded 10 points. In some cases, we have awarded credit for the PRs that
+were not merged or issues that have been closed without a merged PR.
+
+| Author | Points | PR |
+|--- | --- | ---|
+| ahoblitz | 34 | https://github.com/pytorch/pytorch/pull/128566, https://github.com/pytorch/pytorch/pull/128408, https://github.com/pytorch/pytorch/pull/128171, https://github.com/pytorch/pytorch/pull/128083, https://github.com/pytorch/pytorch/pull/128082, https://github.com/pytorch/pytorch/pull/127983, https://github.com/pytorch/xla/pull/7214 |
+| afrittoli | 25 | https://github.com/pytorch/pytorch/pull/128139, https://github.com/pytorch/pytorch/pull/128133, https://github.com/pytorch/pytorch/pull/128132, https://github.com/pytorch/pytorch/pull/128129, https://github.com/pytorch/pytorch/pull/128127 |
+| kiszk | 20 | https://github.com/pytorch/pytorch/pull/128337, https://github.com/pytorch/pytorch/pull/128123, https://github.com/pytorch/pytorch/pull/128022, https://github.com/pytorch/pytorch/pull/128312 |
+| loganthomas | 19 | https://github.com/pytorch/pytorch/pull/128676, https://github.com/pytorch/pytorch/pull/128192, https://github.com/pytorch/pytorch/pull/128189, https://github.com/pytorch/tutorials/pull/2922, https://github.com/pytorch/tutorials/pull/2910, https://github.com/pytorch/xla/pull/7195 |
+| ignaciobartol | 17 | https://github.com/pytorch/pytorch/pull/128741, https://github.com/pytorch/pytorch/pull/128135, https://github.com/pytorch/pytorch/pull/127938, https://github.com/pytorch/tutorials/pull/2936 |
+| arunppsg | 17 | https://github.com/pytorch/pytorch/pull/128391, https://github.com/pytorch/pytorch/pull/128021, https://github.com/pytorch/pytorch/pull/128018, https://github.com/meta-pytorch/torchfix/pull/59 |
+| alperenunlu | 17 | https://github.com/pytorch/tutorials/pull/2934, https://github.com/pytorch/tutorials/pull/2909, https://github.com/pytorch/pytorch/pull/104043 |
+| anandptl84 | 10 | https://github.com/pytorch/pytorch/pull/128196, https://github.com/pytorch/pytorch/pull/128098 |
+| GdoongMathew | 10 | https://github.com/pytorch/pytorch/pull/128136, https://github.com/pytorch/pytorch/pull/128051 |
+| ZhaoqiongZ | 10 | https://github.com/pytorch/pytorch/pull/127872 |
+| ZailiWang | 10 | https://github.com/pytorch/tutorials/pull/2931 |
+| jingxu10 | 8 | https://github.com/pytorch/pytorch/pull/127280, https://github.com/pytorch/pytorch/pull/127279, https://github.com/pytorch/pytorch/pull/127278, https://github.com/pytorch/tutorials/pull/2919 |
+| sitamgithub-MSIT | 7 | https://github.com/pytorch/tutorials/pull/2900, https://github.com/pytorch/xla/pull/7208 |
+| spzala | 5 | https://github.com/pytorch/pytorch/pull/128679, https://github.com/pytorch/pytorch/pull/128657 |
+| TharinduRusira | 5 | https://github.com/pytorch/pytorch/pull/128197 |
+| zabboud | 5 | https://github.com/pytorch/pytorch/pull/128055 |
+| orion160 | 5 | https://github.com/pytorch/tutorials/pull/2912 |
+| Ricktho1 | 5 | https://github.com/pytorch/xla/pull/7273 |
+| IvanLauLinTiong | 4 | https://github.com/pytorch/pytorch/pull/128526, https://github.com/pytorch/tutorials/pull/2849 |
+| sshkhr | 2 | https://github.com/pytorch/pytorch/pull/128155 |
+| rk7697 | 2 | https://github.com/pytorch/pytorch/pull/127993 |
+| hippocookie | 2 | https://github.com/pytorch/tutorials/pull/2937 |
+| diningeachox | 2 | https://github.com/pytorch/tutorials/pull/2935 |
+| akhil-maker | 2 | https://github.com/pytorch/tutorials/pull/2899 |
+| saurabhkthakur | 2 | https://github.com/pytorch/tutorials/pull/2896 |
+
+# 🎉 Docathon H2 2023 Leaderboard 🎉
+
+This is the list of the docathon contributors that have participated and contributed to the H2 2023 PyTorch docathon.
+A big shout out to everyone who have participated! We have awarded points for each merged PR.
+For the **easy** label, we have awarded 2 points. For the **medium** label, we have awarded 5 points.
+For the **advanced** label, we have awarded 10 points. In some cases, we have awarded half credit for the PRs that
+were not merged or issues that have been closed without a merged PR. Thank you all for your awesome contributions! 🎉
+
+| Author | Points | PR |
+|--- | --- | ---|
+| ahoblitz | 25 | https://github.com/pytorch/pytorch/pull/112992, https://github.com/pytorch/tutorials/pull/2662, https://github.com/pytorch/tutorials/pull/2647, https://github.com/pytorch/tutorials/pull/2642, https://github.com/pytorch/tutorials/pull/2640, https://github.com/pytorch/pytorch/pull/113092, https://github.com/pytorch/pytorch/pull/113348 |
+| ChanBong | 22 | https://github.com/pytorch/pytorch/pull/113337, https://github.com/pytorch/pytorch/pull/113336, https://github.com/pytorch/pytorch/pull/113335, https://github.com/pytorch/tutorials/pull/2644, https://github.com/pytorch/tutorials/pull/2639 |
+| alperenunlu | 22 | https://github.com/pytorch/pytorch/pull/113260, https://github.com/pytorch/tutorials/pull/2673, https://github.com/pytorch/tutorials/pull/2660, https://github.com/pytorch/tutorials/pull/2656, https://github.com/pytorch/tutorials/pull/2649, https://github.com/pytorch/pytorch/pull/113505, https://github.com/pytorch/pytorch/pull/113218, https://github.com/pytorch/pytorch/pull/113505 |
+| spzala | 22 | https://github.com/pytorch/pytorch/pull/113200, https://github.com/pytorch/pytorch/pull/112693, https://github.com/pytorch/tutorials/pull/2667, https://github.com/pytorch/tutorials/pull/2635 |
+| bjhargrave | 21 | https://github.com/pytorch/pytorch/pull/113358, https://github.com/pytorch/pytorch/pull/113206, https://github.com/pytorch/pytorch/pull/112786, https://github.com/pytorch/tutorials/pull/2661, https://github.com/pytorch/tutorials/pull/1272 |
+| zabboud | 21 | https://github.com/pytorch/pytorch/pull/113233, https://github.com/pytorch/pytorch/pull/113227, https://github.com/pytorch/pytorch/pull/113177, https://github.com/pytorch/pytorch/pull/113219, https://github.com/pytorch/pytorch/pull/113311 |
+| nvs-abhilash | 20 | https://github.com/pytorch/pytorch/pull/113241, https://github.com/pytorch/pytorch/pull/112765, https://github.com/pytorch/pytorch/pull/112695, https://github.com/pytorch/pytorch/pull/112657 |
+| guptaaryan16 | 19 | https://github.com/pytorch/pytorch/pull/112817, https://github.com/pytorch/pytorch/pull/112735, https://github.com/pytorch/tutorials/pull/2674, https://github.com/pytorch/pytorch/pull/113196, https://github.com/pytorch/pytorch/pull/113532 |
+| min-jean-cho | 17 | https://github.com/pytorch/pytorch/pull/113195, https://github.com/pytorch/pytorch/pull/113183, https://github.com/pytorch/pytorch/pull/113178, https://github.com/pytorch/pytorch/pull/113109, https://github.com/pytorch/pytorch/pull/112892 |
+| markstur | 14 | https://github.com/pytorch/pytorch/pull/113250, https://github.com/pytorch/tutorials/pull/2643, https://github.com/pytorch/tutorials/pull/2638, https://github.com/pytorch/tutorials/pull/2636 |
+| RustyGrackle | 13 | https://github.com/pytorch/pytorch/pull/113371, https://github.com/pytorch/pytorch/pull/113266, https://github.com/pytorch/pytorch/pull/113435 |
+| Viditagarwal7479 | 12 | https://github.com/pytorch/pytorch/pull/112860, https://github.com/pytorch/tutorials/pull/2659, https://github.com/pytorch/tutorials/pull/2671 |
+| kiszk | 10 | https://github.com/pytorch/pytorch/pull/113523, https://github.com/pytorch/pytorch/pull/112751 |
+| awaelchli | 10 | https://github.com/pytorch/pytorch/pull/113216, https://github.com/pytorch/pytorch/pull/112674 |
+| pilot-j | 10 | https://github.com/pytorch/pytorch/pull/112964, https://github.com/pytorch/pytorch/pull/112856 |
+| krishnakalyan3 | 7 | https://github.com/pytorch/tutorials/pull/2653, https://github.com/pytorch/tutorials/pull/1235, https://github.com/pytorch/tutorials/pull/1705 |
+| ash-01xor | 5 | https://github.com/pytorch/pytorch/pull/113511 |
+| IvanLauLinTiong | 5 | https://github.com/pytorch/pytorch/pull/113052 |
+| Senthi1Kumar | 5 | https://github.com/pytorch/pytorch/pull/113021 |
+| ooooo-create | 5 | https://github.com/pytorch/pytorch/pull/112953 |
+| stanleyedward | 5 | https://github.com/pytorch/pytorch/pull/112864, https://github.com/pytorch/pytorch/pull/112617 |
+| leslie-fang-intel | 5 | https://github.com/pytorch/tutorials/pull/2668 |
+| measty | 5 | https://github.com/pytorch/tutorials/pull/2675 |
+| Hhhhhhao | 5 | https://github.com/pytorch/tutorials/pull/2676 |
+| andrewashere | 3 | https://github.com/pytorch/pytorch/pull/112721 |
+| aalhendi | 3 | https://github.com/pytorch/pytorch/pull/112947 |
+| sitamgithub-MSIT | 3 | https://github.com/pytorch/pytorch/pull/113264 |
+| Jarlaze | 3 | https://github.com/pytorch/pytorch/pull/113531 |
+| jingxu10 | 2 | https://github.com/pytorch/tutorials/pull/2657 |
+| cirquit | 2 | https://github.com/pytorch/tutorials/pull/2529 |
+| prithviraj-maurya | 1 | https://github.com/pytorch/tutorials/pull/2652 |
+| MirMustafaAli | 1 | https://github.com/pytorch/tutorials/pull/2645 |
+
+# 🎉 Docathon H1 2023 Leaderboard 🎉
+This is the list of the docathon contributors that have participated and contributed to the PyTorch docathon.
+A big shout out to everyone who have participated! We have awarded points for each merged PR.
+For the **easy** label, we have awarded 2 points. For the **medium** label, we have awarded 5 points.
+For the **advanced** label, we have awarded 10 points. In some cases, we have awarded half credit for the PRs that
+were not merged or issues that have been closed without a merged PR.
+| Author | Points | PR |
+|--- | --- | ---|
+| JoseLuisC99 | 22 | https://github.com/pytorch/tutorials/pull/2468, https://github.com/pytorch/tutorials/pull/2404, https://github.com/pytorch/tutorials/pull/2403, https://github.com/pytorch/tutorials/pull/2372, https://github.com/pytorch/examples/pull/1163, https://github.com/pytorch/tutorials/pull/2432 |
+| QasimKhan5x | 21 | https://github.com/pytorch/tutorials/pull/2452, https://github.com/pytorch/tutorials/pull/2419, https://github.com/pytorch/tutorials/pull/2408, https://github.com/pytorch/tutorials/pull/2397, https://github.com/pytorch/tutorials/pull/2385, https://github.com/pytorch/tutorials/pull/2383 |
+| bjhargrave | 12 | https://github.com/pytorch/tutorials/pull/2428, https://github.com/pytorch/tutorials/pull/2424, https://github.com/pytorch/tutorials/pull/2423 |
+| Aidyn-A | 10 | https://github.com/pytorch/tutorials/pull/2441 |
+| CaoE | 10 | https://github.com/pytorch/tutorials/pull/2439 |
+| HemanthSai7 | 10 | https://github.com/pytorch/tutorials/pull/2392, https://github.com/pytorch/tutorials/pull/2375 |
+| leslie-fang-intel | 10 | https://github.com/pytorch/tutorials/pull/2354 |
+| Valentine233 | 10 | https://github.com/pytorch/tutorials/pull/2430 |
+| TheMemoryDealer | 9 | https://github.com/pytorch/tutorials/pull/2389, https://github.com/pytorch/tutorials/pull/2369, https://github.com/pytorch/tutorials/pull/2367 |
+| arunppsg | 8 | https://github.com/pytorch/tutorials/pull/2384, https://github.com/pytorch/tutorials/pull/821 |
+| noqqaqq | 7 | https://github.com/pytorch/tutorials/pull/2407, https://github.com/pytorch/tutorials/pull/2386 |
+| zabboud | 7 | https://github.com/pytorch/tutorials/pull/2405, https://github.com/pytorch/tutorials/pull/2400 |
+| kiersten-stokes | 7 | https://github.com/pytorch/tutorials/pull/2401, https://github.com/pytorch/tutorials/pull/2398 |
+| frasertajima | 6 | https://github.com/pytorch/tutorials/pull/2370, https://github.com/pytorch/tutorials/pull/2368, https://github.com/pytorch/tutorials/pull/2363 |
+| nairbv | 5 | https://github.com/pytorch/tutorials/pull/2413 |
+| mikebrow | 5 | https://github.com/pytorch/tutorials/pull/2374 |
+| NeoKish | 4 | https://github.com/pytorch/tutorials/pull/2364, https://github.com/pytorch/tutorials/pull/2361 |
+| fabiogomez11c | 3 | https://github.com/pytorch/tutorials/pull/2362, https://github.com/pytorch/tutorials/pull/1011 |
+| onurtore | 2 | https://github.com/pytorch/tutorials/pull/2458 |
+| NM512 | 2 | https://github.com/pytorch/tutorials/pull/2451 |
+| j3soon | 2 | https://github.com/pytorch/tutorials/pull/2420 |
+| Samsonboadi | 2 | https://github.com/pytorch/tutorials/pull/2406 |
+| neuralninja27 | 2 | https://github.com/pytorch/tutorials/pull/2381 |
+| akjalok | 2 | https://github.com/pytorch/tutorials/pull/2380 |
+| tcNickolas | 2 | https://github.com/pytorch/tutorials/pull/2378 |
+| Suhas-G | 2 | https://github.com/pytorch/tutorials/pull/2371 |
+| BeniaminC | 2 | https://github.com/pytorch/tutorials/pull/2366 |
+| ver2king | 2 | https://github.com/pytorch/tutorials/pull/2445, https://github.com/pytorch/tutorials/pull/2459 |
+| mikgor | 1 | https://github.com/pytorch/tutorials/pull/2417 |
+| spzala | 1 | https://github.com/pytorch/tutorials/pull/1579 |
diff --git a/domains.rst b/domains.rst
new file mode 100644
index 00000000000..fbc5fcdedd7
--- /dev/null
+++ b/domains.rst
@@ -0,0 +1,163 @@
+:orphan:
+
+Domains
+=======
+
+This section contains specialized tutorials focused on applying
+PyTorch to specific application areas. These guides demonstrate
+how to use domain-specific libraries like torchvision, torchaudio, and
+others. This section is for developers looking to implement PyTorch
+in particular fields of deep learning.
+
+.. raw:: html
+
+   <div id="tutorial-cards-container">
+
+    <nav class="navbar navbar-expand-lg navbar-light tutorials-nav col-12">
+        <div class="tutorial-tags-container">
+            <div id="dropdown-filter-tags">
+                <div class="tutorial-filter-menu">
+                    <div class="tutorial-filter filter-btn all-tag-selected" data-tag="all">All</div>
+                </div>
+            </div>
+        </div>
+    </nav>
+
+    <hr class="tutorials-hr">
+
+    <div class="row">
+
+    <div id="tutorial-cards">
+    <div class="list">
+
+.. Add cards below this line
+.. customcarditem::
+   :header: TorchVision Object Detection Finetuning Tutorial
+   :card_description: Finetune a pre-trained Mask R-CNN model.
+   :image: _static/img/thumbnails/cropped/TorchVision-Object-Detection-Finetuning-Tutorial.png
+   :link: intermediate/torchvision_tutorial.html
+   :tags: Image/Video
+
+.. customcarditem::
+   :header: Transfer Learning for Computer Vision Tutorial
+   :card_description: Train a convolutional neural network for image classification using transfer learning.
+   :image: _static/img/thumbnails/cropped/Transfer-Learning-for-Computer-Vision-Tutorial.png
+   :link: beginner/transfer_learning_tutorial.html
+   :tags: Image/Video
+
+.. customcarditem::
+   :header: Adversarial Example Generation
+   :card_description: Train a convolutional neural network for image classification using transfer learning.
+   :image: _static/img/thumbnails/cropped/Adversarial-Example-Generation.png
+   :link: beginner/fgsm_tutorial.html
+   :tags: Image/Video
+
+.. customcarditem::
+   :header: DCGAN Tutorial
+   :card_description: Train a generative adversarial network (GAN) to generate new celebrities.
+   :image: _static/img/thumbnails/cropped/DCGAN-Tutorial.png
+   :link: beginner/dcgan_faces_tutorial.html
+   :tags: Image/Video
+
+.. customcarditem::
+   :header: Spatial Transformer Networks Tutorial
+   :card_description: Learn how to augment your network using a visual attention mechanism.
+   :image: _static/img/stn/Five.gif
+   :link: intermediate/spatial_transformer_tutorial.html
+   :tags: Image/Video
+
+.. customcarditem::
+   :header: Semi-Supervised Learning Tutorial Based on USB
+   :card_description: Learn how to train semi-supervised learning algorithms (on custom data) using USB and PyTorch.
+   :image: _static/img/usb_semisup_learn/code.png
+   :link: advanced/usb_semisup_learn.html
+   :tags: Image/Video
+
+.. Reinforcement Learning
+.. customcarditem::
+   :header: Reinforcement Learning (DQN)
+   :card_description: Learn how to use PyTorch to train a Deep Q Learning (DQN) agent on the CartPole-v0 task from the OpenAI Gym.
+   :image: _static/img/cartpole.gif
+   :link: intermediate/reinforcement_q_learning.html
+   :tags: Reinforcement-Learning
+
+.. customcarditem::
+   :header: Reinforcement Learning (PPO) with TorchRL
+   :card_description: Learn how to use PyTorch and TorchRL to train a Proximal Policy Optimization agent on the Inverted Pendulum task from Gym.
+   :image: _static/img/invpendulum.gif
+   :link: intermediate/reinforcement_ppo.html
+   :tags: Reinforcement-Learning
+
+.. customcarditem::
+   :header: Train a Mario-playing RL Agent
+   :card_description: Use PyTorch to train a Double Q-learning agent to play Mario.
+   :image: _static/img/mario.gif
+   :link: intermediate/mario_rl_tutorial.html
+   :tags: Reinforcement-Learning
+
+.. customcarditem::
+   :header: Recurrent DQN
+   :card_description: Use TorchRL to train recurrent policies
+   :image: _static/img/rollout_recurrent.png
+   :link: intermediate/dqn_with_rnn_tutorial.html
+   :tags: Reinforcement-Learning
+
+.. customcarditem::
+   :header: Code a DDPG Loss
+   :card_description: Use TorchRL to code a DDPG Loss
+   :image: _static/img/half_cheetah.gif
+   :link: advanced/coding_ddpg.html
+   :tags: Reinforcement-Learning
+
+.. customcarditem::
+   :header: Writing your environment and transforms
+   :card_description: Use TorchRL to code a Pendulum
+   :image: _static/img/pendulum.gif
+   :link: advanced/pendulum.html
+   :tags: Reinforcement-Learning
+
+.. -----------------------------------------
+.. Page TOC
+.. -----------------------------------------
+.. toctree::
+   :maxdepth: 1
+   :includehidden:
+   :hidden:
+   :caption: Image and Video
+
+   intermediate/torchvision_tutorial
+   beginner/transfer_learning_tutorial
+   beginner/fgsm_tutorial
+   beginner/dcgan_faces_tutorial
+   intermediate/spatial_transformer_tutorial
+
+.. toctree::
+   :maxdepth: 2
+   :includehidden:
+   :hidden:
+   :caption: Reinforcement Learning
+
+   intermediate/reinforcement_q_learning
+   intermediate/reinforcement_ppo
+   intermediate/dqn_with_rnn_tutorial.html
+   intermediate/mario_rl_tutorial
+   advanced/pendulum
+   advanced/coding_ddpg.html
+
+.. toctree::
+   :maxdepth: 2
+   :includehidden:
+   :hidden:
+   :caption: Recommendation Systems
+
+   intermediate/torchrec_intro_tutorial
+   advanced/sharding
+
+.. toctree::
+   :maxdepth: 2
+   :includehidden:
+   :hidden:
+   :caption: Other Domains
+
+   See Audio tutorials on the audio website <https://pytorch.org/audio/stable/index.html>
+   See ExecuTorch tutorials on the ExecuTorch website <https://pytorch.org/executorch/stable/index.html>
diff --git a/ecosystem.rst b/ecosystem.rst
new file mode 100644
index 00000000000..da2a926851a
--- /dev/null
+++ b/ecosystem.rst
@@ -0,0 +1,70 @@
+Ecosystem
+=========
+
+Explore tutorials that cover tools and frameworks in
+the PyTorch ecosystem. These practical guides will help you leverage
+PyTorch's extensive ecosystem for everything from experimentation
+to production deployment.
+
+.. raw:: html
+
+   <div id="tutorial-cards-container">
+
+    <nav class="navbar navbar-expand-lg navbar-light tutorials-nav col-12">
+        <div class="tutorial-tags-container">
+            <div id="dropdown-filter-tags">
+                <div class="tutorial-filter-menu">
+                    <div class="tutorial-filter filter-btn all-tag-selected" data-tag="all">All</div>
+                </div>
+            </div>
+        </div>
+    </nav>
+
+    <hr class="tutorials-hr">
+
+    <div class="row">
+
+    <div id="tutorial-cards">
+    <div class="list">
+
+.. Add tutorial cards below this line
+.. customcarditem::
+   :header: Hyperparameter Tuning Tutorial
+   :card_description: Learn how to use Ray Tune to find the best performing set of hyperparameters for your model.
+   :image: _static/img/ray-tune.png
+   :link: beginner/hyperparameter_tuning_tutorial.html
+   :tags: Model-Optimization,Best-Practice,Ecosystem
+
+.. customcarditem::
+   :header: Multi-Objective Neural Architecture Search with Ax
+   :card_description: Learn how to use Ax to search over architectures find optimal tradeoffs between accuracy and latency.
+   :image: _static/img/ax_logo.png
+   :link: intermediate/ax_multiobjective_nas_tutorial.html
+   :tags: Model-Optimization,Best-Practice,Ax,TorchX,Ecosystem
+
+.. customcarditem::
+   :header: Performance Profiling in TensorBoard
+   :card_description: Learn how to use the TensorBoard plugin to profile and analyze your model's performance.
+   :image: _static/img/thumbnails/cropped/profiler.png
+   :link: intermediate/tensorboard_profiler_tutorial.html
+   :tags: Model-Optimization,Best-Practice,Profiling,TensorBoard,Ecosystem
+
+.. customcarditem::
+   :header: Real Time Inference on Raspberry Pi 4
+   :card_description: This tutorial covers how to run quantized and fused models on a Raspberry Pi 4 at 30 fps.
+   :image: _static/img/thumbnails/cropped/realtime_rpi.png
+   :link: intermediate/realtime_rpi.html
+   :tags: Model-Optimization,Image/Video,Quantization,Ecosystem
+
+.. End of tutorial card section
+.. -----------------------------------------
+.. Page TOC
+.. -----------------------------------------
+.. toctree::
+   :maxdepth: 2
+   :hidden:
+
+   beginner/hyperparameter_tuning_tutorial
+   intermediate/ax_multiobjective_nas_tutorial
+   intermediate/tensorboard_profiler_tutorial
+   intermediate/realtime_rpi
diff --git a/en-wordlist.txt b/en-wordlist.txt
new file mode 100644
index 00000000000..baf75d75ac0
--- /dev/null
+++ b/en-wordlist.txt
@@ -0,0 +1,711 @@
+ACL
+ADI
+ALiBi
+AOT
+AOTInductor
+APIs
+ATen
+AVX
+Args
+Autograd
+BCE
+BFGS
+BLAS
+BLEU
+BN
+BOS
+BT
+Backpropagating
+Bahdanau
+BatchNorm
+Bethge
+Bfloat
+CHW
+CIFAR
+CLS
+CNNDM
+CNNs
+CPUs
+CPython
+CUDA
+Caffe
+Captum
+Captum's
+CartPole
+Cayley
+CharRNN
+Chatbots
+Chen
+Colab
+Colorectal
+Composibility
+Conda
+Conv
+ConvNet
+ConvNets
+Cuda
+CudaLaunchKernel
+CudaMemcpyAsync
+CudaMemsetAsync
+DCGAN
+DCGANs
+DDP
+DDPG
+DDQN
+DLRM
+DMA
+DNN
+DQN
+DataLoaders
+DataPipe
+DataPipes
+Decompositions
+DeepLabV
+DeepMind
+DeiT
+DenseNet
+DeviceMesh
+Dialogs
+DyNet
+EOS
+EPS
+Ecker
+ExecuTorch
+ExportDB
+FC
+FGSM
+tensordict
+DataLoader's
+FLAVA
+FSDP
+FX
+FX's
+FairSeq
+Fastpath
+FakeTensor
+FakeTensors
+FFN
+FloydHub
+FloydHub's
+Frobenius
+Frontend
+GAE
+GAN
+GANs
+GEMM
+GLOO
+GPT
+GPU's
+GPUs
+GRU
+GRUs
+GTC
+Gatys
+GeForce
+Goodfellow
+Goodfellow’s
+Graviton
+GreedySearchDecoder
+HTA
+HVP
+Hao
+HistoEnc
+HistoEncoder
+HSDP
+Hugging Face
+IMDB
+IOT
+IR
+IRs
+ISA
+ITERS
+ImageNet
+Inductor
+Initializations
+Interpretability
+Iteratively
+JSON
+JVP
+Jacobian
+Joona
+Kather
+Keras
+Kihyuk
+Kiuk
+Kubernetes
+Kuei
+KV
+LRSchedulers
+LSTM
+LSTMs
+LYM
+LeCun
+LeNet
+LeakyReLU
+LeakyReLUs
+Lipschitz
+LoRa
+Lua
+Luong
+MHA
+MKLDNN
+MLP
+MLPs
+MNIST
+MPS
+MUC
+MacBook
+MacOS
+MaskRCNN
+Minifier
+MobileNet
+ModelABC
+MPS
+MTIA
+Mypy
+NAS
+NCCL
+NCHW
+NDK
+NES
+NLP
+NTK
+NUMA
+NaN
+NaNs
+NanoGPT
+Netron
+NeurIPS
+Norvig
+NumPy
+Numericalization
+Numpy's
+ONNX
+ONNX Runtime
+ONNX Script
+ONNX's
+OOM
+OU
+OpenAI
+OpenBLAS
+OpenJpeg
+OpenMP
+OpenSlide
+Opset
+Ornstein
+PIL
+PIL's
+PPO
+PatchPredictor
+PennFudan
+Perfetto
+Pixman
+Plotly
+Pohjonen
+Prec
+Profiler
+PyTorch's
+QuickStart
+RCNN
+RGB
+RGBA
+RL
+RNN
+RNNs
+ROCm
+RPC
+RPN
+RRef
+RTX
+Radford
+ReLU
+ReLUs
+ResNeXt
+ResNet
+Resampling
+Runtime's
+SDPA
+SGD
+SIMD
+SPD
+SQuAD
+SSD
+SSL
+SST2
+STN
+STR
+SVE
+SciPy
+Sequentials
+Sharding
+Sigmoid
+SoTA
+Sohn
+Spacy
+SwiGLU
+TCP
+THP
+TIAToolbox
+TODO
+TPU
+TensorBoard
+TensorBoards
+TensorDict
+TensorFloat
+TextVQA
+Theano
+Tokenization
+TorchDynamo
+TorchInductor
+TorchMultimodal
+TorchRL
+TorchRL's
+TorchScript
+TorchVision
+TorchVision
+TorchX
+Tunable
+UI
+UMAP
+Uhlenbeck
+Unescape
+VGG
+VLDB
+VQA
+VS Code
+ViT
+Volterra
+WMT
+WSI
+WSIs
+WSI’s
+Wang
+Wikitext
+Woohoo
+XLM
+Xception
+Xcode
+Xeon
+Yidong
+YouTube
+Zipf
+accelerometer
+accuracies
+activations
+adversarially
+affine
+al
+allocator
+allocator's
+allocators
+approximators
+autodiff
+autoencoder
+autograd
+autotune
+autotuner
+backend
+backends
+backprop
+backpropagate
+backpropagated
+backpropagates
+backpropagation
+backtrace
+batchnorm
+batchnorm's
+bbAP
+benchmarked
+benchmarking
+bitwise
+bool
+boolean
+breakpoint
+broadcasted
+bw
+bytecode
+callable's
+cancelation
+cardinality
+chatbot
+chatbot's
+checkpointing
+chroma
+codegen
+colorbar
+compilable
+composable
+composability
+concat
+conda
+config
+configs
+contrastive
+conv
+convolutional
+cpu
+csv
+cuDNN
+cuda
+customizable
+customizations
+datafile
+dataflow
+dataframe
+dataloader
+dataloaders
+datapipes
+dataset
+datasets
+dataset’s
+deallocation
+decompositions
+decorrelated
+deserialize
+deserialized
+desynchronization
+deterministically
+devicemesh
+dimensionality
+dir
+discontiguous
+distractor
+downsample
+downsamples
+dropdown
+dtensor
+dtype
+dtypes
+duration
+elementwise
+embeddings
+encodings
+enqueuing
+ensembling
+enum
+eq
+equalities
+et
+eval
+evaluateInput
+extensibility
+fastai
+fastmath
+fastpath
+fbgemm
+feedforward
+finetune
+finetuning
+FlexAttention
+fp
+frontend
+functionalized
+functionalizes
+functionalization
+functorch
+fuser
+geomean
+globals
+grayscale
+html
+handoff
+hardcode
+helpdesk
+helpdesks
+hessian
+hessians
+histoencoder
+histologically
+homonymous
+hotspot
+hvp
+hyperparameter
+hyperparameters
+imagenet
+img
+inductor
+inferencing
+initializations
+inlined
+interpretable
+intra
+invariance
+io
+iter
+iterable
+iteratively
+jacobian
+jacobians
+jit
+jitter
+jpg
+json
+judgements
+jupyter
+kernels
+keypoint
+kwargs
+labelled
+latencies
+learnable
+learnings
+linearities
+loadFilename
+logits
+mAP
+macos
+manualSeed
+matmul
+matmuls
+matplotlib
+memcpy
+memset
+minibatch
+minibatches
+minified
+minifying
+minimax
+misclassification
+misclassified
+modularity
+modularized
+mpp
+mucosa
+multihead
+MultiheadAttention
+multimodal
+multimodality
+multinode
+multiobjective
+multiprocessed
+multithreaded
+multithreading
+namespace
+natively
+ndarrays
+nheads
+nightlies
+NJT
+NJTs
+NJT's
+num
+numericalize
+numpy
+nvFuser
+nvFuser's
+ok
+oneDNN
+opset
+optimizable
+optimizer's
+optimizers
+otsu
+overfitting
+pageable
+parallelizable
+parallelization
+parametrization
+parametrizations
+parametrized
+parametrizing
+perceptibility
+performant
+pickleable
+pipelining
+pointwise
+postprocessing
+pre
+pre
+preallocate
+preallocates
+preallocation
+precompute
+precomputing
+prepend
+preprocess
+preprocessing
+prepruned
+prespecified
+pretrained
+prewritten
+primals
+processgroup
+profiler
+profilers
+protobuf
+py
+pytorch
+quantized
+quantizing
+queryable
+randint
+randn
+readably
+recomputation
+reenable
+regressor
+reimplement
+reimplementing
+reimplements
+reinitializes
+relu
+reproducibility
+rescale
+rescaling
+reshard
+resnet
+restride
+rewinded
+rgb
+rollout
+rollouts
+romanized
+runnable
+runtime
+runtime
+runtimes
+scalable
+SDPA
+sharded
+softmax
+sparsified
+sparsifier
+sparsifiers
+sparsify
+sparsifying
+specificities
+src
+stacktrace
+stateful
+storages
+strided
+stroma
+subclasses
+subclassing
+subcomponent
+subcomponents
+subdirectories
+subfolder
+submodule
+submodules
+subnetworks
+subproblems
+subprocess
+subprocesses
+subreddit
+subregion
+subregion's
+summarization
+swappable
+tanh
+tensor's
+th
+thresholding
+tiatoolbox
+timestep
+timesteps
+tmp
+tokenization
+tokenize
+tokenized
+tokenizer
+tokenizes
+tooltip
+topologies
+torchaudio
+torchdata
+torchrun
+torchscriptable
+torchtext
+torchtext's
+torchvision
+torchviz
+traceback
+tradeoff
+tradeoffs
+triton
+uint
+UX
+umap
+unbacked
+uncomment
+uncommented
+underflowing
+unfused
+unicode
+unimodal
+unigram
+unnormalized
+unoptimized
+unparametrized
+unpickling
+unpruned
+unscale
+unscaled
+unscales
+upscaled
+utils
+vectorization
+vectorize
+vectorized
+vhp
+voc
+walkthrough
+warmstart
+warmstarted
+warmstarting
+warmup
+webp
+wikitext
+wsi
+wsis
+Meta's
+RecSys
+TorchRec
+sharding
+TBE
+EBC
+sharder
+hyperoptimized
+DMP
+unsharded
+lookups
+KJTs
+amongst
+async
+everytime
+prototyped
+GBs
+HBM
+gloo
+nccl
+Localhost
+gpu
+torchmetrics
+url
+colab
+sharders
+Criteo
+torchrec
+_batch_norm_impl_index
+convolution_overrideable
+aten
+XPU
+XPUs
+impl
+overrideable
+TorchServe
+Inductor’s
+onwards
+recompilations
+BiasCorrection
+ELU
+GELU
+NNCF
+OpenVINO
+OpenVINOQuantizer
+PReLU
+Quantizer
+SmoothQuant
+quantizer
+quantizers
\ No newline at end of file
diff --git a/extension.rst b/extension.rst
new file mode 100644
index 00000000000..ee4d4524418
--- /dev/null
+++ b/extension.rst
@@ -0,0 +1,106 @@
+:orphan:
+
+Extension
+=========
+
+This section provides insights into extending PyTorch's capabilities.
+It covers custom operations, frontend APIs, and advanced topics like
+C++ extensions and dispatcher usage.
+
+.. raw:: html
+
+    <div id="tutorial-cards-container">
+
+    <nav class="navbar navbar-expand-lg navbar-light tutorials-nav col-12">
+        <div class="tutorial-tags-container">
+            <div id="dropdown-filter-tags">
+                <div class="tutorial-filter-menu">
+                    <div class="tutorial-filter filter-btn all-tag-selected" data-tag="all">All</div>
+                </div>
+            </div>
+        </div>
+    </nav>
+
+    <hr class="tutorials-hr">
+
+    <div class="row">
+
+    <div id="tutorial-cards">
+    <div class="list">
+
+.. Add tutorial cards below this line
+.. customcarditem::
+   :header: PyTorch Custom Operators Landing Page
+   :card_description: This is the landing page for all things related to custom operators in PyTorch.
+   :image: _static/img/thumbnails/cropped/Custom-Cpp-and-CUDA-Extensions.png
+   :link: advanced/custom_ops_landing_page.html
+   :tags: Extending-PyTorch,Frontend-APIs,C++,CUDA
+
+.. customcarditem::
+   :header: Custom Python Operators
+   :card_description: Create Custom Operators in Python. Useful for black-boxing a Python function for use with torch.compile.
+   :image: _static/img/thumbnails/cropped/Custom-Cpp-and-CUDA-Extensions.png
+   :link: advanced/python_custom_ops.html
+   :tags: Extending-PyTorch,Frontend-APIs,C++,CUDA
+
+.. customcarditem::
+   :header: Custom C++ and CUDA Operators
+   :card_description: How to extend PyTorch with custom C++ and CUDA operators.
+   :image: _static/img/thumbnails/cropped/Custom-Cpp-and-CUDA-Extensions.png
+   :link: advanced/cpp_custom_ops.html
+   :tags: Extending-PyTorch,Frontend-APIs,C++,CUDA
+
+.. customcarditem::
+   :header: Custom Function Tutorial: Double Backward
+   :card_description: Learn how to write a custom autograd Function that supports double backward.
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: intermediate/custom_function_double_backward_tutorial.html
+   :tags: Extending-PyTorch,Frontend-APIs
+
+.. customcarditem::
+   :header: Custom Function Tutorial: Fusing Convolution and Batch Norm
+   :card_description: Learn how to create a custom autograd Function that fuses batch norm into a convolution to improve memory usage.
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: intermediate/custom_function_conv_bn_tutorial.html
+   :tags: Extending-PyTorch,Frontend-APIs
+
+.. customcarditem::
+   :header: Registering a Dispatched Operator in C++
+   :card_description: The dispatcher is an internal component of PyTorch which is responsible for figuring out what code should actually get run when you call a function like torch::add.
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: advanced/dispatcher.html
+   :tags: Extending-PyTorch,Frontend-APIs,C++
+
+.. customcarditem::
+   :header: Extending Dispatcher For a New Backend in C++
+   :card_description: Learn how to extend the dispatcher to add a new device living outside of the pytorch/pytorch repo and maintain it to keep in sync with native PyTorch devices.
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: advanced/extend_dispatcher.html
+   :tags: Extending-PyTorch,Frontend-APIs,C++
+
+.. customcarditem::
+   :header: Facilitating New Backend Integration by PrivateUse1
+   :card_description: Learn how to integrate a new backend living outside of the pytorch/pytorch repo and maintain it to keep in sync with the native PyTorch backend.
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: advanced/privateuseone.html
+   :tags: Extending-PyTorch,Frontend-APIs,C++
+
+.. End of tutorial card section
+.. -----------------------------------------
+.. Page TOC
+.. -----------------------------------------
+.. toctree::
+   :maxdepth: 2
+   :includehidden:
+   :hidden:
+   :caption: Extending PyTorch
+
+   advanced/custom_ops_landing_page
+   advanced/python_custom_ops
+   advanced/cpp_custom_ops
+   intermediate/custom_function_double_backward_tutorial
+   intermediate/custom_function_conv_bn_tutorial
+   advanced/cpp_extension
+   advanced/dispatcher
+   advanced/extend_dispatcher
+   advanced/privateuseone
diff --git a/index.rst b/index.rst
index d6671f42da3..3f81d3d257a 100644
--- a/index.rst
+++ b/index.rst
@@ -1,251 +1,784 @@
 Welcome to PyTorch Tutorials
 ============================
 
-To learn how to use PyTorch, begin with our Getting Started Tutorials.
-The :doc:`60-minute blitz </beginner/deep_learning_60min_blitz>` is the most common
-starting point, and provides a broad view into how to use PyTorch from the basics all the way into constructing deep neural networks.
-
-Some considerations:
-
-* We’ve added a new feature to tutorials that allows users to open the notebook associated with a tutorial in Google Colab.
-  Visit `this page <https://pytorch.org/tutorials/beginner/colab.html>`_ for more information.
-* If you would like to do the tutorials interactively via IPython / Jupyter,
-  each tutorial has a download link for a Jupyter Notebook and Python source code.
-* Additional high-quality examples are available, including image classification,
-  unsupervised learning, reinforcement learning, machine translation, and
-  many other applications, in `PyTorch Examples
-  <https://github.com/pytorch/examples/>`_.
-* You can find reference documentation for the PyTorch API and layers in `PyTorch Docs
-  <https://pytorch.org/docs>`_ or via inline help.
-* If you would like the tutorials section improved, please open a github issue
-  `here <https://github.com/pytorch/tutorials>`_ with your feedback.
-* Check out our
-  `PyTorch Cheat Sheet <https://pytorch.org/tutorials/beginner/ptcheat.html>`_
-  for additional useful information.
-* Finally, here's a link to the
-  `PyTorch Release Notes <https://github.com/pytorch/pytorch/releases>`_
-
-Getting Started
-------------------
-
-.. customgalleryitem::
-   :figure: /_static/img/thumbnails/pytorch-logo-flat.png
-   :tooltip: Understand PyTorch’s Tensor library and neural networks at a high level
-   :description: :doc:`/beginner/deep_learning_60min_blitz`
-
-.. customgalleryitem::
-   :figure: /_static/img/thumbnails/landmarked_face2.png
-   :tooltip: Learn how to load and preprocess/augment data from a non trivial dataset
-   :description: :doc:`/beginner/data_loading_tutorial`
-
-.. customgalleryitem::
-   :tooltip: This tutorial introduces the fundamental concepts of PyTorch through self-contained examples
-   :figure: /_static/img/thumbnails/examples.png
-   :description: :doc:`/beginner/pytorch_with_examples`
-
-.. customgalleryitem::
-   :figure: /_static/img/thumbnails/sphx_glr_transfer_learning_tutorial_001.png
-   :tooltip: In transfer learning, a model created from one task is used in another
-   :description: :doc:`beginner/transfer_learning_tutorial`
-
-.. customgalleryitem::
-   :figure: /_static/img/hybrid.png
-   :tooltip: Experiment with some of the key features of the PyTorch hybrid frontend
-   :description: :doc:`beginner/deploy_seq2seq_hybrid_frontend_tutorial`
-
-.. customgalleryitem::
-   :figure: /_static/img/thumbnails/floppy.png
-   :tooltip: Explore use cases for the saving and loading of PyTorch models
-   :description: :doc:`beginner/saving_loading_models`
-
-.. .. galleryitem:: beginner/saving_loading_models.py
-
-.. customgalleryitem::
-   :figure: /_static/img/torch.nn.png
-   :tooltip: Use torch.nn to create and train a neural network
-   :description: :doc:`beginner/nn_tutorial`
+**What's new in PyTorch tutorials?**
 
+* `Integrating Custom Operators with SYCL for Intel GPU <https://pytorch.org/tutorials/advanced/cpp_custom_ops_sycl.html>`__
+* `Supporting Custom C++ Classes in torch.compile/torch.export <https://docs.pytorch.org/tutorials/advanced/custom_class_pt2.html>`__
+* `Accelerating torch.save and torch.load with GPUDirect Storage <https://docs.pytorch.org/tutorials/unstable/gpu_direct_storage.html>`__
+* `Getting Started with Fully Sharded Data Parallel (FSDP2) <https://docs.pytorch.org/tutorials/intermediate/FSDP_tutorial.html>`__
 
 .. raw:: html
 
-    <div style='clear:both'></div>
-
-
-Image
-----------------------
-
-.. customgalleryitem::
-   :figure: /_static/img/thumbnails/tv-img.png
-   :tooltip: Finetuning a pre-trained Mask R-CNN model
-   :description: :doc:`intermediate/torchvision_tutorial`
+    <div class="tutorials-callout-container">
+        <div class="row">
 
-.. customgalleryitem::
-   :figure: /_static/img/thumbnails/eye.png
-   :tooltip: Finetune and feature extract the torchvision models
-   :description: :doc:`beginner/finetuning_torchvision_models_tutorial`
+.. Add callout items below this line
 
-.. customgalleryitem::
-   :figure: /_static/img/stn/Five.gif
-   :tooltip: Learn how to augment your network using a visual attention mechanism called spatial transformer networks
-   :description: :doc:`intermediate/spatial_transformer_tutorial`
+.. customcalloutitem::
+   :description: Familiarize yourself with PyTorch concepts and modules. Learn how to load data, build deep neural networks, train and save your models in this quickstart guide.
+   :header: Learn the Basics
+   :button_link:  beginner/basics/intro.html
+   :button_text: Get started with PyTorch
 
-.. customgalleryitem::
-   :figure: /_static/img/neural-style/sphx_glr_neural_style_tutorial_004.png
-   :tooltip: How to implement the Neural-Style algorithm developed by Gatys, Ecker, and Bethge
-   :description: :doc:`advanced/neural_style_tutorial`
+.. customcalloutitem::
+   :description: Bite-size, ready-to-deploy PyTorch code examples.
+   :header: PyTorch Recipes
+   :button_link: recipes_index.html
+   :button_text: Explore Recipes
 
-.. customgalleryitem::
-   :figure: /_static/img/panda.png
-   :tooltip: Raise your awareness to the security vulnerabilities of ML models, and get insight into the hot topic of adversarial machine learning
-   :description: :doc:`beginner/fgsm_tutorial`
-
-.. customgalleryitem::
-   :figure: /_static/img/cat.jpg
-   :tooltip: Use ONNX to convert a model defined in PyTorch into the ONNX format and then load it into Caffe2
-   :description: :doc:`advanced/super_resolution_with_caffe2`
+.. End of callout item section
 
 .. raw:: html
 
-    <div style='clear:both'></div>
-
+        </div>
+    </div>
+
+    <div id="tutorial-cards-container">
+
+    <nav class="navbar navbar-expand-lg navbar-light tutorials-nav col-12">
+        <div class="tutorial-tags-container">
+            <div id="dropdown-filter-tags">
+                <div class="tutorial-filter-menu">
+                    <div class="tutorial-filter filter-btn all-tag-selected" data-tag="all">All</div>
+                </div>
+            </div>
+        </div>
+    </nav>
+
+    <hr class="tutorials-hr">
+
+    <div class="row">
+
+    <div id="tutorial-cards">
+    <div class="list">
+
+.. Add tutorial cards below this line
+
+.. Learning PyTorch
+
+.. customcarditem::
+   :header: Learn the Basics
+   :card_description: A step-by-step guide to building a complete ML workflow with PyTorch.
+   :image: _static/img/thumbnails/cropped/60-min-blitz.png
+   :link: beginner/basics/intro.html
+   :tags: Getting-Started
+
+.. customcarditem::
+   :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/introyt_index.html
+   :tags: Getting-Started
+
+.. customcarditem::
+   :header: Learning PyTorch with Examples
+   :card_description: This tutorial introduces the fundamental concepts of PyTorch through self-contained examples.
+   :image: _static/img/thumbnails/cropped/learning-pytorch-with-examples.png
+   :link: beginner/pytorch_with_examples.html
+   :tags: Getting-Started
+
+.. customcarditem::
+   :header: What is torch.nn really?
+   :card_description: Use torch.nn to create and train a neural network.
+   :image: _static/img/thumbnails/cropped/torch-nn.png
+   :link: beginner/nn_tutorial.html
+   :tags: Getting-Started
+
+.. customcarditem::
+   :header: Visualizing Models, Data, and Training with TensorBoard
+   :card_description: Learn to use TensorBoard to visualize data and model training.
+   :image: _static/img/thumbnails/cropped/visualizing-with-tensorboard.png
+   :link: intermediate/tensorboard_tutorial.html
+   :tags: Interpretability,Getting-Started,TensorBoard
+
+.. customcarditem::
+   :header: Good usage of `non_blocking` and `pin_memory()` in PyTorch
+   :card_description: A guide on best practices to copy data from CPU to GPU.
+   :image: _static/img/pinmem.png
+   :link: intermediate/pinmem_nonblock.html
+   :tags: Getting-Started
+
+.. customcarditem::
+   :header: Understanding requires_grad, retain_grad, Leaf, and Non-leaf Tensors
+   :card_description: Learn the subtleties of requires_grad, retain_grad, leaf, and non-leaf tensors
+   :image: _static/img/thumbnails/cropped/understanding_leaf_vs_nonleaf.png
+   :link: beginner/understanding_leaf_vs_nonleaf_tutorial.html
+   :tags: Getting-Started
+
+.. customcarditem::
+   :header: Visualizing Gradients in PyTorch
+   :card_description: Visualize the gradient flow of a network.
+   :image: _static/img/thumbnails/cropped/visualizing_gradients_tutorial.png
+   :link: intermediate/visualizing_gradients_tutorial.html
+   :tags: Getting-Started
+
+.. Image/Video
+
+.. customcarditem::
+   :header: TorchVision Object Detection Finetuning Tutorial
+   :card_description: Finetune a pre-trained Mask R-CNN model.
+   :image: _static/img/thumbnails/cropped/TorchVision-Object-Detection-Finetuning-Tutorial.png
+   :link: intermediate/torchvision_tutorial.html
+   :tags: Image/Video
+
+.. customcarditem::
+   :header: Transfer Learning for Computer Vision Tutorial
+   :card_description: Train a convolutional neural network for image classification using transfer learning.
+   :image: _static/img/thumbnails/cropped/Transfer-Learning-for-Computer-Vision-Tutorial.png
+   :link: beginner/transfer_learning_tutorial.html
+   :tags: Image/Video
+
+.. customcarditem::
+   :header: Adversarial Example Generation
+   :card_description: Train a convolutional neural network for image classification using transfer learning.
+   :image: _static/img/thumbnails/cropped/Adversarial-Example-Generation.png
+   :link: beginner/fgsm_tutorial.html
+   :tags: Image/Video
+
+.. customcarditem::
+   :header: DCGAN Tutorial
+   :card_description: Train a generative adversarial network (GAN) to generate new celebrities.
+   :image: _static/img/thumbnails/cropped/DCGAN-Tutorial.png
+   :link: beginner/dcgan_faces_tutorial.html
+   :tags: Image/Video
+
+.. customcarditem::
+   :header: Spatial Transformer Networks Tutorial
+   :card_description: Learn how to augment your network using a visual attention mechanism.
+   :image: _static/img/stn/Five.gif
+   :link: intermediate/spatial_transformer_tutorial.html
+   :tags: Image/Video
+
+
+.. customcarditem::
+   :header: Semi-Supervised Learning Tutorial Based on USB
+   :card_description: Learn how to train semi-supervised learning algorithms (on custom data) using USB and PyTorch.
+   :image: _static/img/usb_semisup_learn/code.png
+   :link: advanced/usb_semisup_learn.html
+   :tags: Image/Video
 
 .. Audio
-.. ----------------------
-
-.. Uncomment below when adding content
-.. .. raw:: html
-
-    <div style='clear:both'></div>
-
-
-Text
-----------------------
-
-.. customgalleryitem::
-   :figure: /_static/img/chat.png
-   :tooltip: Train a simple chatbot using movie scripts
-   :description: :doc:`beginner/chatbot_tutorial`
-
-.. customgalleryitem::
-   :figure: /_static/img/char_rnn_generation.png
-   :tooltip: Generate names from languages
-   :description: :doc:`intermediate/char_rnn_generation_tutorial`
 
-.. customgalleryitem::
-   :figure: /_static/img/rnnclass.png
-   :tooltip: Build and train a basic character-level RNN to classify words
-   :description: :doc:`intermediate/char_rnn_classification_tutorial`
-
-.. customgalleryitem::
-    :tooltip: Explore the key concepts of deep learning programming using Pytorch
-    :figure: /_static/img/thumbnails/babel.jpg
-    :description: :doc:`/beginner/deep_learning_nlp_tutorial`
-
-.. galleryitem:: intermediate/seq2seq_translation_tutorial.py
-  :figure: _static/img/seq2seq_flat.png
-
-.. raw:: html
-
-    <div style='clear:both'></div>
-
-Generative
-----------------------
-
-.. customgalleryitem::
-    :tooltip: Train a generative adversarial network (GAN) to generate new celebrities
-    :figure: /_static/img/dcgan_generator.png
-    :description: :doc:`beginner/dcgan_faces_tutorial`
+.. customcarditem::
+   :header: Audio IO
+   :card_description: Learn to load data with torchaudio.
+   :image: _static/img/thumbnails/cropped/torchaudio-Tutorial.png
+   :link: beginner/audio_io_tutorial.html
+   :tags: Audio
+
+.. customcarditem::
+   :header: Audio Resampling
+   :card_description: Learn to resample audio waveforms using torchaudio.
+   :image: _static/img/thumbnails/cropped/torchaudio-Tutorial.png
+   :link: beginner/audio_resampling_tutorial.html
+   :tags: Audio
+
+.. customcarditem::
+   :header: Audio Data Augmentation
+   :card_description: Learn to apply data augmentations using torchaudio.
+   :image: _static/img/thumbnails/cropped/torchaudio-Tutorial.png
+   :link: beginner/audio_data_augmentation_tutorial.html
+   :tags: Audio
+
+.. customcarditem::
+   :header: Audio Feature Extractions
+   :card_description: Learn to extract features using torchaudio.
+   :image: _static/img/thumbnails/cropped/torchaudio-Tutorial.png
+   :link: beginner/audio_feature_extractions_tutorial.html
+   :tags: Audio
+
+.. customcarditem::
+   :header: Audio Feature Augmentation
+   :card_description: Learn to augment features using torchaudio.
+   :image: _static/img/thumbnails/cropped/torchaudio-Tutorial.png
+   :link: beginner/audio_feature_augmentation_tutorial.html
+   :tags: Audio
+
+.. customcarditem::
+   :header: Audio Datasets
+   :card_description: Learn to use torchaudio datasets.
+   :image: _static/img/thumbnails/cropped/torchaudio-Tutorial.png
+   :link: beginner/audio_datasets_tutorial.html
+   :tags: Audio
+
+.. customcarditem::
+   :header: Automatic Speech Recognition with Wav2Vec2 in torchaudio
+   :card_description: Learn how to use torchaudio's pretrained models for building a speech recognition application.
+   :image: _static/img/thumbnails/cropped/torchaudio-asr.png
+   :link: intermediate/speech_recognition_pipeline_tutorial.html
+   :tags: Audio
+
+.. customcarditem::
+   :header: Speech Command Classification
+   :card_description: Learn how to correctly format an audio dataset and then train/test an audio classifier network on the dataset.
+   :image: _static/img/thumbnails/cropped/torchaudio-speech.png
+   :link: intermediate/speech_command_classification_with_torchaudio_tutorial.html
+   :tags: Audio
+
+.. customcarditem::
+   :header: Text-to-Speech with torchaudio
+   :card_description: Learn how to use torchaudio's pretrained models for building a text-to-speech application.
+   :image: _static/img/thumbnails/cropped/torchaudio-speech.png
+   :link: intermediate/text_to_speech_with_torchaudio.html
+   :tags: Audio
+
+.. customcarditem::
+   :header: Forced Alignment with Wav2Vec2 in torchaudio
+   :card_description: Learn how to use torchaudio's Wav2Vec2 pretrained models for aligning text to speech
+   :image: _static/img/thumbnails/cropped/torchaudio-alignment.png
+   :link: intermediate/forced_alignment_with_torchaudio_tutorial.html
+   :tags: Audio
+
+.. 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: 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: 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: NLP
+
+.. ONNX
+
+.. customcarditem::
+   :header: Exporting a PyTorch model to ONNX using TorchDynamo backend and Running it using ONNX Runtime
+   :card_description: Build a image classifier model in PyTorch and convert it to ONNX before deploying it with ONNX Runtime.
+   :image: _static/img/thumbnails/cropped/Exporting-PyTorch-Models-to-ONNX-Graphs.png
+   :link: beginner/onnx/export_simple_model_to_onnx_tutorial.html
+   :tags: Production,ONNX,Backends
+
+.. customcarditem::
+   :header: Extending the ONNX exporter operator support
+   :card_description: Demonstrate end-to-end how to address unsupported operators in ONNX.
+   :image: _static/img/thumbnails/cropped/Exporting-PyTorch-Models-to-ONNX-Graphs.png
+   :link: beginner/onnx/onnx_registry_tutorial.html
+   :tags: Production,ONNX,Backends
+
+.. customcarditem::
+   :header: Exporting a model with control flow to ONNX
+   :card_description: Demonstrate how to handle control flow logic while exporting a PyTorch model to ONNX.
+   :image: _static/img/thumbnails/cropped/Exporting-PyTorch-Models-to-ONNX-Graphs.png
+   :link: beginner/onnx/export_control_flow_model_to_onnx_tutorial.html
+   :tags: Production,ONNX,Backends
+
+.. Reinforcement Learning
+
+.. customcarditem::
+   :header: Reinforcement Learning (DQN)
+   :card_description: Learn how to use PyTorch to train a Deep Q Learning (DQN) agent on the CartPole-v0 task from the OpenAI Gym.
+   :image: _static/img/cartpole.gif
+   :link: intermediate/reinforcement_q_learning.html
+   :tags: Reinforcement-Learning
+
+.. customcarditem::
+   :header: Reinforcement Learning (PPO) with TorchRL
+   :card_description: Learn how to use PyTorch and TorchRL to train a Proximal Policy Optimization agent on the Inverted Pendulum task from Gym.
+   :image: _static/img/invpendulum.gif
+   :link: intermediate/reinforcement_ppo.html
+   :tags: Reinforcement-Learning
+
+.. customcarditem::
+   :header: Train a Mario-playing RL Agent
+   :card_description: Use PyTorch to train a Double Q-learning agent to play Mario.
+   :image: _static/img/mario.gif
+   :link: intermediate/mario_rl_tutorial.html
+   :tags: Reinforcement-Learning
+
+.. customcarditem::
+   :header: Recurrent DQN
+   :card_description: Use TorchRL to train recurrent policies
+   :image: _static/img/rollout_recurrent.png
+   :link: intermediate/dqn_with_rnn_tutorial.html
+   :tags: Reinforcement-Learning
+
+.. customcarditem::
+   :header: Code a DDPG Loss
+   :card_description: Use TorchRL to code a DDPG Loss
+   :image: _static/img/half_cheetah.gif
+   :link: advanced/coding_ddpg.html
+   :tags: Reinforcement-Learning
+
+.. customcarditem::
+   :header: Writing your environment and transforms
+   :card_description: Use TorchRL to code a Pendulum
+   :image: _static/img/pendulum.gif
+   :link: advanced/pendulum.html
+   :tags: Reinforcement-Learning
+
+.. Deploying PyTorch Models in Production
+
+.. customcarditem::
+   :header: Profiling PyTorch
+   :card_description: Learn how to profile a PyTorch application
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: beginner/profiler.html
+   :tags: Profiling
+
+.. customcarditem::
+   :header: Profiling PyTorch
+   :card_description: Introduction to Holistic Trace Analysis
+   :link: beginner/hta_intro_tutorial.html
+   :tags: Profiling
+
+.. customcarditem::
+   :header: Profiling PyTorch
+   :card_description: Trace Diff using Holistic Trace Analysis
+   :link: beginner/hta_trace_diff_tutorial.html
+   :tags: Profiling
+
+.. Code Transformations with FX
+
+.. customcarditem::
+   :header: Building a Simple Performance Profiler with FX
+   :card_description: Build a simple FX interpreter to record the runtime of op, module, and function calls and report statistics
+   :image: _static/img/thumbnails/cropped/Deploying-PyTorch-in-Python-via-a-REST-API-with-Flask.png
+   :link: intermediate/fx_profiling_tutorial.html
+   :tags: FX
+
+.. Frontend APIs
+
+.. customcarditem::
+   :header: (beta) Channels Last Memory Format in PyTorch
+   :card_description: Get an overview of Channels Last memory format and understand how it is used to order NCHW tensors in memory preserving dimensions.
+   :image: _static/img/thumbnails/cropped/experimental-Channels-Last-Memory-Format-in-PyTorch.png
+   :link: intermediate/memory_format_tutorial.html
+   :tags: Memory-Format,Best-Practice,Frontend-APIs
+
+.. customcarditem::
+   :header: Using the PyTorch C++ Frontend
+   :card_description: Walk through an end-to-end example of training a model with the C++ frontend by training a DCGAN – a kind of generative model – to generate images of MNIST digits.
+   :image: _static/img/thumbnails/cropped/Using-the-PyTorch-Cpp-Frontend.png
+   :link: advanced/cpp_frontend.html
+   :tags: Frontend-APIs,C++
+
+.. customcarditem::
+   :header: PyTorch Custom Operators Landing Page
+   :card_description: This is the landing page for all things related to custom operators in PyTorch.
+   :image: _static/img/thumbnails/cropped/Custom-Cpp-and-CUDA-Extensions.png
+   :link: advanced/custom_ops_landing_page.html
+   :tags: Extending-PyTorch,Frontend-APIs,C++,CUDA
+
+.. customcarditem::
+   :header: Custom Python Operators
+   :card_description: Create Custom Operators in Python. Useful for black-boxing a Python function for use with torch.compile.
+   :image: _static/img/thumbnails/cropped/Custom-Cpp-and-CUDA-Extensions.png
+   :link: advanced/python_custom_ops.html
+   :tags: Extending-PyTorch,Frontend-APIs,C++,CUDA
+
+.. customcarditem::
+   :header: Compiled Autograd: Capturing a larger backward graph for ``torch.compile``
+   :card_description: Learn how to use compiled autograd to capture a larger backward graph.
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: intermediate/compiled_autograd_tutorial
+   :tags: Model-Optimization,CUDA
+
+.. customcarditem::
+   :header: Custom C++ and CUDA Operators
+   :card_description: How to extend PyTorch with custom C++ and CUDA operators.
+   :image: _static/img/thumbnails/cropped/Custom-Cpp-and-CUDA-Extensions.png
+   :link: advanced/cpp_custom_ops.html
+   :tags: Extending-PyTorch,Frontend-APIs,C++,CUDA
+
+.. customcarditem::
+   :header: Autograd in C++ Frontend
+   :card_description: The autograd package helps build flexible and dynamic neural netorks. In this tutorial, explore several examples of doing autograd in PyTorch C++ frontend
+   :image: _static/img/thumbnails/cropped/Autograd-in-Cpp-Frontend.png
+   :link: advanced/cpp_autograd.html
+   :tags: Frontend-APIs,C++
+
+.. customcarditem::
+   :header: Registering a Dispatched Operator in C++
+   :card_description: The dispatcher is an internal component of PyTorch which is responsible for figuring out what code should actually get run when you call a function like torch::add.
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: advanced/dispatcher.html
+   :tags: Extending-PyTorch,Frontend-APIs,C++
+
+.. customcarditem::
+   :header: Extending Dispatcher For a New Backend in C++
+   :card_description: Learn how to extend the dispatcher to add a new device living outside of the pytorch/pytorch repo and maintain it to keep in sync with native PyTorch devices.
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: advanced/extend_dispatcher.html
+   :tags: Extending-PyTorch,Frontend-APIs,C++
+
+.. customcarditem::
+   :header: Facilitating New Backend Integration by PrivateUse1
+   :card_description: Learn how to integrate a new backend living outside of the pytorch/pytorch repo and maintain it to keep in sync with the native PyTorch backend.
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: advanced/privateuseone.html
+   :tags: Extending-PyTorch,Frontend-APIs,C++
+
+.. customcarditem::
+   :header: Custom Function Tutorial: Double Backward
+   :card_description: Learn how to write a custom autograd Function that supports double backward.
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: intermediate/custom_function_double_backward_tutorial.html
+   :tags: Extending-PyTorch,Frontend-APIs
+
+.. customcarditem::
+   :header: Custom Function Tutorial: Fusing Convolution and Batch Norm
+   :card_description: Learn how to create a custom autograd Function that fuses batch norm into a convolution to improve memory usage.
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: intermediate/custom_function_conv_bn_tutorial.html
+   :tags: Extending-PyTorch,Frontend-APIs
+
+.. customcarditem::
+   :header: Forward-mode Automatic Differentiation
+   :card_description: Learn how to use forward-mode automatic differentiation.
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: intermediate/forward_ad_usage.html
+   :tags: Frontend-APIs
+
+.. customcarditem::
+   :header: Jacobians, Hessians, hvp, vhp, and more
+   :card_description: Learn how to compute advanced autodiff quantities using torch.func
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: intermediate/jacobians_hessians.html
+   :tags: Frontend-APIs
+
+.. customcarditem::
+   :header: Model Ensembling
+   :card_description: Learn how to ensemble models using torch.vmap
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: intermediate/ensembling.html
+   :tags: Frontend-APIs
+
+.. customcarditem::
+   :header: Per-Sample-Gradients
+   :card_description: Learn how to compute per-sample-gradients using torch.func
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: intermediate/per_sample_grads.html
+   :tags: Frontend-APIs
+
+.. customcarditem::
+   :header: Neural Tangent Kernels
+   :card_description: Learn how to compute neural tangent kernels using torch.func
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: intermediate/neural_tangent_kernels.html
+   :tags: Frontend-APIs
+
+.. Model Optimization
+
+.. customcarditem::
+   :header: Performance Profiling in PyTorch
+   :card_description: Learn how to use the PyTorch Profiler to benchmark your module's performance.
+   :image: _static/img/thumbnails/cropped/profiler.png
+   :link: beginner/profiler.html
+   :tags: Model-Optimization,Best-Practice,Profiling
+
+.. customcarditem::
+   :header: Performance Profiling in TensorBoard
+   :card_description: Learn how to use the TensorBoard plugin to profile and analyze your model's performance.
+   :image: _static/img/thumbnails/cropped/profiler.png
+   :link: intermediate/tensorboard_profiler_tutorial.html
+   :tags: Model-Optimization,Best-Practice,Profiling,TensorBoard
+
+.. customcarditem::
+   :header: Hyperparameter Tuning Tutorial
+   :card_description: Learn how to use Ray Tune to find the best performing set of hyperparameters for your model.
+   :image: _static/img/ray-tune.png
+   :link: beginner/hyperparameter_tuning_tutorial.html
+   :tags: Model-Optimization,Best-Practice
+
+.. customcarditem::
+   :header: Parametrizations Tutorial
+   :card_description: Learn how to use torch.nn.utils.parametrize to put constraints on your parameters (e.g. make them orthogonal, symmetric positive definite, low-rank...)
+   :image: _static/img/thumbnails/cropped/parametrizations.png
+   :link: intermediate/parametrizations.html
+   :tags: Model-Optimization,Best-Practice
+
+.. customcarditem::
+   :header: Pruning Tutorial
+   :card_description: Learn how to use torch.nn.utils.prune to sparsify your neural networks, and how to extend it to implement your own custom pruning technique.
+   :image: _static/img/thumbnails/cropped/Pruning-Tutorial.png
+   :link: intermediate/pruning_tutorial.html
+   :tags: Model-Optimization,Best-Practice
+
+.. customcarditem::
+   :header: How to save memory by fusing the optimizer step into the backward pass
+   :card_description: Learn a memory-saving technique through fusing the optimizer step into the backward pass using memory snapshots.
+   :image: _static/img/thumbnails/cropped/pytorch-logo.png
+   :link: intermediate/optimizer_step_in_backward_tutorial.html
+   :tags: Model-Optimization,Best-Practice,CUDA,Frontend-APIs
+
+.. customcarditem::
+   :header: (beta) Accelerating BERT with semi-structured sparsity
+   :card_description: Train BERT, prune it to be 2:4 sparse, and then accelerate it to achieve 2x inference speedups with semi-structured sparsity and torch.compile.
+   :image: _static/img/thumbnails/cropped/Pruning-Tutorial.png
+   :link: advanced/semi_structured_sparse.html
+   :tags: Text,Model-Optimization
+
+.. customcarditem::
+   :header: Multi-Objective Neural Architecture Search with Ax
+   :card_description: Learn how to use Ax to search over architectures find optimal tradeoffs between accuracy and latency.
+   :image: _static/img/ax_logo.png
+   :link: intermediate/ax_multiobjective_nas_tutorial.html
+   :tags: Model-Optimization,Best-Practice,Ax,TorchX
+
+.. customcarditem::
+   :header: torch.compile Tutorial
+   :card_description: Speed up your models with minimal code changes using torch.compile, the latest PyTorch compiler solution.
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: intermediate/torch_compile_tutorial.html
+   :tags: Model-Optimization
+
+.. customcarditem::
+   :header: Building a Convolution/Batch Norm fuser in torch.compile
+   :card_description: Build a simple pattern matcher pass that fuses batch norm into convolution to improve performance during inference.
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: intermediate/torch_compile_conv_bn_fuser.html
+   :tags: Model-Optimization
+
+.. customcarditem::
+   :header: Inductor CPU Backend Debugging and Profiling
+   :card_description: Learn the usage, debugging and performance profiling for ``torch.compile`` with Inductor CPU backend.
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: intermediate/inductor_debug_cpu.html
+   :tags: Model-Optimization
+
+.. customcarditem::
+   :header: (beta) Implementing High-Performance Transformers with SCALED DOT PRODUCT ATTENTION
+   :card_description: This tutorial explores the new torch.nn.functional.scaled_dot_product_attention and how it can be used to construct Transformer components.
+   :image: _static/img/thumbnails/cropped/pytorch-logo.png
+   :link: intermediate/scaled_dot_product_attention_tutorial.html
+   :tags: Model-Optimization,Attention,Transformer
+
+.. customcarditem::
+   :header: Knowledge Distillation in Convolutional Neural Networks
+   :card_description:  Learn how to improve the accuracy of lightweight models using more powerful models as teachers.
+   :image: _static/img/thumbnails/cropped/knowledge_distillation_pytorch_logo.png
+   :link: beginner/knowledge_distillation_tutorial.html
+   :tags: Model-Optimization,Image/Video
+
+
+.. customcarditem::
+   :header: Accelerating PyTorch Transformers by replacing nn.Transformer with Nested Tensors and torch.compile()
+   :card_description: This tutorial goes over recommended best practices for implementing Transformers with native PyTorch.
+   :image: _static/img/thumbnails/cropped/pytorch-logo.png
+   :link: intermediate/transformer_building_blocks.html
+   :tags: Transformer
+
+.. Parallel-and-Distributed-Training
+
+
+
+.. customcarditem::
+   :header: PyTorch Distributed Overview
+   :card_description: Briefly go over all concepts and features in the distributed package. Use this document to find the distributed training technology that can best serve your application.
+   :image: _static/img/thumbnails/cropped/PyTorch-Distributed-Overview.png
+   :link: beginner/dist_overview.html
+   :tags: Parallel-and-Distributed-Training
+
+.. customcarditem::
+   :header: Distributed Data Parallel in PyTorch - Video Tutorials
+   :card_description: This series of video tutorials walks you through distributed training in PyTorch via DDP.
+   :image: _static/img/thumbnails/cropped/PyTorch-Distributed-Overview.png
+   :link: beginner/ddp_series_intro.html
+   :tags: Parallel-and-Distributed-Training
+
+.. customcarditem::
+   :header: Single-Machine Model Parallel Best Practices
+   :card_description:  Learn how to implement model parallel, a distributed training technique which splits a single model onto different GPUs, rather than replicating the entire model on each GPU
+   :image: _static/img/thumbnails/cropped/Model-Parallel-Best-Practices.png
+   :link: intermediate/model_parallel_tutorial.html
+   :tags: Parallel-and-Distributed-Training
+
+.. customcarditem::
+   :header: Getting Started with Distributed Data Parallel
+   :card_description: Learn the basics of when to use distributed data paralle versus data parallel and work through an example to set it up.
+   :image: _static/img/thumbnails/cropped/Getting-Started-with-Distributed-Data-Parallel.png
+   :link: intermediate/ddp_tutorial.html
+   :tags: Parallel-and-Distributed-Training
+
+.. customcarditem::
+   :header: Writing Distributed Applications with PyTorch
+   :card_description: Set up the distributed package of PyTorch, use the different communication strategies, and go over some the internals of the package.
+   :image: _static/img/thumbnails/cropped/Writing-Distributed-Applications-with-PyTorch.png
+   :link: intermediate/dist_tuto.html
+   :tags: Parallel-and-Distributed-Training
+
+.. customcarditem::
+   :header: Large Scale Transformer model training with Tensor Parallel
+   :card_description: Learn how to train large models with Tensor Parallel package.
+   :image: _static/img/thumbnails/cropped/Large-Scale-Transformer-model-training-with-Tensor-Parallel.png
+   :link: intermediate/TP_tutorial.html
+   :tags: Parallel-and-Distributed-Training
+
+.. customcarditem::
+   :header: Customize Process Group Backends Using Cpp Extensions
+   :card_description: Extend ProcessGroup with custom collective communication implementations.
+   :image: _static/img/thumbnails/cropped/Customize-Process-Group-Backends-Using-Cpp-Extensions.png
+   :link: intermediate/process_group_cpp_extension_tutorial.html
+   :tags: Parallel-and-Distributed-Training
+
+.. customcarditem::
+   :header: Getting Started with Distributed RPC Framework
+   :card_description: Learn how to build distributed training using the torch.distributed.rpc package.
+   :image: _static/img/thumbnails/cropped/Getting Started with Distributed-RPC-Framework.png
+   :link: intermediate/rpc_tutorial.html
+   :tags: Parallel-and-Distributed-Training
+
+.. customcarditem::
+   :header: Implementing a Parameter Server Using Distributed RPC Framework
+   :card_description: Walk through a through a simple example of implementing a parameter server using PyTorch’s Distributed RPC framework.
+   :image: _static/img/thumbnails/cropped/Implementing-a-Parameter-Server-Using-Distributed-RPC-Framework.png
+   :link: intermediate/rpc_param_server_tutorial.html
+   :tags: Parallel-and-Distributed-Training
+
+.. customcarditem::
+   :header: Introduction to Distributed Pipeline Parallelism
+   :card_description: Demonstrate how to implement pipeline parallelism using torch.distributed.pipelining
+   :image: _static/img/thumbnails/cropped/Introduction-to-Distributed-Pipeline-Parallelism.png
+   :link: intermediate/pipelining_tutorial.html
+   :tags: Parallel-and-Distributed-Training
+
+.. customcarditem::
+   :header: Implementing Batch RPC Processing Using Asynchronous Executions
+   :card_description: Learn how to use rpc.functions.async_execution to implement batch RPC
+   :image: _static/img/thumbnails/cropped/Implementing-Batch-RPC-Processing-Using-Asynchronous-Executions.png
+   :link: intermediate/rpc_async_execution.html
+   :tags: Parallel-and-Distributed-Training
+
+.. customcarditem::
+   :header: Combining Distributed DataParallel with Distributed RPC Framework
+   :card_description: Walk through a through a simple example of how to combine distributed data parallelism with distributed model parallelism.
+   :image: _static/img/thumbnails/cropped/Combining-Distributed-DataParallel-with-Distributed-RPC-Framework.png
+   :link: advanced/rpc_ddp_tutorial.html
+   :tags: Parallel-and-Distributed-Training
+
+.. customcarditem::
+   :header: Getting Started with Fully Sharded Data Parallel (FSDP2)
+   :card_description: Learn how to train models with Fully Sharded Data Parallel (fully_shard) package.
+   :image: _static/img/thumbnails/cropped/Getting-Started-with-FSDP.png
+   :link: intermediate/FSDP_tutorial.html
+   :tags: Parallel-and-Distributed-Training
+
+.. customcarditem::
+   :header: Introduction to Libuv TCPStore Backend
+   :card_description: TCPStore now uses a new server backend for faster connection and better scalability.
+   :image: _static/img/thumbnails/cropped/Introduction-to-Libuv-Backend-TCPStore.png
+   :link: intermediate/TCPStore_libuv_backend.html
+   :tags: Parallel-and-Distributed-Training
+
+.. Edge
+
+.. customcarditem::
+   :header: Exporting to ExecuTorch Tutorial
+   :card_description: Learn about how to use ExecuTorch, a unified ML stack for lowering PyTorch models to edge devices.
+   :image: _static/img/ExecuTorch-Logo-cropped.svg
+   :link: https://pytorch.org/executorch/stable/tutorials/export-to-executorch-tutorial.html
+   :tags: Edge
+
+.. customcarditem::
+   :header: Running an ExecuTorch Model in C++ Tutorial
+   :card_description: Learn how to load and execute an ExecuTorch model in C++
+   :image: _static/img/ExecuTorch-Logo-cropped.svg
+   :link: https://pytorch.org/executorch/stable/running-a-model-cpp-tutorial.html
+   :tags: Edge
+
+.. customcarditem::
+   :header: Using the ExecuTorch SDK to Profile a Model
+   :card_description: Explore how to use the ExecuTorch SDK to profile, debug, and visualize ExecuTorch models
+   :image: _static/img/ExecuTorch-Logo-cropped.svg
+   :link: https://docs.pytorch.org/executorch/main/tutorials/devtools-integration-tutorial.html
+   :tags: Edge
+
+.. customcarditem::
+   :header: Building an ExecuTorch iOS Demo App
+   :card_description: Explore how to set up the ExecuTorch iOS Demo App, which uses the MobileNet v3 model to process live camera images leveraging three different backends: XNNPACK, Core ML, and Metal Performance Shaders (MPS).
+   :image: _static/img/ExecuTorch-Logo-cropped.svg
+   :link: https://github.com/meta-pytorch/executorch-examples/tree/main/mv3/apple/ExecuTorchDemo
+   :tags: Edge
+
+.. customcarditem::
+   :header: Building an ExecuTorch Android Demo App
+   :card_description: Learn how to set up the ExecuTorch Android Demo App for image segmentation tasks using the DeepLab v3 model and XNNPACK FP32 backend.
+   :image: _static/img/ExecuTorch-Logo-cropped.svg
+   :link: https://github.com/meta-pytorch/executorch-examples/tree/main/dl3/android/DeepLabV3Demo#executorch-android-demo-app
+   :tags: Edge
+
+.. customcarditem::
+   :header: Lowering a Model as a Delegate
+   :card_description: Learn to accelerate your program using ExecuTorch by applying delegates through three methods: lowering the whole module, composing it with another module, and partitioning parts of a module.
+   :image: _static/img/ExecuTorch-Logo-cropped.svg
+   :link: https://pytorch.org/executorch/stable/examples-end-to-end-to-lower-model-to-delegate.html
+   :tags: Edge
+
+
+.. Recommendation Systems
+
+.. customcarditem::
+   :header: Introduction to TorchRec
+   :card_description: TorchRec is a PyTorch domain library built to provide common sparsity & parallelism primitives needed for large-scale recommender systems.
+   :image: _static/img/thumbnails/torchrec.png
+   :link: intermediate/torchrec_intro_tutorial.html
+   :tags: TorchRec,Recommender
+
+.. customcarditem::
+   :header: Exploring TorchRec sharding
+   :card_description: This tutorial covers the sharding schemes of embedding tables by using <code>EmbeddingPlanner</code> and <code>DistributedModelParallel</code> API.
+   :image: _static/img/thumbnails/torchrec.png
+   :link: advanced/sharding.html
+   :tags: TorchRec,Recommender
+
+
+.. End of tutorial card section
 
 .. raw:: html
 
-    <div style='clear:both'></div>
-
-
-Reinforcement Learning
-----------------------
+    </div>
 
-.. customgalleryitem::
-    :tooltip: Use PyTorch to train a Deep Q Learning (DQN) agent
-    :figure: /_static/img/cartpole.gif
-    :description: :doc:`intermediate/reinforcement_q_learning`
+    <div class="pagination d-flex justify-content-center"></div>
 
-.. raw:: html
-
-    <div style='clear:both'></div>
+    </div>
 
-Extending PyTorch
-----------------------
+    </div>
+    <br>
+    <br>
 
-.. customgalleryitem::
-    :tooltip: Create extensions using numpy and scipy
-    :figure: /_static/img/scipynumpy.png
-    :description: :doc:`advanced/numpy_extensions_tutorial`
-
-.. customgalleryitem::
-   :tooltip: Implement custom extensions in C++ or CUDA for eager PyTorch
-   :description: :doc:`/advanced/cpp_extension`
-   :figure: _static/img/cpp_logo.png
-
-.. customgalleryitem::
-   :tooltip: Implement custom operators in C++ or CUDA for TorchScript
-   :description: :doc:`/advanced/torch_script_custom_ops`
-   :figure: _static/img/cpp_logo.png
 
+Additional Resources
+============================
 
 .. raw:: html
 
-    <div style='clear:both'></div>
-
-
-Production Usage
-----------------------
-
-.. customgalleryitem::
-   :tooltip: Loading a PyTorch model in C++
-   :description: :doc:`advanced/cpp_export`
-   :figure: _static/img/cpp_logo.png
+    <div class="tutorials-callout-container">
+        <div class="row">
 
-.. customgalleryitem::
-   :tooltip: Convert a neural style transfer model that has been exported from PyTorch into the Apple CoreML format using ONNX
-   :description: :doc:`advanced/ONNXLive`
-   :figure: _static/img/ONNXLive.png
+.. Add callout items below this line
 
+.. customcalloutitem::
+   :header: Examples of PyTorch
+   :description: A set of examples around PyTorch in Vision, Text, Reinforcement Learning that you can incorporate in your existing work.
+   :button_link: https://pytorch.org/examples?utm_source=examples&utm_medium=examples-landing
+   :button_text: Check Out Examples
 
-.. customgalleryitem::
-   :tooltip: Parallelize computations across processes and clusters of machines
-   :description: :doc:`/intermediate/dist_tuto`
-   :figure: _static/img/distributed/DistPyTorch.jpg
-
-.. customgalleryitem::
-  :tooltip: Train large models with multiple GPUs using model parallel
-  :description: :doc:`/intermediate/model_parallel_tutorial`
-  :figure: _static/img/distributed/DistPyTorch.jpg
-
-.. customgalleryitem::
-  :tooltip: Getting started with DistributedDataParallel
-  :description: :doc:`/intermediate/ddp_tutorial`
-  :figure: _static/img/distributed/DistPyTorch.jpg
-
-.. customgalleryitem::
-   :tooltip: PyTorch distributed trainer with Amazon AWS
-   :description: :doc:`/beginner/aws_distributed_training_tutorial`
-   :figure: _static/img/distributed/DistPyTorch.jpg
+.. customcalloutitem::
+   :header: Run Tutorials on Google Colab
+   :description: Learn how to copy tutorial data into Google Drive so that you can run tutorials on Google Colab.
+   :button_link: beginner/colab.html
+   :button_text: Open
 
+.. End of callout section
 
 .. raw:: html
 
-    <div style='clear:both'></div>
-
-
-PyTorch in Other Languages
--------------
-
-.. customgalleryitem::
-    :tooltip: Using the PyTorch C++ Frontend
-    :figure: /_static/img/cpp-pytorch.png
-    :description: :doc:`advanced/cpp_frontend`
-
-.. raw:: html
+        </div>
+    </div>
 
     <div style='clear:both'></div>
 
@@ -253,93 +786,56 @@ PyTorch in Other Languages
 .. Page TOC
 .. -----------------------------------------
 .. toctree::
-   :maxdepth: 2
+   :glob:
+   :maxdepth: 1
    :hidden:
-   :includehidden:
-   :caption: Getting Started
 
-   beginner/deep_learning_60min_blitz
-   beginner/data_loading_tutorial
-   beginner/pytorch_with_examples
-   beginner/transfer_learning_tutorial
-   beginner/deploy_seq2seq_hybrid_frontend_tutorial
-   beginner/saving_loading_models
-   beginner/nn_tutorial
+   intro
 
 .. toctree::
-   :maxdepth: 2
-   :includehidden:
+   :maxdepth: 1
    :hidden:
-   :caption: Image
 
-   intermediate/torchvision_tutorial
-   beginner/finetuning_torchvision_models_tutorial
-   intermediate/spatial_transformer_tutorial
-   advanced/neural_style_tutorial
-   beginner/fgsm_tutorial
-   advanced/super_resolution_with_caffe2
+   compilers_index
 
 .. toctree::
    :maxdepth: 2
-   :includehidden:
    :hidden:
-   :caption: Audio
 
-.. toctree::
-   :maxdepth: 2
-   :includehidden:
+   domains
+
+.. toctree:: 1
    :hidden:
-   :caption: Text
+   :maxdepth: 2
 
-   beginner/chatbot_tutorial
-   intermediate/char_rnn_generation_tutorial
-   intermediate/char_rnn_classification_tutorial
-   beginner/deep_learning_nlp_tutorial
-   intermediate/seq2seq_translation_tutorial
+   distributed
 
 .. toctree::
-   :maxdepth: 2
-   :includehidden:
+   :maxdepth: 1
    :hidden:
-   :caption: Generative
 
-   beginner/dcgan_faces_tutorial
+   deep-dive
 
 .. toctree::
-   :maxdepth: 2
-   :includehidden:
+   :maxdepth: 1
    :hidden:
-   :caption: Reinforcement Learning
 
-   intermediate/reinforcement_q_learning
+   extension
 
 .. toctree::
-   :maxdepth: 2
-   :includehidden:
+   :maxdepth: 1
    :hidden:
-   :caption: Extending PyTorch
 
-   advanced/numpy_extensions_tutorial
-   advanced/cpp_extension
-   advanced/torch_script_custom_ops
+   ecosystem
 
 .. toctree::
-   :maxdepth: 2
-   :includehidden:
+   :maxdepth: 1
    :hidden:
-   :caption: Production Usage
 
-   intermediate/model_parallel_tutorial
-   intermediate/ddp_tutorial
-   intermediate/dist_tuto
-   beginner/aws_distributed_training_tutorial
-   advanced/ONNXLive
-   advanced/cpp_export
+   recipes_index
 
 .. toctree::
-   :maxdepth: 2
-   :includehidden:
+   :maxdepth: 1
    :hidden:
-   :caption: PyTorch in Other Languages
 
-   advanced/cpp_frontend
+   prototype/prototype_index
diff --git a/intermediate_source/FSDP1_tutorial.rst b/intermediate_source/FSDP1_tutorial.rst
new file mode 100644
index 00000000000..b983879a449
--- /dev/null
+++ b/intermediate_source/FSDP1_tutorial.rst
@@ -0,0 +1,448 @@
+Getting Started with Fully Sharded Data Parallel(FSDP)
+======================================================
+
+**Author**: `Hamid Shojanazeri <https://github.com/HamidShojanazeri>`__, `Yanli Zhao <https://github.com/zhaojuanmao>`__, `Shen Li <https://mrshenli.github.io/>`__
+
+.. note::
+   FSDP1 is deprecated. Please check out `FSDP2 tutorial <https://docs.pytorch.org/tutorials/intermediate/FSDP_tutorial.html>`_.
+
+Training AI models at a large scale is a challenging task that requires a lot of compute power and resources.
+It also comes with considerable engineering complexity to handle the training of these very large models.
+`PyTorch FSDP <https://pytorch.org/blog/introducing-pytorch-fully-sharded-data-parallel-api/>`__, released in PyTorch 1.11 makes this easier.
+
+In this tutorial, we show how to use `FSDP APIs <https://pytorch.org/docs/stable/fsdp.html>`__, for simple MNIST models that can be extended to other larger models such as `HuggingFace BERT models <https://huggingface.co/blog/zero-deepspeed-fairscale>`__,
+`GPT 3 models up to 1T parameters <https://pytorch.medium.com/training-a-1-trillion-parameter-model-with-pytorch-fully-sharded-data-parallel-on-aws-3ac13aa96cff>`__ . The sample DDP MNIST code courtesy of `Patrick Hu <https://github.com/yqhu/>`_.
+
+
+How FSDP works
+--------------
+In `DistributedDataParallel <https://pytorch.org/docs/stable/generated/torch.nn.parallel.DistributedDataParallel.html>`__, (DDP) training, each process/ worker owns a replica of the model and processes a batch of data, finally it uses all-reduce to sum up gradients over different workers. In DDP the model weights and optimizer states are replicated across all workers. FSDP is a type of data parallelism that shards model parameters, optimizer states and gradients across DDP ranks.
+
+When training with FSDP, the GPU memory footprint is smaller than when training with DDP across all workers. This makes the training of some very large models feasible by allowing larger models or batch sizes to fit on device. This comes with the cost of increased communication volume. The communication overhead is reduced by internal optimizations like overlapping communication and computation.
+
+.. figure:: /_static/img/distributed/fsdp_workflow.png
+   :width: 100%
+   :align: center
+   :alt: FSDP workflow
+
+   FSDP Workflow
+
+At a high level FSDP works as follow:
+
+*In constructor*
+
+* Shard model parameters and each rank only keeps its own shard
+
+*In forward path*
+
+* Run all_gather to collect all shards from all ranks to recover the full parameter in this FSDP unit
+* Run forward computation
+* Discard parameter shards it has just collected
+
+*In backward path*
+
+* Run all_gather to collect all shards from all ranks to recover the full parameter in this FSDP unit
+* Run backward computation
+* Run reduce_scatter to sync gradients
+* Discard parameters.
+
+One way to view FSDP's sharding is to decompose the DDP gradient all-reduce into reduce-scatter and all-gather. Specifically, during the backward pass, FSDP reduces and scatters gradients, ensuring that each rank possesses a shard of the gradients. Then it updates the corresponding shard of the parameters in the optimizer step. Finally, in the subsequent forward pass, it performs an all-gather operation to collect and combine the updated parameter shards.
+
+.. figure:: /_static/img/distributed/fsdp_sharding.png
+   :width: 100%
+   :align: center
+   :alt: FSDP allreduce
+
+   FSDP Allreduce
+
+How to use FSDP
+---------------
+Here we use a toy model to run training on the MNIST dataset for demonstration purposes. The APIs and logic can be applied to training larger models as well.
+
+*Setup*
+
+1.1 Install PyTorch along with Torchvision
+
+See the `Get Started guide <https://pytorch.org/get-started/locally/>`__ for information on installation.
+
+We add the following code snippets to a python script “FSDP_mnist.py”.
+
+1.2  Import necessary packages
+
+.. note::
+    This tutorial is intended for PyTorch versions 1.12 and later. If you are using an earlier version, replace all instances of `size_based_auto_wrap_policy` with `default_auto_wrap_policy` and `fsdp_auto_wrap_policy` with `auto_wrap_policy`.
+
+.. code-block:: python
+
+    # Based on: https://github.com/pytorch/examples/blob/master/mnist/main.py
+    import os
+    import argparse
+    import functools
+    import torch
+    import torch.nn as nn
+    import torch.nn.functional as F
+    import torch.optim as optim
+    from torchvision import datasets, transforms
+
+
+    from torch.optim.lr_scheduler import StepLR
+
+    import torch.distributed as dist
+    import torch.multiprocessing as mp
+    from torch.nn.parallel import DistributedDataParallel as DDP
+    from torch.utils.data.distributed import DistributedSampler
+    from torch.distributed.fsdp import FullyShardedDataParallel as FSDP
+    from torch.distributed.fsdp.fully_sharded_data_parallel import (
+        CPUOffload,
+        BackwardPrefetch,
+    )
+    from torch.distributed.fsdp.wrap import (
+        size_based_auto_wrap_policy,
+        enable_wrap,
+        wrap,
+    )
+
+1.3 Distributed training setup. As we mentioned FSDP is a type of data parallelism which requires a distributed training environment, so here we use two helper functions to initialize the processes for distributed training and clean up.
+
+.. code-block:: python
+
+    def setup(rank, world_size):
+        os.environ['MASTER_ADDR'] = 'localhost'
+        os.environ['MASTER_PORT'] = '12355'
+
+        # initialize the process group
+        dist.init_process_group("nccl", rank=rank, world_size=world_size)
+
+    def cleanup():
+        dist.destroy_process_group()
+
+2.1  Define our toy model for handwritten digit classification.
+
+.. code-block:: python
+
+    class Net(nn.Module):
+        def __init__(self):
+            super(Net, self).__init__()
+            self.conv1 = nn.Conv2d(1, 32, 3, 1)
+            self.conv2 = nn.Conv2d(32, 64, 3, 1)
+            self.dropout1 = nn.Dropout(0.25)
+            self.dropout2 = nn.Dropout(0.5)
+            self.fc1 = nn.Linear(9216, 128)
+            self.fc2 = nn.Linear(128, 10)
+
+        def forward(self, x):
+
+            x = self.conv1(x)
+            x = F.relu(x)
+            x = self.conv2(x)
+            x = F.relu(x)
+            x = F.max_pool2d(x, 2)
+            x = self.dropout1(x)
+            x = torch.flatten(x, 1)
+            x = self.fc1(x)
+            x = F.relu(x)
+            x = self.dropout2(x)
+            x = self.fc2(x)
+            output = F.log_softmax(x, dim=1)
+            return output
+
+2.2 Define a train function
+
+.. code-block:: python
+
+    def train(args, model, rank, world_size, train_loader, optimizer, epoch, sampler=None):
+        model.train()
+        ddp_loss = torch.zeros(2).to(rank)
+        if sampler:
+            sampler.set_epoch(epoch)
+        for batch_idx, (data, target) in enumerate(train_loader):
+            data, target = data.to(rank), target.to(rank)
+            optimizer.zero_grad()
+            output = model(data)
+            loss = F.nll_loss(output, target, reduction='sum')
+            loss.backward()
+            optimizer.step()
+            ddp_loss[0] += loss.item()
+            ddp_loss[1] += len(data)
+
+        dist.all_reduce(ddp_loss, op=dist.ReduceOp.SUM)
+        if rank == 0:
+            print('Train Epoch: {} \tLoss: {:.6f}'.format(epoch, ddp_loss[0] / ddp_loss[1]))
+
+2.3 Define a validation function
+
+.. code-block:: python
+
+    def test(model, rank, world_size, test_loader):
+        model.eval()
+        correct = 0
+        ddp_loss = torch.zeros(3).to(rank)
+        with torch.no_grad():
+            for data, target in test_loader:
+                data, target = data.to(rank), target.to(rank)
+                output = model(data)
+                ddp_loss[0] += F.nll_loss(output, target, reduction='sum').item()  # sum up batch loss
+                pred = output.argmax(dim=1, keepdim=True)  # get the index of the max log-probability
+                ddp_loss[1] += pred.eq(target.view_as(pred)).sum().item()
+                ddp_loss[2] += len(data)
+
+        dist.all_reduce(ddp_loss, op=dist.ReduceOp.SUM)
+
+        if rank == 0:
+            test_loss = ddp_loss[0] / ddp_loss[2]
+            print('Test set: Average loss: {:.4f}, Accuracy: {}/{} ({:.2f}%)\n'.format(
+                test_loss, int(ddp_loss[1]), int(ddp_loss[2]),
+                100. * ddp_loss[1] / ddp_loss[2]))
+
+2.4 Define a distributed train function that wraps the model in FSDP
+
+**Note: to save the FSDP model, we need to call the state_dict on each rank then on Rank 0 save the overall states.**
+
+.. code-block:: python
+
+    def fsdp_main(rank, world_size, args):
+        setup(rank, world_size)
+
+        transform=transforms.Compose([
+            transforms.ToTensor(),
+            transforms.Normalize((0.1307,), (0.3081,))
+        ])
+
+        dataset1 = datasets.MNIST('../data', train=True, download=True,
+                            transform=transform)
+        dataset2 = datasets.MNIST('../data', train=False,
+                            transform=transform)
+
+        sampler1 = DistributedSampler(dataset1, rank=rank, num_replicas=world_size, shuffle=True)
+        sampler2 = DistributedSampler(dataset2, rank=rank, num_replicas=world_size)
+
+        train_kwargs = {'batch_size': args.batch_size, 'sampler': sampler1}
+        test_kwargs = {'batch_size': args.test_batch_size, 'sampler': sampler2}
+        cuda_kwargs = {'num_workers': 2,
+                        'pin_memory': True,
+                        'shuffle': False}
+        train_kwargs.update(cuda_kwargs)
+        test_kwargs.update(cuda_kwargs)
+
+        train_loader = torch.utils.data.DataLoader(dataset1,**train_kwargs)
+        test_loader = torch.utils.data.DataLoader(dataset2, **test_kwargs)
+        my_auto_wrap_policy = functools.partial(
+            size_based_auto_wrap_policy, min_num_params=100
+        )
+        torch.cuda.set_device(rank)
+
+
+        init_start_event = torch.cuda.Event(enable_timing=True)
+        init_end_event = torch.cuda.Event(enable_timing=True)
+
+        model = Net().to(rank)
+
+        model = FSDP(model)
+
+        optimizer = optim.Adadelta(model.parameters(), lr=args.lr)
+
+        scheduler = StepLR(optimizer, step_size=1, gamma=args.gamma)
+        init_start_event.record()
+        for epoch in range(1, args.epochs + 1):
+            train(args, model, rank, world_size, train_loader, optimizer, epoch, sampler=sampler1)
+            test(model, rank, world_size, test_loader)
+            scheduler.step()
+
+        init_end_event.record()
+
+        if rank == 0:
+            init_end_event.synchronize()
+            print(f"CUDA event elapsed time: {init_start_event.elapsed_time(init_end_event) / 1000}sec")
+            print(f"{model}")
+
+        if args.save_model:
+            # use a barrier to make sure training is done on all ranks
+            dist.barrier()
+            states = model.state_dict()
+            if rank == 0:
+                torch.save(states, "mnist_cnn.pt")
+
+        cleanup()
+
+
+
+2.5 Finally, parse the arguments and set the main function
+
+.. code-block:: python
+
+    if __name__ == '__main__':
+        # Training settings
+        parser = argparse.ArgumentParser(description='PyTorch MNIST Example')
+        parser.add_argument('--batch-size', type=int, default=64, metavar='N',
+                            help='input batch size for training (default: 64)')
+        parser.add_argument('--test-batch-size', type=int, default=1000, metavar='N',
+                            help='input batch size for testing (default: 1000)')
+        parser.add_argument('--epochs', type=int, default=10, metavar='N',
+                            help='number of epochs to train (default: 14)')
+        parser.add_argument('--lr', type=float, default=1.0, metavar='LR',
+                            help='learning rate (default: 1.0)')
+        parser.add_argument('--gamma', type=float, default=0.7, metavar='M',
+                            help='Learning rate step gamma (default: 0.7)')
+        parser.add_argument('--no-cuda', action='store_true', default=False,
+                            help='disables CUDA training')
+        parser.add_argument('--seed', type=int, default=1, metavar='S',
+                            help='random seed (default: 1)')
+        parser.add_argument('--save-model', action='store_true', default=False,
+                            help='For Saving the current Model')
+        args = parser.parse_args()
+
+        torch.manual_seed(args.seed)
+
+        WORLD_SIZE = torch.cuda.device_count()
+        mp.spawn(fsdp_main,
+            args=(WORLD_SIZE, args),
+            nprocs=WORLD_SIZE,
+            join=True)
+
+
+We have recorded cuda events to measure the time of FSDP model specifics. The CUDA event time was 110.85 seconds.
+
+.. code-block:: bash
+
+    python FSDP_mnist.py
+
+    CUDA event elapsed time on training loop 40.67462890625sec
+
+Wrapping the model with FSDP, the model will look as follows, we can see the model has been wrapped in one FSDP unit.
+Alternatively, we will look at adding the auto_wrap_policy next and will discuss the differences.
+
+.. code-block:: bash
+
+    FullyShardedDataParallel(
+    (_fsdp_wrapped_module): FlattenParamsWrapper(
+        (_fpw_module): Net(
+        (conv1): Conv2d(1, 32, kernel_size=(3, 3), stride=(1, 1))
+        (conv2): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1))
+        (dropout1): Dropout(p=0.25, inplace=False)
+        (dropout2): Dropout(p=0.5, inplace=False)
+        (fc1): Linear(in_features=9216, out_features=128, bias=True)
+        (fc2): Linear(in_features=128, out_features=10, bias=True)
+        )
+    )
+ )
+
+The following is the peak memory usage from FSDP MNIST training on g4dn.12.xlarge AWS EC2 instance with 4 GPUs captured from PyTorch Profiler.
+
+
+.. figure:: /_static/img/distributed/FSDP_memory.gif
+   :width: 100%
+   :align: center
+   :alt: FSDP peak memory
+
+   FSDP Peak Memory Usage
+
+Applying *auto_wrap_policy* in FSDP otherwise, FSDP will put the entire model in one FSDP unit, which will reduce computation efficiency and memory efficiency.
+The way it works is that, suppose your model contains 100 Linear layers. If you do FSDP(model), there will only be one FSDP unit which wraps the entire model.
+In that case, the allgather would collect the full parameters for all 100 linear layers, and hence won't save CUDA memory for parameter sharding.
+Also, there is only one blocking allgather call for the all 100 linear layers, there will not be communication and computation overlapping between layers.
+
+To avoid that, you can pass in an auto_wrap_policy, which will seal the current FSDP unit and start a new one automatically when the specified condition is met (e.g., size limit).
+In that way you will have multiple FSDP units, and only one FSDP unit needs to collect full parameters at a time. E.g., suppose you have 5 FSDP units, and each wraps 20 linear layers.
+Then, in the forward, the 1st FSDP unit will allgather parameters for the first 20 linear layers, do computation, discard the parameters and then move on to the next 20 linear layers. So, at any point in time, each rank only materializes parameters/grads for 20 linear layers instead of 100.
+
+
+To do so in 2.4 we define the auto_wrap_policy and pass it to FSDP wrapper, in the following example, my_auto_wrap_policy defines that a layer could be wrapped or sharded by FSDP if the number of parameters in this layer is larger than 100.
+If the number of parameters in this layer is smaller than 100, it will be wrapped with other small layers together by FSDP.
+Finding an optimal auto wrap policy is challenging, PyTorch will add auto tuning for this config in the future. Without an auto tuning tool, it is good to profile your workflow using different auto wrap policies experimentally and find the optimal one.
+
+.. code-block:: python
+
+    my_auto_wrap_policy = functools.partial(
+            size_based_auto_wrap_policy, min_num_params=20000
+        )
+    torch.cuda.set_device(rank)
+    model = Net().to(rank)
+
+    model = FSDP(model,
+        auto_wrap_policy=my_auto_wrap_policy)
+
+Applying the auto_wrap_policy, the model would be as follows:
+
+.. code-block:: bash
+
+    FullyShardedDataParallel(
+  (_fsdp_wrapped_module): FlattenParamsWrapper(
+    (_fpw_module): Net(
+      (conv1): Conv2d(1, 32, kernel_size=(3, 3), stride=(1, 1))
+      (conv2): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1))
+      (dropout1): Dropout(p=0.25, inplace=False)
+      (dropout2): Dropout(p=0.5, inplace=False)
+      (fc1): FullyShardedDataParallel(
+        (_fsdp_wrapped_module): FlattenParamsWrapper(
+          (_fpw_module): Linear(in_features=9216, out_features=128, bias=True)
+        )
+      )
+      (fc2): Linear(in_features=128, out_features=10, bias=True)
+    )
+  )
+
+
+.. code-block:: bash
+
+    python FSDP_mnist.py
+
+    CUDA event elapsed time on training loop 41.89130859375sec
+
+The following is the peak memory usage from FSDP with auto_wrap policy of MNIST training on a g4dn.12.xlarge AWS EC2 instance with 4 GPUs captured from PyTorch Profiler.
+It can be observed that the peak memory usage on each device is smaller compared to FSDP without auto wrap policy applied, from ~75 MB to 66 MB.
+
+.. figure:: /_static/img/distributed/FSDP_autowrap.gif
+   :width: 100%
+   :align: center
+   :alt: FSDP peak memory
+
+   FSDP Peak Memory Usage using Auto_wrap policy
+
+*CPU Off-loading*: In case the model is very large that even with FSDP wouldn't fit into GPUs, then CPU offload can be helpful here.
+
+Currently, only parameter and gradient CPU offload is supported. It can be enabled via passing in cpu_offload=CPUOffload(offload_params=True).
+
+Note that this currently implicitly enables gradient offloading to CPU in order for params and grads to be on the same device to work with the optimizer. This API is subject to change. The default is None in which case there will be no offloading.
+
+Using this feature may slow down the training considerably, due to frequent copying of tensors from host to device, but it could help improve memory efficiency and train larger scale models.
+
+In 2.4 we just add it to the FSDP wrapper
+
+
+.. code-block:: python
+
+    model = FSDP(model,
+        auto_wrap_policy=my_auto_wrap_policy,
+        cpu_offload=CPUOffload(offload_params=True))
+
+
+Compare it with DDP, if in 2.4 we just normally wrap the model in DPP, saving the changes in “DDP_mnist.py”.
+
+.. code-block:: python
+
+    model = Net().to(rank)
+    model = DDP(model)
+
+
+.. code-block:: bash
+
+    python DDP_mnist.py
+
+    CUDA event elapsed time on training loop 39.77766015625sec
+
+The following is the peak memory usage from DDP MNIST training on g4dn.12.xlarge AWS EC2 instance with 4 GPUs captured from PyTorch profiler.
+
+.. figure:: /_static/img/distributed/DDP_memory.gif
+   :width: 100%
+   :align: center
+   :alt: FSDP peak memory
+
+   DDP Peak Memory Usage using Auto_wrap policy
+
+
+Considering the toy example and tiny MNIST model we defined here, we can observe the difference between peak memory usage of DDP and FSDP.
+In DDP each process holds a replica of the model, so the memory footprint is higher compared to FSDP which shards the model parameters, optimizer states and gradients over DDP ranks.
+The peak memory usage using FSDP with auto_wrap policy is the lowest followed by FSDP and DDP.
+
+Also, looking at timings, considering the small model and running the training on a single machine, FSDP with and without auto_wrap policy performed almost as fast as DDP.
+This example does not represent most of the real applications, for detailed analysis and comparison between DDP and FSDP please refer to this `blog post  <https://pytorch.medium.com/6c8da2be180d>`__ .
diff --git a/intermediate_source/FSDP_advanced_tutorial.rst b/intermediate_source/FSDP_advanced_tutorial.rst
new file mode 100644
index 00000000000..bf22e6efb50
--- /dev/null
+++ b/intermediate_source/FSDP_advanced_tutorial.rst
@@ -0,0 +1,719 @@
+Advanced Model Training with Fully Sharded Data Parallel (FSDP)
+===============================================================
+
+**Author**: `Hamid Shojanazeri <https://github.com/HamidShojanazeri>`__, `Less
+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
+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.
+
+The example uses Wikihow and for simplicity, we will showcase the training on a
+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.
+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
+<https://pytorch.org/blog/introducing-pytorch-fully-sharded-data-parallel-api/>`__.
+
+
+FSDP Features in This Tutorial
+------------------------------
+* Transformer Auto Wrap Policy
+* Mixed Precision
+* Initializing FSDP Model on Device
+* Sharding Strategy
+* Backward Prefetch
+* Model Checkpoint Saving via Streaming to CPU
+
+
+
+Recap on How FSDP Works
+-----------------------
+
+At a high level FDSP works as follow:
+
+*In the constructor*
+
+* Shard model parameters and each rank only keeps its own shard
+
+*In the forward pass*
+
+* Run `all_gather` to collect all shards from all ranks to recover the full
+  parameter for this FSDP unit and run the forward computation
+* Discard the non-owned parameter shards it has just collected to free memory
+
+*In the backward pass*
+
+* Run `all_gather` to collect all shards from all ranks to recover the full
+  parameter in this FSDP unit and run backward computation
+* Discard non-owned parameters to free memory.
+* Run reduce_scatter to sync gradients
+
+
+Fine-tuning HF T5
+-----------------
+HF T5 pre-trained models are available in four different sizes, ranging from
+small with 60 Million parameters to XXL with 11 Billion parameters. In this
+tutorial, we demonstrate the fine-tuning of a T5 3B with FSDP for text
+summarization using WikiHow dataset.  The main focus of this tutorial is to
+highlight different available features in FSDP that are helpful for training
+large scale model above 3B parameters. Also, we cover specific features for
+Transformer based models. The code for this tutorial is available in  `Pytorch
+examples
+<https://github.com/pytorch/examples/tree/main/distributed/FSDP/>`__.
+
+
+*Setup*
+
+1.1 Install the latest PyTorch
+
+.. code-block:: bash
+
+    pip3 install torch torchvision torchaudio
+
+1.2 Dataset Setup
+
+Please create a `data` folder, download the WikiHow dataset from `wikihowAll.csv
+<https://ucsb.app.box.com/s/ap23l8gafpezf4tq3wapr6u8241zz358>`__  and
+`wikihowSep.cs <https://ucsb.app.box.com/s/7yq601ijl1lzvlfu4rjdbbxforzd2oag>`__,
+and place them in the `data` folder.  We will use the wikihow dataset from
+`summarization_dataset
+<https://github.com/pytorch/examples/blob/main/distributed/FSDP/summarization_dataset.py>`__.
+
+Next, we add the following code snippets to a Python script “T5_training.py”.
+
+.. note::
+   The full source code for this tutorial is available in `PyTorch examples
+   <https://github.com/pytorch/examples/tree/main/distributed/FSDP/>`__.
+
+1.3  Import necessary packages:
+
+.. code-block:: python
+
+    import os
+    import argparse
+    import torch
+    import torch.nn as nn
+    import torch.nn.functional as F
+    import torch.optim as optim
+    from transformers import AutoTokenizer, GPT2TokenizerFast
+    from transformers import T5Tokenizer, T5ForConditionalGeneration
+    import functools
+    from torch.optim.lr_scheduler import StepLR
+    import torch.nn.functional as F
+    import torch.distributed as dist
+    import torch.multiprocessing as mp
+    from torch.nn.parallel import DistributedDataParallel as DDP
+    from torch.utils.data.distributed import DistributedSampler
+    from transformers.models.t5.modeling_t5 import T5Block
+
+    from torch.distributed.algorithms._checkpoint.checkpoint_wrapper import (
+     checkpoint_wrapper,
+     CheckpointImpl,
+     apply_activation_checkpointing_wrapper)
+
+    from torch.distributed.fsdp import (
+        FullyShardedDataParallel as FSDP,
+        MixedPrecision,
+        BackwardPrefetch,
+        ShardingStrategy,
+        FullStateDictConfig,
+        StateDictType,
+    )
+    from torch.distributed.fsdp.wrap import (
+        transformer_auto_wrap_policy,
+        enable_wrap,
+        wrap,
+    )
+    from functools import partial
+    from torch.utils.data import DataLoader
+    from pathlib import Path
+    from summarization_dataset import *
+    from transformers.models.t5.modeling_t5 import T5Block
+    from typing import Type
+    import time
+    import tqdm
+    from datetime import datetime
+
+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
+<https://pytorch.org/docs/stable/elastic/run.html>`__ , which will set the
+worker `RANK` and `WORLD_SIZE` automatically.
+
+.. code-block:: python
+
+    def setup():
+        # initialize the process group
+        dist.init_process_group("nccl")
+
+    def cleanup():
+        dist.destroy_process_group()
+
+2.1  Set up the HuggingFace T5 model:
+
+.. code-block:: python
+
+    def setup_model(model_name):
+        model = T5ForConditionalGeneration.from_pretrained(model_name)
+        tokenizer =  T5Tokenizer.from_pretrained(model_name)
+        return model, tokenizer
+
+We also, add couple of helper functions here for date and formatting memory
+metrics.
+
+.. code-block:: python
+
+    def get_date_of_run():
+        """create date and time for file save uniqueness
+        example: 2022-05-07-08:31:12_PM'
+        """
+        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:
+
+.. code-block:: python
+
+    def train(args, model, rank, world_size, train_loader, optimizer, epoch, sampler=None):
+        model.train()
+        local_rank = int(os.environ['LOCAL_RANK'])
+        fsdp_loss = torch.zeros(2).to(local_rank)
+
+        if sampler:
+            sampler.set_epoch(epoch)
+        if rank==0:
+            inner_pbar = tqdm.tqdm(
+                range(len(train_loader)), colour="blue", desc="r0 Training Epoch"
+            )
+        for batch in train_loader:
+            for key in batch.keys():
+                batch[key] = batch[key].to(local_rank)
+            optimizer.zero_grad()
+            output = model(input_ids=batch["source_ids"],attention_mask=batch["source_mask"],labels=batch["target_ids"] )
+            loss = output["loss"]
+            loss.backward()
+            optimizer.step()
+            fsdp_loss[0] += loss.item()
+            fsdp_loss[1] += len(batch)
+            if rank==0:
+                inner_pbar.update(1)
+
+        dist.all_reduce(fsdp_loss, op=dist.ReduceOp.SUM)
+        train_accuracy = fsdp_loss[0] / fsdp_loss[1]
+
+
+        if rank == 0:
+            inner_pbar.close()
+            print(
+                    f"Train Epoch: \t{epoch}, Loss: \t{train_accuracy:.4f}"
+                )
+        return train_accuracy
+
+2.3 Define a validation function:
+
+.. code-block:: python
+
+    def validation(model, rank, world_size, val_loader):
+        model.eval()
+        correct = 0
+        local_rank = int(os.environ['LOCAL_RANK'])
+        fsdp_loss = torch.zeros(3).to(local_rank)
+        if rank == 0:
+            inner_pbar = tqdm.tqdm(
+                range(len(val_loader)), colour="green", desc="Validation Epoch"
+            )
+        with torch.no_grad():
+            for batch in val_loader:
+                for key in batch.keys():
+                    batch[key] = batch[key].to(local_rank)
+                output = model(input_ids=batch["source_ids"],attention_mask=batch["source_mask"],labels=batch["target_ids"])
+                fsdp_loss[0] += output["loss"].item()  # sum up batch loss
+                fsdp_loss[1] += len(batch)
+
+                if rank==0:
+                    inner_pbar.update(1)
+
+        dist.all_reduce(fsdp_loss, op=dist.ReduceOp.SUM)
+        val_loss = fsdp_loss[0] / fsdp_loss[1]
+        if rank == 0:
+            inner_pbar.close()
+            print(f"Validation Loss: {val_loss:.4f}")
+        return val_loss
+
+
+2.4 Define a distributed train function that wraps the model in FSDP:
+
+
+.. code-block:: python
+
+
+    def fsdp_main(args):
+
+        model, tokenizer = setup_model("t5-base")
+
+        local_rank = int(os.environ['LOCAL_RANK'])
+        rank = int(os.environ['RANK'])
+        world_size = int(os.environ['WORLD_SIZE'])
+
+
+        dataset = load_dataset('wikihow', 'all', data_dir='data/')
+        print(dataset.keys())
+        print("Size of train dataset: ", dataset['train'].shape)
+        print("Size of Validation dataset: ", dataset['validation'].shape)
+
+
+        #wikihow(tokenizer, type_path, num_samples, input_length, output_length, print_text=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)
+        sampler2 = DistributedSampler(val_dataset, rank=rank, num_replicas=world_size)
+
+        setup()
+
+
+        train_kwargs = {'batch_size': args.batch_size, 'sampler': sampler1}
+        test_kwargs = {'batch_size': args.test_batch_size, 'sampler': sampler2}
+        cuda_kwargs = {'num_workers': 2,
+                        'pin_memory': True,
+                        'shuffle': False}
+        train_kwargs.update(cuda_kwargs)
+        test_kwargs.update(cuda_kwargs)
+
+        train_loader = torch.utils.data.DataLoader(train_dataset,**train_kwargs)
+        val_loader = torch.utils.data.DataLoader(val_dataset, **test_kwargs)
+
+        t5_auto_wrap_policy = functools.partial(
+            transformer_auto_wrap_policy,
+            transformer_layer_cls={
+                T5Block,
+            },
+        )
+        sharding_strategy: ShardingStrategy = ShardingStrategy.SHARD_GRAD_OP #for Zero2 and FULL_SHARD for Zero3
+        torch.cuda.set_device(local_rank)
+
+
+        #init_start_event = torch.cuda.Event(enable_timing=True)
+        #init_end_event = torch.cuda.Event(enable_timing=True)
+
+        #init_start_event.record()
+
+        bf16_ready = (
+        torch.version.cuda
+        and torch.cuda.is_bf16_supported()
+        and LooseVersion(torch.version.cuda) >= "11.0"
+        and dist.is_nccl_available()
+        and nccl.version() >= (2, 10)
+        )
+
+        if bf16_ready:
+            mp_policy = bfSixteen
+        else:
+            mp_policy = None # defaults to fp32
+
+        # model is on CPU before input to FSDP
+        model = FSDP(model,
+            auto_wrap_policy=t5_auto_wrap_policy,
+            mixed_precision=mp_policy,
+            #sharding_strategy=sharding_strategy,
+            device_id=torch.cuda.current_device())
+
+        optimizer = optim.AdamW(model.parameters(), lr=args.lr)
+
+        scheduler = StepLR(optimizer, step_size=1, gamma=args.gamma)
+        best_val_loss = float("inf")
+        curr_val_loss = float("inf")
+        file_save_name = "T5-model-"
+
+        if rank == 0:
+            time_of_run = get_date_of_run()
+            dur = []
+            train_acc_tracking = []
+            val_acc_tracking = []
+            training_start_time = time.time()
+
+        if rank == 0 and args.track_memory:
+            mem_alloc_tracker = []
+            mem_reserved_tracker = []
+
+        for epoch in range(1, args.epochs + 1):
+            t0 = time.time()
+            train_accuracy = train(args, model, rank, world_size, train_loader, optimizer, epoch, sampler=sampler1)
+            if args.run_validation:
+                curr_val_loss = validation(model, rank, world_size, val_loader)
+            scheduler.step()
+
+            if rank == 0:
+
+                print(f"--> epoch {epoch} completed...entering save and stats zone")
+
+                dur.append(time.time() - t0)
+                train_acc_tracking.append(train_accuracy.item())
+
+                if args.run_validation:
+                    val_acc_tracking.append(curr_val_loss.item())
+
+                if args.track_memory:
+                    mem_alloc_tracker.append(
+                        format_metrics_to_gb(torch.cuda.memory_allocated())
+                    )
+                    mem_reserved_tracker.append(
+                        format_metrics_to_gb(torch.cuda.memory_reserved())
+                    )
+                print(f"completed save and stats zone...")
+
+            if args.save_model and curr_val_loss < best_val_loss:
+
+                # save
+                if rank == 0:
+                    print(f"--> entering save model state")
+
+                save_policy = FullStateDictConfig(offload_to_cpu=True, rank0_only=True)
+                with FSDP.state_dict_type(
+                    model, StateDictType.FULL_STATE_DICT, save_policy
+                ):
+                    cpu_state = model.state_dict()
+                #print(f"saving process: rank {rank}  done w state_dict")
+
+
+                if rank == 0:
+                    print(f"--> saving model ...")
+                    currEpoch = (
+                        "-" + str(epoch) + "-" + str(round(curr_val_loss.item(), 4)) + ".pt"
+                    )
+                    print(f"--> attempting to save model prefix {currEpoch}")
+                    save_name = file_save_name + "-" + time_of_run + "-" + currEpoch
+                    print(f"--> saving as model name {save_name}")
+
+                    torch.save(cpu_state, save_name)
+
+            if curr_val_loss < best_val_loss:
+
+                best_val_loss = curr_val_loss
+                if rank==0:
+                    print(f"-->>>> New Val Loss Record: {best_val_loss}")
+
+        dist.barrier()
+        cleanup()
+
+
+2.5 Parse the arguments and set the main function:
+
+.. code-block:: python
+
+
+    if __name__ == '__main__':
+        # Training settings
+        parser = argparse.ArgumentParser(description='PyTorch T5 FSDP Example')
+        parser.add_argument('--batch-size', type=int, default=4, metavar='N',
+                            help='input batch size for training (default: 64)')
+        parser.add_argument('--test-batch-size', type=int, default=4, metavar='N',
+                            help='input batch size for testing (default: 1000)')
+        parser.add_argument('--epochs', type=int, default=2, metavar='N',
+                            help='number of epochs to train (default: 3)')
+        parser.add_argument('--lr', type=float, default=.002, metavar='LR',
+                            help='learning rate (default: .002)')
+        parser.add_argument('--gamma', type=float, default=0.7, metavar='M',
+                            help='Learning rate step gamma (default: 0.7)')
+        parser.add_argument('--no-cuda', action='store_true', default=False,
+                            help='disables CUDA training')
+        parser.add_argument('--seed', type=int, default=1, metavar='S',
+                            help='random seed (default: 1)')
+        parser.add_argument('--track_memory', action='store_false', default=True,
+                            help='track the gpu memory')
+        parser.add_argument('--run_validation', action='store_false', default=True,
+                            help='running the validation')
+        parser.add_argument('--save-model', action='store_false', default=True,
+                            help='For Saving the current Model')
+        args = parser.parse_args()
+
+        torch.manual_seed(args.seed)
+
+        fsdp_main(args)
+
+
+To run the the training using torchrun:
+
+.. code-block:: bash
+
+    torchrun --nnodes 1 --nproc_per_node 4  T5_training.py
+
+.. _transformer_wrapping_policy:
+
+Transformer Wrapping Policy
+---------------------------
+
+As discussed in the `previous tutorial
+<https://pytorch.org/tutorials/intermediate/FSDP_tutorial.html>`__,
+auto_wrap_policy is one of the FSDP features that make it easy to automatically
+shard a given model and put the model, optimizer and gradient shards into
+distinct FSDP units.
+
+For some architectures such as Transformer encoder-decoders, some parts of the
+model such as embedding table is being shared with both encoder and decoder.  In
+this case, we need to place the embedding table in the outer FSDP unit so that
+it could be accessed from both encoder and decoder.  In addition, by registering
+the layer class for a transformer, the sharding plan can be made much more
+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).
+
+
+.. code-block:: python
+
+    t5_auto_wrap_policy = functools.partial(
+            transformer_auto_wrap_policy,
+            transformer_layer_cls={
+                T5Block,
+            },
+        )
+    torch.cuda.set_device(local_rank)
+
+
+    model = FSDP(model,
+        auto_wrap_policy=t5_auto_wrap_policy)
+
+To see the wrapped model, you can easily print the model and visually inspect
+the sharding and FSDP units as well.
+
+
+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 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 LooseVersion(torch.version.cuda) >= "11.0"
+        and dist.is_nccl_available()
+        and nccl.version() >= (2, 10)
+    )
+
+One of the advantages of mixed precision in FSDP is providing granular control
+over different precision levels for parameters, gradients, and buffers as
+follows:
+
+.. code-block:: python
+
+    fpSixteen = MixedPrecision(
+        param_dtype=torch.float16,
+        # Gradient communication precision.
+        reduce_dtype=torch.float16,
+        # Buffer precision.
+        buffer_dtype=torch.float16,
+    )
+
+    bfSixteen = MixedPrecision(
+        param_dtype=torch.bfloat16,
+        # Gradient communication precision.
+        reduce_dtype=torch.bfloat16,
+        # Buffer precision.
+        buffer_dtype=torch.bfloat16,
+    )
+
+    fp32_policy = MixedPrecision(
+        param_dtype=torch.float32,
+        # Gradient communication precision.
+        reduce_dtype=torch.float32,
+        # Buffer precision.
+        buffer_dtype=torch.float32,
+    )
+
+Note that if a certain type (parameter, reduce, buffer) is not specified, they
+will not be casted at all.
+
+This flexibility allows users fine grained control, such as only setting
+gradient communication to happen in reduced precision, and all parameters /
+buffer computation to be done in full precision. This is potentially useful in
+cases where intra-node communication is the main bottleneck and parameters /
+buffers must be in full precision to avoid accuracy issues. This can be done
+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:
+
+
+.. code-block:: python
+
+     model = FSDP(model,
+            auto_wrap_policy=t5_auto_wrap_policy,
+            mixed_precision=bfSixteen)
+
+In our experiments, we have observed up to 4x speed up by using BFloat16 for
+training and memory reduction of approximately 30% in some experiments that can
+be used for batch size increases.
+
+
+Intializing FSDP Model on Device
+--------------------------------
+In 1.12, FSDP supports a `device_id` argument meant to initialize input CPU
+module on the device given by `device_id`. This is useful when the entire model
+does not fit on a single GPU, but fits in a host's CPU memory. When `device_id`
+is specified, FSDP will move the model to the specified device on a per-FSDP
+unit basis, avoiding GPU OOM issues while initializing several times faster than
+CPU-based initialization:
+
+.. code-block:: python
+
+    torch.cuda.set_device(local_rank)
+
+     model = FSDP(model,
+            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,
+gradients and optimizer states get sharded across all ranks. (also termed Zero3
+sharding). In case you are interested to have the Zero2 sharding strategy, where
+only optimizer states and gradients are sharded, FSDP support this feature by
+passing the Sharding strategy by using  "ShardingStrategy.SHARD_GRAD_OP",
+instead of "ShardingStrategy.FULL_SHARD" to the FSDP initialization  as follows:
+
+.. code-block:: python
+
+    torch.cuda.set_device(local_rank)
+
+     model = FSDP(model,
+            auto_wrap_policy=t5_auto_wrap_policy,
+            mixed_precision=bfSixteen,
+            device_id=torch.cuda.current_device(),
+            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.
+
+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
+end of backwards and all_gather will happen on the next forward pass.
+
+Backward Prefetch
+-----------------
+The backward prefetch setting controls the timing of when the next FSDP unit's
+parameters should be requested.  By setting it to `BACKWARD_PRE`, the next
+FSDP's unit params can begin to be requested and arrive sooner before the
+computation of the current unit starts. This overlaps the `all_gather`
+communication and gradient computation which can increase the training speed in
+exchange for slightly higher memory consumption. It can be utilized in the FSDP
+wrapper in 2.4 as follows:
+
+.. code-block:: python
+
+    torch.cuda.set_device(local_rank)
+
+     model = FSDP(model,
+            auto_wrap_policy=t5_auto_wrap_policy,
+            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.
+
+Model Checkpoint Saving, by streaming to the Rank0 CPU
+------------------------------------------------------
+To save model checkpoints using FULL_STATE_DICT saving which saves model in the
+same fashion as a local model, PyTorch 1.12 offers a few utilities to support
+the saving of larger models.
+
+First, a FullStateDictConfig can be specified, allowing the state_dict to be
+populated on rank 0 only and offloaded to the CPU.
+
+When using this configuration, FSDP will allgather model parameters, offloading
+them to the CPU one by one, only on rank 0. When the state_dict is finally
+saved, it will only be populated on rank 0 and contain CPU tensors. This avoids
+potential OOM for models that are larger than a single GPU memory and allows
+users to checkpoint models whose size is roughly the available CPU RAM on the
+user's machine.
+
+This feature can be run as follows:
+
+.. code-block:: python
+
+    save_policy = FullStateDictConfig(offload_to_cpu=True, rank0_only=True)
+    with FSDP.state_dict_type(
+                model, StateDictType.FULL_STATE_DICT, save_policy
+            ):
+                cpu_state = model.state_dict()
+    if rank == 0:
+     save_name = file_save_name + "-" + time_of_run + "-" + currEpoch
+     torch.save(cpu_state, save_name)
+
+Summary
+-------
+
+In this tutorial, we have introduced many new features for FSDP available in
+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.
+
+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
+using FSDP, please feel free to contact us by opening an issue in the
+`PyTorch Github repository <https://github.com/pytorch/pytorch>`__.
diff --git a/intermediate_source/FSDP_tutorial.rst b/intermediate_source/FSDP_tutorial.rst
new file mode 100644
index 00000000000..075480adbf0
--- /dev/null
+++ b/intermediate_source/FSDP_tutorial.rst
@@ -0,0 +1,411 @@
+Getting Started with Fully Sharded Data Parallel (FSDP2)
+======================================================
+
+**Author**: `Wei Feng <https://github.com/weifengpy>`__, `Will Constable <https://github.com/wconstab>`__, `Yifan Mao <https://github.com/mori360>`__
+
+.. note::
+   |edit| Check out the code in this tutorial from `pytorch/examples <https://github.com/pytorch/examples/tree/main/distributed/FSDP2>`_. FSDP1 is deprecated. FSDP1 tutorials are archived in `[1] <https://docs.pytorch.org/tutorials/intermediate/FSDP1_tutorial.html>`_ and `[2] <https://docs.pytorch.org/tutorials/intermediate/FSDP_advanced_tutorial.html>`_
+
+How FSDP2 works
+--------------
+In `DistributedDataParallel <https://pytorch.org/docs/stable/generated/torch.nn.parallel.DistributedDataParallel.html>`__ (DDP) training, each rank owns a model replica and processes a batch of data, finally it uses all-reduce to sync gradients across ranks.
+
+Comparing with DDP, FSDP reduces GPU memory footprint by sharding model parameters, gradients, and optimizer states. It makes it feasible to train models that cannot fit on a single GPU. As shown below in the picture,
+
+* Outside of forward and backward computation, parameters are fully sharded
+* Before forward and backward, sharded parameters are all-gathered into unsharded parameters
+* Inside backward, local unsharded gradients are reduce-scatterred into sharded gradients
+* Optimizer updates sharded parameters with sharded gradients, resulting in sharded optimizer states
+
+.. figure:: /_static/img/distributed/fsdp_workflow.png
+   :width: 100%
+   :align: center
+   :alt: FSDP workflow
+
+
+FSDP can be considered a decomposition of DDP's all-reduce into reduce-scatter and all-gather operations
+
+.. figure:: /_static/img/distributed/fsdp_sharding.png
+   :width: 100%
+   :align: center
+   :alt: FSDP all-gather and reduce-scatter
+
+
+Comparing with `FSDP1
+<https://docs.pytorch.org/docs/stable/fsdp.html>`__, FSDP2 has following advantages:
+
+* Representing sharded parameters as `DTensor <https://docs.pytorch.org/docs/stable/distributed.tensor.html>`_ sharded on dim-i, allowing for easy manipulation of individual parameters, communication-free sharded state dicts, and a simpler meta-device initialization flow.
+* Improving memory management system that achieves lower and deterministic GPU memory by avoiding ``recordStream`` (`doc <https://dev-discuss.pytorch.org/t/fsdp-cudacachingallocator-an-outsider-newb-perspective/1486>`_) and does so without any CPU synchronization.
+* Offering a tensor subclass extension point to customize the all-gather, e.g. for float8 all-gather for float8 linears (`doc <https://dev-discuss.pytorch.org/t/enabling-float8-all-gather-in-fsdp2/2359>`_), and NF4 for QLoRA (`doc <https://github.com/pytorch/torchtune/blob/main/README.md>`_)
+* Mixing frozen and non-frozen parameters can in the same communication group without using extra memory.
+
+How to use FSDP2
+---------------
+
+Model Initialization
+~~~~~~~~~~~~~~~
+
+**Applying fully_shard on submodules**: Different from DDP, we should apply `fully_shard <https://docs.pytorch.org/docs/main/distributed.fsdp.fully_shard.html>`_ on submodules as well as the root model. In the transformer example below, we applied ``fully_shard`` on each layer first, then the root model
+
+* During forward computation of ``layers[i]``, the rest of the layers are sharded to reduce memory footprint
+* Inside ``fully_shard(model)``, FSDP2 excludes parameters from ``model.layers`` and classify remaining parameters into a parameter group for performant all-gather and reduce-scatter
+* ``fully_shard`` moves sharded model to actual training device (eg ``cuda``)
+
+
+**Command**: ``torchrun --nproc_per_node 2 train.py``
+
+.. code-block:: python
+
+    from torch.distributed.fsdp import fully_shard, FSDPModule
+    model = Transformer()
+    for layer in model.layers:
+        fully_shard(layer)
+    fully_shard(model)
+
+    assert isinstance(model, Transformer)
+    assert isinstance(model, FSDPModule)
+    print(model)
+    #  FSDPTransformer(
+    #    (tok_embeddings): Embedding(...)
+    #    ...
+    #    (layers): 3 x FSDPTransformerBlock(...)
+    #    (output): Linear(...)
+    #  )
+
+We can inspect the nested wrapping with ``print(model)``. ``FSDPTransformer`` is a joint class of `Transformer <https://github.com/pytorch/examples/blob/70922969e70218458d2a945bf86fd8cc967fc6ea/distributed/FSDP2/model.py#L100>`_ and `FSDPModule
+<https://docs.pytorch.org/docs/main/distributed.fsdp.fully_shard.html#torch.distributed.fsdp.FSDPModule>`_. The same thing happens to `FSDPTransformerBlock <https://github.com/pytorch/examples/blob/70922969e70218458d2a945bf86fd8cc967fc6ea/distributed/FSDP2/model.py#L76C7-L76C18>`_. All FSDP2 public APIs are exposed through ``FSDPModule``. For example, users can call ``model.unshard()`` to manually control all-gather schedules. See "explicit prefetching" below for details.
+
+**model.parameters() as DTensor**: ``fully_shard`` shards parameters across ranks, and convert ``model.parameters()`` from plain ``torch.Tensor`` to DTensor to represent sharded parameters. FSDP2 shards on dim-0 by default so DTensor placements are `Shard(dim=0)`. Say we have N ranks and a parameter with N rows before sharding. After sharding, each rank will have 1 row of the parameter. We can inspect sharded parameters using ``param.to_local()``.
+
+.. code-block:: python
+
+    from torch.distributed.tensor import DTensor
+    for param in model.parameters():
+        assert isinstance(param, DTensor)
+        assert param.placements == (Shard(0),)
+        # inspect sharded parameters with param.to_local()
+
+    optim = torch.optim.Adam(model.parameters(), lr=1e-2)
+
+Note the optimizer is constructed after applying ``fully_shard``. Both model and optimizer state dicts are represented in DTensor.
+
+DTensor facilitates optimizer, gradient clipping and checkpointing
+
+* ``torch.optim.Adam`` and ``torch.nn.utils.clip_grad_norm_`` works out of the box for DTensor parameters. It makes the code consistent between single-device and distributed training
+* we can use DTensor and DCP APIs to manipulate parameters to get full state dict, see "state dict" section below for details. For distributed state dicts, we can save/load checkpoints (`doc <https://docs.pytorch.org/tutorials/recipes/distributed_checkpoint_recipe.html>`_) without extra communication
+
+
+Forward/Backward with Prefetching
+~~~~~~~~~~~~~~~
+
+**command**: ``torchrun --nproc_per_node 2 train.py``
+
+.. code-block:: python
+
+    for _ in range(epochs):
+        x = torch.randint(0, vocab_size, (batch_size, seq_len), device=device)
+        loss = model(x).sum()
+        loss.backward()
+        optim.step()
+        optim.zero_grad()
+
+``fully_shard`` registers forward/backward hooks to all-gather parameters before computation, and reshards parameters after computation. To overlap all-gathers with computation, FSDP2 offers **implicit prefetching** that works out of the box with the training loop above and **explicit prefetching** for advanced users to control all-gather schedules manually.
+
+**Implicit Prefetching**: CPU thread issues all-gather i before layer i. All-gathers are queued into its own cuda stream while layer i computation happens in the default stream. For non-cpu-bound workload (eg Transformer with big batch size), all-gather i+1 can overlap with computation for layer i. Implicit prefetching works similarly in the backward, except all-gathers are issued in the reverse of post-forward order.
+
+.. figure:: /_static/img/distributed/fsdp_implicit.png
+   :width: 100%
+   :align: center
+   :alt: FSDP Implicit
+
+We recommend users to start with implicit prefetching to understand the performance out of the box.
+
+**Explicit Prefetching**: Users can specify forward ordering with `set_modules_to_forward_prefetch <https://docs.pytorch.org/docs/main/distributed.fsdp.fully_shard.html#torch.distributed.fsdp.FSDPModule.set_modules_to_forward_prefetch>`_, and backward ordering with `set_modules_to_backward_prefetch <https://docs.pytorch.org/docs/main/distributed.fsdp.fully_shard.html#torch.distributed.fsdp.FSDPModule.set_modules_to_backward_prefetch>`_. As shown in the code below, CPU thread issue all-gather i + 1 and i + 2 at layer i
+
+Explicit prefetching works well in following situation:
+
+**CPU-bound workload**: If using implicit prefetching, CPU thread will be too slow to issue all-gather for layer i+1 when kernels from layer i get executed. We have to explicitly issue all-gather i+1 before running forward for layer i
+
+**Prefetching for 2+ layers**: Implicit prefetching only all-gathers next one layer at a time to keep memory footprint minimum. With explicit prefetching can all-gather multiple layers at a time to possibly for better perf with increased memory. See ``layers_to_prefetch`` in the code
+
+**Issuing 1st all-gather earlier**: Implicit prefetching happens at the time of calling ``model(x)``. The 1st all-gather gets exposed. We can call `model.unshard() <https://docs.pytorch.org/docs/main/distributed.fsdp.fully_shard.html#torch.distributed.fsdp.FSDPModule.unshard>`_ explicitly earlier to issue 1st all-gather earlier
+
+**command**: ``torchrun --nproc_per_node 2 train.py --explicit-prefetching``
+
+.. code-block:: python
+
+    num_to_forward_prefetch = 2
+    for i, layer in enumerate(model.layers):
+        if i >= len(model.layers) - num_to_forward_prefetch:
+            break
+        layers_to_prefetch = [
+            model.layers[i + j] for j in range(1, num_to_forward_prefetch + 1)
+        ]
+        layer.set_modules_to_forward_prefetch(layers_to_prefetch)
+
+    num_to_backward_prefetch = 2
+    for i, layer in enumerate(model.layers):
+        if i < num_to_backward_prefetch:
+            continue
+        layers_to_prefetch = [
+            model.layers[i - j] for j in range(1, num_to_backward_prefetch + 1)
+        ]
+        layer.set_modules_to_backward_prefetch(layers_to_prefetch)
+
+    for _ in range(epochs):
+        # trigger 1st all-gather earlier
+        # this overlaps all-gather with any computation before model(x)
+        model.unshard()
+        x = torch.randint(0, vocab_size, (batch_size, seq_len), device=device)
+        loss = model(x).sum()
+        loss.backward()
+        optim.step()
+        optim.zero_grad()
+
+
+Enabling Mixed Precision
+~~~~~~~~~~~~~~~
+
+FSDP2 offers a flexible `mixed precision policy <https://docs.pytorch.org/docs/main/distributed.fsdp.fully_shard.html#torch.distributed.fsdp.MixedPrecisionPolicy>`_ to speed up training. One typical use case is
+
+* Casting float32 parameters to bfloat16 for forward/backward computation, see ``param_dtype=torch.bfloat16``
+* Upcasting gradients to float32 for reduce-scatter to preserve accuracy, see ``reduce_dtype=torch.float32``
+
+Comparing with `torch.amp <https://docs.pytorch.org/docs/stable/amp.html>`_, FSDP2 mixed precision has following advantages
+
+* **Performant and flexible parameter casting**: All the parameters inside a ``FSDPModule`` are cast together at the module boundary (before and after before/backward). We can set different mixed precision policies for each layer. For example, the first few layers can be in float32 while remaining layers can be in bfloat16.
+
+* **float32 gradient reduction (reduce-scatter)**: Gradients might vary a lot from rank to rank. Reducing gradients in float32 can be critical for numerics.
+
+
+
+**command**: ``torchrun --nproc_per_node 2 train.py --mixed-precision``
+
+.. code-block:: python
+
+    model = Transformer(model_args)
+    fsdp_kwargs = {
+        "mp_policy": MixedPrecisionPolicy(
+            param_dtype=torch.bfloat16,
+            reduce_dtype=torch.float32,
+        )
+    }
+    for layer in model.layers:
+        fully_shard(layer, **fsdp_kwargs)
+    fully_shard(model, **fsdp_kwargs)
+
+    # sharded parameters are float32
+    for param in model.parameters():
+        assert param.dtype == torch.float32
+
+    # unsharded parameters are bfloat16
+    model.unshard()
+    for param in model.parameters(recurse=False):
+        assert param.dtype == torch.bfloat16
+    model.reshard()
+
+    # optimizer states are in float32
+    optim = torch.optim.Adam(model.parameters(), lr=1e-2)
+
+    # training loop
+    # ...
+
+
+
+Gradient Clipping and Optimizer with DTensor
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+**command**: ``torchrun --nproc_per_node 2 train.py``
+
+.. code-block:: python
+
+    # optim is constructed base on DTensor model parameters
+    optim = torch.optim.Adam(model.parameters(), lr=1e-2)
+    for _ in range(epochs):
+        x = torch.randint(0, vocab_size, (batch_size, seq_len), device=device)
+        loss = model(x).sum()
+        loss.backward()
+        torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=max_norm)
+        optim.step()
+        optim.zero_grad()
+
+Optimizer is initialized after applying ``fully_shard`` on the model, and holds reference to DTensor ``model.parameters()``. For gradient clipping, ``torch.nn.utils.clip_grad_norm_`` works for DTensor parameters. Tensor ops will be dispatched correctly inside DTensor to communicate partial tensors across ranks to preserve the single device semantic.
+
+
+State Dicts with DTensor APIs
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+We showcase how to convert a full state dict into a DTensor state dict for loading, and how to convert it back to full state dict for saving.
+
+**command**: ``torchrun --nproc_per_node 2 train.py``
+
+* For the 1st time, it creates checkpoints for the model and optimizer
+* For the 2nd time, it loads from the previous checkpoint to resume training
+
+**Loading state dicts**: We initialize the model under meta device and call ``fully_shard`` to convert ``model.parameters()`` from plain ``torch.Tensor`` to DTensor. After reading the full state dict from torch.load, we can call `distribute_tensor <https://docs.pytorch.org/docs/stable/distributed.tensor.html#torch.distributed.tensor.distribute_tensor>`_ to convert plain ``torch.Tensor`` into DTensor, using the same placements and device mesh from ``model.state_dict()``. Finally we can call `model.load_state_dict <https://docs.pytorch.org/docs/stable/generated/torch.nn.Module.html#torch.nn.Module.load_state_dict>`_ to load DTensor state dicts into the model.
+
+.. code-block:: python
+
+    from torch.distributed.tensor import distribute_tensor
+
+    # mmap=True reduces CPU memory usage
+    full_sd = torch.load(
+        "checkpoints/model_state_dict.pt",
+        mmap=True,
+        weights_only=True,
+        map_location='cpu',
+    )
+    meta_sharded_sd = model.state_dict()
+    sharded_sd = {}
+    for param_name, full_tensor in full_sd.items():
+        sharded_meta_param = meta_sharded_sd.get(param_name)
+        sharded_tensor = distribute_tensor(
+            full_tensor,
+            sharded_meta_param.device_mesh,
+            sharded_meta_param.placements,
+        )
+        sharded_sd[param_name] = nn.Parameter(sharded_tensor)
+    # `assign=True` since we cannot call `copy_` on meta tensor
+    model.load_state_dict(sharded_sd, assign=True)
+
+**Saving state dicts**: ``model.state_dict()`` returns a DTensor state dict. We can convert a DTensor into a plain ``torch.Tensor`` by calling `full_tensor() <https://docs.pytorch.org/docs/stable/distributed.tensor.html#torch.distributed.tensor.DTensor.full_tensor>`_. Internally it issues an all-gather across ranks to get unsharded parameters in plain torch.Tensor. For rank 0, ``full_param.cpu()`` offloads the tensor to cpu one by one to avoid peaking GPU memory with unsharded parameters.
+
+.. code-block:: python
+
+    sharded_sd = model.state_dict()
+    cpu_state_dict = {}
+    for param_name, sharded_param in sharded_sd.items():
+        full_param = sharded_param.full_tensor()
+        if torch.distributed.get_rank() == 0:
+            cpu_state_dict[param_name] = full_param.cpu()
+        else:
+            del full_param
+    torch.save(cpu_state_dict, "checkpoints/model_state_dict.pt")
+
+
+Optimizer state dict works similarly (`code <https://github.com/pytorch/examples/blob/70922969e70218458d2a945bf86fd8cc967fc6ea/distributed/FSDP2/checkpoint.py#L156>`_). Users can customize the above DTensor scripts to work with 3rd party checkpoints.
+
+If there is no need for customization, we can use `DCP APIs <https://docs.pytorch.org/docs/stable/distributed.checkpoint.html>`_ directly to support both single-node and multi-node training.
+
+
+State Dict with DCP APIs
+~~~~~~~~~~~~~~~~~~~~~~~~
+
+**command**: ``torchrun --nproc_per_node 2 train.py --dcp-api``
+
+* For the 1st time, it creates checkpoints for the model and optimizer
+* For the 2nd time, it loads from the previous checkpoint to resume training
+
+**Loading state dicts**: We can load a full state dict into a FSDP2 model with `set_model_state_dict <https://docs.pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.state_dict.set_model_state_dict>`_. With ``broadcast_from_rank0=True``, we can load the full state dict only on rank 0 to avoid peaking CPU memory. DCP will shard tensors and broadcast them to other ranks.
+
+.. code-block:: python
+
+    from torch.distributed.checkpoint.state_dict import set_model_state_dict
+    set_model_state_dict(
+        model=model,
+        model_state_dict=full_sd,
+        options=StateDictOptions(
+            full_state_dict=True,
+            broadcast_from_rank0=True,
+        ),
+    )
+
+**Saving state dicts**: `get_model_state_dict <https://docs.pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.state_dict.get_model_state_dict>`_ with ``full_state_dict=True`` and ``cpu_offload=True`` all-gathers tensors and offload them to CPU. It works similarly to DTensor APIs.
+
+.. code-block:: python
+
+    from torch.distributed.checkpoint.state_dict import get_model_state_dict
+    model_state_dict = get_model_state_dict(
+        model=model,
+        options=StateDictOptions(
+            full_state_dict=True,
+            cpu_offload=True,
+        )
+    )
+    torch.save(model_state_dict, "model_state_dict.pt")
+
+
+Refer to `pytorch/examples <https://github.com/pytorch/examples/blob/main/distributed/FSDP2/checkpoint.py>`__ for loading and saving optimizer state dicts with `set_optimizer_state_dict <https://docs.pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.state_dict.set_optimizer_state_dict>`_ and `get_optimizer_state_dict <https://docs.pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.state_dict.get_optimizer_state_dict>`_.
+
+
+FSDP1-to-FSDP2 migration guide
+---------------
+
+Let’s look at an example of an `FSDP <https://docs.pytorch.org/docs/stable/fsdp.html>`_ usage and an equivalent `fully_shard <https://docs.pytorch.org/docs/main/distributed.fsdp.fully_shard.html>`_ usage.  We’ll highlight the key differences and suggest steps for migration.
+
+Original FSDP() usage
+
+.. code-block:: python
+
+    from torch.distributed.fsdp import FullyShardedDataParallel as FSDP
+    with torch.device("meta"):
+        model = Transformer()
+    policy = ModuleWrapPolicy({TransformerBlock})
+    model = FSDP(model, auto_wrap_policy=policy)
+    def param_init_fn(module: nn.Module) -> None: ...
+    model = FSDP(model, auto_wrap_policy=policy, param_init_fn=param_init_fn)
+
+New fully_shard() usage
+
+.. code-block:: python
+
+    with torch.device("meta"):
+        model = Transformer()
+    for module in model.modules():
+        if isinstance(module, TransformerBlock):
+            fully_shard(module)
+    fully_shard(model)
+    for tensor in itertools.chain(model.parameters(), model.buffers()):
+        assert tensor.device == torch.device("meta")
+
+
+    # Initialize the model after sharding
+    model.to_empty(device="cuda")
+    model.reset_parameters()
+
+Migration Steps
+
+* Replace the imports
+* Implement your ‘policy’ directly (apply ``fully_shard`` to the desired sublayers)
+* Wrap your root model with ``fully_shard`` instead of ``FSDP``
+* Get rid of ``param_init_fn`` and manually call ``model.reset_parameters()``
+* Replace other FSDP1 kwargs (see below)
+
+
+sharding_strategy
+
+* FULL_SHARD: ``reshard_after_forward=True``
+* SHARD_GRAD_OP: ``reshard_after_forward=False``
+* HYBRID_SHARD: ``reshard_after_forward=True`` with a 2D device mesh
+* _HYBRID_SHARD_ZERO2: ``reshard_after_forward=False`` with a 2D device mesh
+
+cpu_offload
+
+* CPUOffload.offload_params=False: ``offload_policy=None``
+* CPUOffload.offload_params = True: ``offload_policy=CPUOffloadPolicy()``
+
+backward_prefetch
+
+* BACKWARD_PRE: always used
+* BACKWARD_POST: not supported
+
+mixed_precision
+
+* ``buffer_dtype`` is omitted because fully_shard does not shard buffers
+* fully_shard’s ``cast_forward_inputs`` maps to both ``cast_forward_inputs`` and ``cast_root_forward_inputs`` in FSDP1
+* ``output_dtype`` is a new config for fully_shard
+
+device_id: Inferred from device_mesh’s device
+
+sync_module_states=True/False: Moved to DCP. User can broadcast state dicts from rank0 using `set_model_state_dict <https://docs.pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.state_dict.set_model_state_dict>`_ with ``broadcast_from_rank0=True``
+
+forward_prefetch: Manual control over prefetching is possible with
+
+* Manually call `fsdp_module.unshard() <https://docs.pytorch.org/docs/main/distributed.fsdp.fully_shard.html#torch.distributed.fsdp.FSDPModule.unshard>`_
+* Use these APIs to control automatic prefetching, `set_modules_to_forward_prefetch <https://docs.pytorch.org/docs/main/distributed.fsdp.fully_shard.html#torch.distributed.fsdp.FSDPModule.set_modules_to_forward_prefetch>`_ and `set_modules_to_backward_prefetch <https://docs.pytorch.org/docs/main/distributed.fsdp.fully_shard.html#torch.distributed.fsdp.FSDPModule.set_modules_to_backward_prefetch>`_
+
+limit_all_gathers: No longer needed, because ``fully_shard`` removed cpu synchronization
+
+use_orig_params: Original params are always used (no more flat parameter)
+
+no_sync(): `set_requires_gradient_sync <https://docs.pytorch.org/docs/main/distributed.fsdp.fully_shard.html#torch.distributed.fsdp.FSDPModule.set_requires_gradient_sync>`_
+
+ignored_params and ignored_states: `ignored_params <https://docs.pytorch.org/docs/main/distributed.fsdp.fully_shard.html#torch.distributed.fsdp.fully_shard>`_
diff --git a/intermediate_source/README.txt b/intermediate_source/README.txt
index 1b8e637094e..ecc8eb74af4 100644
--- a/intermediate_source/README.txt
+++ b/intermediate_source/README.txt
@@ -1,26 +1,34 @@
 Intermediate tutorials
 ----------------------
 
-1. char_rnn_classification_tutorial.py
+1. tensorboard_tutorial.py
+	Classifying Names with a Character-Level RNN
+	https://pytorch.org/tutorials/intermediate/tensorboard_tutorial.html
+
+2. char_rnn_classification_tutorial.py
 	Classifying Names with a Character-Level RNN
 	https://pytorch.org/tutorials/intermediate/char_rnn_classification_tutorial.html
 
-2. char_rnn_generation_tutorial.py
+3. char_rnn_generation_tutorial.py
 	Generating Names with a Character-Level RNN
 	https://pytorch.org/tutorials/intermediate/char_rnn_generation_tutorial.html
 
-3. seq2seq_translation_tutorial.py
+4. seq2seq_translation_tutorial.py
 	Translation with a Sequence to Sequence Network and Attention
 	https://pytorch.org/tutorials/intermediate/seq2seq_translation_tutorial.html
 
-4. reinforcement_q_learning.py
+5. reinforcement_q_learning.py
 	Reinforcement Learning (DQN) Tutorial
 	https://pytorch.org/tutorials/intermediate/reinforcement_q_learning.html
 
-5. dist_tuto.rst
+6. dist_tuto.rst
 	Writing Distributed Applications with PyTorch
 	https://pytorch.org/tutorials/intermediate/dist_tuto.html
 
-6. spatial_transformer_tutorial
+7. spatial_transformer_tutorial
 	Spatial Transformer Networks Tutorial
 	https://pytorch.org/tutorials/intermediate/spatial_transformer_tutorial.html
+
+8. nvfuser_intro_tutorial.py
+        Introduction to nvFuser
+	https://pytorch.org/tutorials/intermediate/nvfuser_intro_tutorial.html
diff --git a/intermediate_source/TCPStore_libuv_backend.rst b/intermediate_source/TCPStore_libuv_backend.rst
new file mode 100644
index 00000000000..1e285eba7c4
--- /dev/null
+++ b/intermediate_source/TCPStore_libuv_backend.rst
@@ -0,0 +1,286 @@
+Introduction to Libuv TCPStore Backend
+======================================
+**Authors**: `Xilun Wu <https://github.com/XilunWu>`_
+
+.. note::
+    |edit| View and edit this tutorial in `github <https://github.com/pytorch/tutorials/blob/main/intermediate_source/TCPStore_libuv_backend.rst>`__.
+
+.. grid:: 2
+
+   .. grid-item-card:: :octicon:`mortar-board;1em;` What you will learn
+      :class-card: card-prerequisites
+  
+      *  What is the new TCPStore backend
+      *  Compare the new libuv backend against the legacy backend
+      *  How to enable to use the legacy backend
+
+
+   .. grid-item-card:: :octicon:`list-unordered;1em;` Prerequisites
+      :class-card: card-prerequisites
+
+      * PyTorch 2.4 or later
+      * Read about the `TCPStore API <https://pytorch.org/docs/main/distributed.html#torch.distributed.TCPStore>`__.
+
+
+Introduction
+------------
+
+Recently, we have rolled out a new TCPStore server backend using `libuv <https://github.com/libuv/libuv>`__, a third-party library for asynchronous I/O. This new server backend aims to
+address scalability and robustness challenges in large-scale distributed training jobs, such as those with more than 1024 ranks. We ran a series of
+benchmarks to compare the libuv backend against the old one, and the experiment results demonstrated significant improvements in store initialization
+time and maintained a comparable performance in store I/O operations.
+
+As a result of these findings, the libuv backend has been set as the default TCPStore server backend in PyTorch 2.4. This change is expected to enhance
+the performance and scalability of distributed training jobs.
+
+This change introduces a slight incompatibility to store initialization. For users who wish to continue using the legacy backend, the tutorial will
+provide guidance on how to specify to use the previous TCPStore server backend.
+
+
+Performance Benchmark
+---------------------
+
+To better demonstrate the benefit of our new libuv TCPStore backend, we set up a benchmark over a wide range of job size, from 1024 (1K) to 98304 (96K) ranks.
+We first measured the TCPStore initialization time using the code snippet below:
+
+.. code:: python
+
+    import logging
+    import os
+
+    from time import perf_counter
+
+    import torch
+    import torch.distributed as dist
+
+    logger: logging.Logger = logging.getLogger(__name__)
+
+    # Env var are preset when launching the benchmark
+    env_rank = os.environ.get("RANK", 0)
+    env_world_size = os.environ.get("WORLD_SIZE", 1)
+    env_master_addr = os.environ.get("MASTER_ADDR", "localhost")
+    env_master_port = os.environ.get("MASTER_PORT", "23456")
+
+    start = perf_counter()
+    tcp_store = dist.TCPStore(
+        env_master_addr,
+        int(env_master_port),
+        world_size=int(env_world_size),
+        is_master=(int(env_rank) == 0),
+    )
+    end = perf_counter()
+    time_elapsed = end - start
+    logger.info(
+        f"Complete TCPStore init with rank={env_rank}, world_size={env_world_size} in {time_elapsed} seconds."
+    )
+
+Since the execution of the TCPStore server thread will be blocked until all clients are successfully connected, we take the time measured on rank 0 as the total
+TCPStore initialization runtime. The experiment numbers are reported in the figure below:
+
+.. figure:: /_static/img/distributed/tcpstore_init_time.png
+   :width: 100%
+   :align: center
+   :alt: TCPStore Initialization Runtime Benchmark Result
+
+Figure 1. shows some significant evidence that the libuv backend is superior to the legacy backend:
+
+- TCPStore with libuv backend always has a faster initialization than the legacy backend, especially at super-large scale
+- The legacy backend would timeout at server-client connecting at 96K scale (for example, over 30 minutes) while the libuv backend completed the initialization in 100 seconds.
+
+The second benchmark we did is to measure the runtime of TCPStore ``store_based_barrier`` operation:
+
+.. code:: python
+
+    import logging
+    import os
+    import time
+
+    from datetime import timedelta
+    from time import perf_counter
+
+    import torch
+    import torch.distributed as dist
+
+    DistStoreError = torch._C._DistStoreError
+    logger: logging.Logger = logging.getLogger(__name__)
+
+    # since dist._store_based_barrier is a private function and cannot be directly called, we need to write a function which does the same
+    def store_based_barrier(
+        rank,
+        store,
+        group_name,
+        rendezvous_count,
+        timeout=dist.constants.default_pg_timeout,
+        logging_interval=timedelta(seconds=10),
+    ):
+        store_key = f"store_based_barrier_key:{group_name}"
+        store.add(store_key, 1)
+
+        world_size = rendezvous_count
+        worker_count = store.add(store_key, 0)
+
+        last_worker_key = f"{store_key}:last_worker"
+        if worker_count == world_size:
+            store.set(last_worker_key, "1")
+
+        start = time.time()
+        while True:
+            try:
+                # This will throw an exception after the logging_interval in which we print out
+                # the status of the group or time out officially, throwing runtime error
+                store.wait([last_worker_key], logging_interval)
+                break
+            except RuntimeError as e:
+                worker_count = store.add(store_key, 0)
+                # Print status periodically to keep track.
+                logger.info(
+                    "Waiting in store based barrier to initialize process group for "
+                    "rank: %s, key: %s (world_size=%s, num_workers_joined=%s, timeout=%s)"
+                    "error: %s",
+                    rank,
+                    store_key,
+                    world_size,
+                    worker_count,
+                    timeout,
+                    e,
+                )
+
+                if timedelta(seconds=(time.time() - start)) > timeout:
+                    raise DistStoreError(
+                        "Timed out initializing process group in store based barrier on "
+                        "rank {}, for key: {} (world_size={}, num_workers_joined={}, timeout={})".format(
+                            rank, store_key, world_size, worker_count, timeout
+                        )
+                    )
+
+        logger.info(
+            "Rank %s: Completed store-based barrier for key:%s with %s nodes.",
+            rank,
+            store_key,
+            world_size,
+        )
+
+    # Env var are preset when launching the benchmark
+    env_rank = os.environ.get("RANK", 0)
+    env_world_size = os.environ.get("WORLD_SIZE", 1)
+    env_master_addr = os.environ.get("MASTER_ADDR", "localhost")
+    env_master_port = os.environ.get("MASTER_PORT", "23456")
+
+    tcp_store = dist.TCPStore(
+        env_master_addr,
+        int(env_master_port),
+        world_size=int(env_world_size),
+        is_master=(int(env_rank) == 0),
+    )
+
+    # sync workers
+    store_based_barrier(int(env_rank), tcp_store, "tcpstore_test", int(env_world_size))
+
+    number_runs = 10
+    start = perf_counter()
+    for _ in range(number_runs):
+        store_based_barrier(
+            int(env_rank), tcp_store, "tcpstore_test", int(env_world_size)
+        )
+    end = perf_counter()
+    time_elapsed = end - start
+    logger.info(
+        f"Complete {number_runs} TCPStore barrier runs with rank={env_rank}, world_size={env_world_size} in {time_elapsed} seconds."
+    )
+
+We compute the average by dividing the runtime measured on rank 0 by ``number_runs`` and report it in the figure below:
+
+.. figure:: /_static/img/distributed/tcpstore_barrier_time.png
+   :width: 100%
+   :align: center
+   :alt: TCPStore Barrier Runtime Benchmark Result
+
+Figure 2. shows that the I/O performance of libuv backend is comparable to the legacy backend:
+
+- The libuv backend has a comparable performance over the whole spectrum in terms of the number of ranks
+- The libuv backend runtime is more stable than the legacy backend as the number of ranks grows
+
+
+Impact
+------
+
+One incompatibility that users may need to pay attention is, TCPStore currently does not support initialization with a ``listen_fd`` when using libuv backend.
+If the user wants to keep using this initialization method, the user can simply pass ``use_libuv=False`` to stay with the old TCPStore backend.
+
+.. code:: python
+
+    import socket
+
+    import torch
+    import torch.distributed as dist
+
+    listen_sock: socket.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    listen_sock.bind(("localhost", 0))
+    addr, port, *_ = listen_sock.getsockname()
+    listen_fd = listen_sock.detach()
+
+    tcpstore = dist.TCPStore(addr, port, 1, True, master_listen_fd=listen_fd)  # expect NotImplementedError
+    tcpstore = dist.TCPStore(addr, port, 1, True, master_listen_fd=listen_fd, use_libuv=False)  # OK. Use legacy backend
+
+
+Exit Route 1: Pass ``use_libuv=False`` to TCPStore Initialization
+-----------------------------------------------------------------
+
+As the above code snippet shows, if user calls TCPStore init method to create a store, simply passing ``use_libuv=False`` allows user to remain using the old
+TCPStore backend. This override has the highest priority over other approaches determining which backend the TCPStore server should choose.
+
+
+Exit Route 2: Add ``use_libuv=0`` to ``init_method`` at ProcessGroup Initialization
+-----------------------------------------------------------------------------------
+
+``ProcessGroup`` creates a TCPStore if user does not explicitly pass one to its initialization. User can add the query option ``use_libuv=0`` to ``init_method`` when
+initializing the ``ProcessGroup``. This approach has lower priority than Exit Route 1.
+
+.. code:: python
+
+    import torch
+    import torch.distributed as dist
+
+    addr = "localhost"
+    port = 23456
+    dist.init_process_group(
+        backend="cpu:gloo,cuda:nccl",
+        rank=0,
+        world_size=1,
+        init_method=f"tcp://{addr}:{port}?use_libuv=0",
+    )
+    dist.destroy_process_group()
+
+
+Exit Route 3: Set Environment Variable ``USE_LIBUV`` to ``0``
+-------------------------------------------------------------
+
+When ProcessGroup creates a TCPStore, it also checks the environment vairable ``USE_LIBUV`` to determine which TCPStore backend to use. User can set the environment
+variable ``"USE_LIBUV"`` to ``"0"`` to specify the use of old TCPStore backend. This approach has lower priority than Exit Route 2, for example, if the user sets environment
+variable ``USE_LIBUV`` to ``1`` and also passes ``use_libuv=0`` in ``init_method``, then the old store backend will be chosen.
+
+.. code:: python
+
+    import os
+
+    import torch
+    import torch.distributed as dist
+
+    addr = "localhost"
+    port = 23456
+    os.environ["USE_LIBUV"] = "0"
+    dist.init_process_group(
+        backend="cpu:gloo,cuda:nccl",
+        rank=0,
+        world_size=1,
+        init_method=f"tcp://{addr}:{port}",
+    )
+    dist.destroy_process_group()
+
+
+Conclusion
+----------
+In PyTorch 2.4, we made the new libuv TCPStore backend the default. Although the new backend has incompatibility with initialization from a ``listen_fd``, it
+shows significant performance improvement on store initialization at large-scale and compatible performance on store I/O at small/medium/large scales, which
+brings a major benefit to Distributed Training's control plane. This tutorial explains our motivation, goes through the performance benchmark, notifies users
+of the potential impact, and introduces three exit routes to remain using the legacy backend. In the long term, we aim to eventually deprecate the legacy backend.
diff --git a/intermediate_source/TP_tutorial.rst b/intermediate_source/TP_tutorial.rst
new file mode 100644
index 00000000000..6d3e7b60c68
--- /dev/null
+++ b/intermediate_source/TP_tutorial.rst
@@ -0,0 +1,356 @@
+Large Scale Transformer model training with Tensor Parallel (TP)
+======================================================
+
+**Author**: `Wanchao Liang <https://github.com/wanchaol>`__, `Tianyu Liu <https://github.com/tianyu-l>`__
+
+.. note::
+   |edit| View and edit this tutorial in `github <https://github.com/pytorch/tutorials/blob/main/intermediate_source/TP_tutorial.rst>`__.
+
+This tutorial demonstrates how to train a large Transformer-like model across hundreds to thousands of GPUs using Tensor Parallel and Fully Sharded Data Parallel.
+
+Prerequisites:
+
+- PyTorch 2.3.0 or later installed with CUDA/Linux
+-  `Tensor Parallel APIs <https://pytorch.org/docs/stable/distributed.tensor.parallel.html>`__
+-  `Getting Started with DeviceMesh <https://pytorch.org/tutorials/recipes/distributed_device_mesh.html>`__
+-  `Getting Started with Fully Sharded Data Parallel <https://pytorch.org/tutorials/intermediate/FSDP_tutorial.html>`__
+
+
+How Tensor Parallel works?
+-----------
+Tensor Parallel (TP) was originally proposed in the `Megatron-LM <https://arxiv.org/abs/1909.08053>`__ paper,
+and it is an efficient model parallelism technique to train large scale Transformer models.
+`Sequence Parallel <https://arxiv.org/abs/2205.05198>`__ (SP) we mention in this tutorial is a variant of Tensor
+Parallel that shards on the sequence dimension for ``nn.LayerNorm`` or ``RMSNorm`` to further save activation memory
+during training. As the model becomes larger, the activation memory becomes the bottleneck, so in Tensor
+Parallel training it usually applies Sequence Parallel to ``LayerNorm`` or ``RMSNorm`` layers.
+
+.. figure:: /_static/img/distributed/megatron_lm.png
+   :width: 100%
+   :align: center
+   :alt: Megatron-LM TP
+
+   Figure 1. represents the sharding in Tensor Parallel style on a Transformer model’s MLP and Self-Attention layer, where the matrix multiplications in both attention/MLP happens through sharded computations (`image source <https://arxiv.org/abs/1909.08053>`__)
+
+
+At a high level, PyTorch Tensor Parallel works as follows:
+
+**Sharding initialization**
+
+* Determine which ``ParallelStyle`` to apply to each layer and shard the initialized module by calling ``parallelize_module``.
+* The parallelized modules would have their model parameters be swapped to DTensors, and DTensor would be responsible to run the parallelized module using sharded computation.
+
+**Runtime foward/backward**
+
+* Depending on the input/outputs DTensor layouts user specified for each ``ParallelStyle``, it would run proper communication operation to transform the DTensor layouts for inputs/outputs (such as ``allreduce``, ``allgather`` and ``reduce_scatter``).
+* Run sharded computation for the parallelized layers to save compute/memory (for example, ``nn.Linear``, ``nn.Embedding``).
+
+
+When and Why you should apply Tensor Parallel
+---------------------------------------------
+The PyTorch Fully Sharded Data Parallel (FSDP) already has the capability to scale model training to a specific
+number of GPUs. However, when it comes to further scale the model training in terms of model size and GPU quantity,
+many additional challenges arise that may require combining Tensor Parallel with FSDP.:
+
+1. As the world size (number of GPUs) is becoming excessively large (exceeding 128/256 GPUs), the FSDP collectives (such as ``allgather``) are being dominated by ring latency.
+   By implementing TP/SP on top of FSDP, the FSDP world size could be reduced by 8 by applying FSDP to be inter-host only, consequently decreasing the latency costs by the same amount.
+2. Hit data parallelism limit where you can not raise the global batch size to be above the number of GPUs due to both convergence and GPU memory limitations, Tensor/Sequence Parallel
+   is the only known way to “ballpark” the global batch size and continue scaling with more GPUs. This means both model size and number of GPUs could continue to scale.
+3. For certain types of models, when local batch size becomes smaller, TP/SP can yield matrix multiplication shapes that are more optimized for floating point operations (FLOPS).
+
+So, when pre-training, how easy is it to hit those limits? As of now, pre-training a Large Language Model (LLM) with billions or trillions of tokens could take months, even when using thousands of GPUs.
+
+* It will always hit limitation 1 when training LLM on a large scale. For example, Llama 2 70B trained with 2k GPUs for 35 days, multi-dimensional parallelisms are needed at 2k scale.
+* When the Transformer model becomes larger (such as Llama2 70B), it will also quickly hit the limitation 2. One could not use FSDP alone with even local ``batch_size=1`` due to memory
+  and convergence constraints. For example, Llama 2 global batch size is 1K, so data parallelism alone can not be used at 2K GPUs.
+
+
+How to apply Tensor Parallel
+----------------------------
+
+PyTorch Tensor Parallel APIs offers a set of module level primitives (``ParallelStyle``) to configure the sharding for each individual layers of the model, including:
+
+* ``ColwiseParallel`` and ``RowwiseParallel``: Shard the ``nn.Linear`` and ``nn.Embedding`` in the column or row fashion.
+* ``SequenceParallel``: Perform sharded computations on ``nn.LayerNorm``, ``nn.Dropout``, ``RMSNormPython``, etc.
+* ``PrepareModuleInput`` and ``PrepareModuleOutput``: Configure the module inputs/outputs sharding layouts with proper communication operations.
+
+To demonstrate how to use the PyTorch native Tensor Parallel APIs, let us look at a common Transformer model. In this tutorial, we use the most recent `Llama2 model <https://github.com/pytorch/examples/blob/main/distributed/tensor_parallelism/llama2_model.py>`__ as a reference Transformer model implementation, as it is also widely used in the community.
+
+Since Tensor Parallel shard individual tensors over a set of devices, we would need to set up the distributed environment (such as NCCL communicators) first.
+Tensor Parallelism is a Single-Program Multiple-Data (SPMD) sharding algorithm similar to PyTorch DDP/FSDP, and it under the hood leverages the PyTorch DTensor
+to perform sharding. It also utilizes the DeviceMesh abstraction (which under the hood manages ProcessGroups) for device management and sharding.
+To see how to utilize DeviceMesh to set up multi-dimensional parallelisms, please refer to `this tutorial <https://pytorch.org/tutorials/recipes/distributed_device_mesh.html>`__. Tensor Parallel usually works within each host, so let us first initialize a DeviceMesh that connects 8 GPUs within a host.
+
+.. code-block:: python
+
+    from torch.distributed.device_mesh import init_device_mesh
+
+    tp_mesh = init_device_mesh("cuda", (8,))
+
+
+Now that we have initialized DeviceMesh, let us take a detailed look at the Llama 2 model architecture and see how we should perform the Tensor Parallel sharding.
+Here we focus on the core ``TransformerBlock``, where the Transformer model stacks the identical ``TransformerBlock`` s to scale up the model.
+
+The core ``TransformerBlock`` consists of an ``Attention`` layer and a ``FeedForward`` layer. Let us first look at the simpler ``FeedForward`` layer.
+For the ``FeedForward`` Layer it consists of three Linear layers, where it performs a SwiGLU style MLP, looking at its forward function:
+
+.. code-block:: python
+
+    # forward in the FeedForward layer
+    def forward(self, x):
+        return self.w2(F.silu(self.w1(x)) * self.w3(x))
+
+
+It performs ``w1`` and ``w3`` matmuls concurrently and followed by a ``w2`` matmul with the result of the combined w1/w3 linear projection results. This means we could
+use the idea from the Tensor Parallelism paper to shard the w1/w3 Linear layers in the colwise fashion and shard the ``w2`` Linear layer in the rowwise fashion, so that
+there is only one ``allreduce`` communication happening at the end of all the three layers. With the PyTorch native Tensor Parallel, we can simply create a ``parallelize_plan`` for the ``FeedForward`` layer like below:
+
+.. code-block:: python
+
+    from torch.distributed.tensor.parallel import ColwiseParallel, RowwiseParallel, parallelize_module
+
+    layer_tp_plan = {
+        # by default ColwiseParallel input layouts is replicated
+        # and RowwiseParallel output layouts is replicated
+        "feed_foward.w1": ColwiseParallel(),
+        "feed_forward.w2": RowwiseParallel(),
+        "feed_forward.w3": ColwiseParallel(),
+    }
+
+
+That's simply how we configure the shardings for the ``FeedForward`` layer using the PyTorch Tensor Parallel APIs. Note that users would only need to specify how to shard the individual layers and the communications (for example, ``allreduce``) will happen under the hood.
+
+Moving on to the ``Attention`` Layer. It consists of ``wq``, ``wk``, ``wv`` Linear layers to project input to ``q``/ ``k`` / ``v``, and then it performs attention and output projection with the ``wo`` Linear layer. Tensor Parallelism here intends to perform column-wise sharding for the
+q/k/v projection and row-wise sharding for the ``wo`` linear projection. So we can add the Attention plan to the ``tp_plan`` that we just drafted up:
+
+.. code-block:: python
+
+    layer_tp_plan = {
+        # by default ColwiseParallel input layouts is replicated
+        # and RowwiseParallel output layouts is replicated
+        "attention.wq": ColwiseParallel(use_local_output=False),
+        "attention.wk": ColwiseParallel(use_local_output=False),
+        "attention.wv": ColwiseParallel(use_local_output=False),
+        "attention.wo": RowwiseParallel(),
+        "feed_forward.w1": ColwiseParallel(),
+        "feed_forward.w2": RowwiseParallel(),
+        "feed_forward.w3": ColwiseParallel(),
+    }
+
+
+This is almost the ``layer_tp_plan`` we need to apply Tensor Parallelism to the ``TransformerBlock``. However, one thing we should be aware is that when sharding the linear layer column-wise, the output of the linear layers would become sharded on the last tensor dimension, and the row-wise sharding linear layer directly accepts an input that shards on the last dimension.
+If there are any more tensor operations (such as view operations) between the column-wise linear and the row-wise linear, we would need to adjust the relevant shape related ops to sharded shape.
+
+For the Llama model, in the attention layer, there are several view operations related to shape. Specifically, for column-wise parallelism in the ``wq``/``wk``/``wv`` linear layers, the activation tensor is sharded on the ``num_heads`` dimension. To manage the difference between global and local ``num_heads``, we should set ``use_local_output=False`` to ensure the output is a DTensor. Unlike a regular tensor, a DTensor is aware of the parallelism plans and will automatically handle changes in the ``num_heads`` dimension.
+
+Finally, we need to call ``parallelize_module`` API to make the plan for each ``TransformerBlock`` effective. Under the hood, it distributes the model parameters inside ``Attention`` and ``FeedForward`` layers to DTensors, and registers communication hooks for model inputs and outputs (before and after each module respectively), if necessary:
+
+.. code-block:: python
+
+    for layer_id, transformer_block in enumerate(model.layers):
+        layer_tp_plan = {...}  # i.e. the plan we just generated
+
+        parallelize_module(
+            module=transformer_block,
+            device_mesh=tp_mesh,
+            parallelize_plan=layer_tp_plan,
+        )
+
+Now that we have elaborated the sharding plan for each ``TransformerBlock``, there is usually a ``nn.Embedding`` in the first layer and a final ``nn.Linear`` projection layer, where user could choose row-wise or column-wise sharding to the first ``nn.Embedding`` and column-wise sharding to the last ``nn.Linear`` projection layer with proper input and output layouts specified.
+Here is an example:
+
+.. code-block:: python
+
+    model = parallelize_module(
+        model,
+        tp_mesh,
+        {
+            "tok_embeddings": RowwiseParallel(
+                input_layouts=Replicate(),
+            ),
+            "output": ColwiseParallel(
+                output_layouts=Replicate(),
+            ),
+        }
+    )
+
+.. note::
+	If the model to be partitioned is too large to fit into CPU memory, one could either use ``meta`` device initialization (for example, initialize the model on meta device first, shard the layers, and the materialize the model), or parallelize the ``TransformerBlock`` layer by layer during the Transformer model initialization.
+
+Apply Sequence Parallel to ``LayerNorm/RMSNorm`` layers
+-------------------------------------------------------
+
+Sequence Parallel works on top of the Tensor Parallel illustrated above. Compared with basic Tensor Parallel, which only shards tensors within the ``Attention`` modules and ``FeedForward`` modules and keep their module inputs and outputs (namely activations in the forward pass and gradients in the backward pass) replicated, Sequence Parallel keeps them sharded on the sequence dimension.
+
+In a typical ``TransformerBlock``, the forward function combines norm layers (``LayerNorm`` or ``RMSNorm``), an attention layer, a feed forward layer, and residual connections. For example:
+
+.. code-block:: python
+
+    # forward in a TransformerBlock
+    def forward(self, x):
+        h = x + self.attention(self.attention_norm(x))
+        out = h + self.feed_forward(self.ffn_norm(h))
+        return out
+
+In most use cases, the activations (and gradients) are of the shape ``[batch size, sequence length, hidden dimension]`` outside the ``Attention`` and ``FeedForward`` modules. In the DTensor’s language, Sequence Parallel performs activation computation using the ``Shard(1)`` layout for both forward/backward of the module.
+Following the code example earlier, the code below demonstrates how we apply Sequence Parallel to the norm layers within a ``TransformerBlock``:
+
+First let's import the required dependencies for Sequence Parallel:
+
+.. code-block:: python
+
+    from torch.distributed.tensor.parallel import (
+        PrepareModuleInput,
+        SequenceParallel,
+    )
+
+
+Next let's adjust the ``layer_tp_plan`` to enable sequence parallel on the ``RMSNorm`` layers:
+
+.. code-block:: python
+
+    layer_tp_plan = {
+        # Now the input and output of SequenceParallel has Shard(1) layouts,
+        # to represent the input/output tensors sharded on the sequence dimension
+        "attention_norm": SequenceParallel(),
+        "attention": PrepareModuleInput(
+            input_layouts=(Shard(1), Replicate()),
+            desired_input_layouts=(Replicate(), Replicate()),
+        ),
+        "attention.wq": ColwiseParallel(use_local_output=False),
+        "attention.wk": ColwiseParallel(use_local_output=False),
+        "attention.wv": ColwiseParallel(use_local_output=False),
+        "attention.wo": RowwiseParallel(output_layouts=Shard(1)),
+        "ffn_norm": SequenceParallel(),
+        "feed_forward": PrepareModuleInput(
+            input_layouts=(Shard(1),),
+            desired_input_layouts=(Replicate(),),
+        ),
+        "feed_forward.w1": ColwiseParallel(),
+        "feed_forward.w2": RowwiseParallel(output_layouts=Shard(1)),
+        "feed_forward.w3": ColwiseParallel(),
+    }
+
+
+One can see we now use ``PrepareModuleInput`` to modify the module input layouts to the Attention and FeedForward layers from ``Shard(1)`` to ``Replicate()``, and mark their output layouts as ``Shard(1)``.
+Just like what happens to Tensor Parallelism, one only needs to specify the tensor sharding layouts of the inputs and outputs, and the communication between layers will happen automatically.
+
+Note that with Sequence Parallel, we assume the inputs and outputs of a ``TransformerBlock`` are always sharded on the sequence dimension, so that multiple ``TransformerBlocks`` can be concatenated seamlessly.
+This can be facilitated by explicitly specifying the output of the beginning ``nn.Embedding`` layer and the input of the final ``nn.Linear`` projection layer to be ``Shard(1)``:
+
+.. code-block:: python
+
+    model = parallelize_module(
+        model,
+        tp_mesh,
+        {
+            "tok_embeddings": RowwiseParallel(
+                input_layouts=Replicate(),
+                output_layouts=Shard(1),
+            ),
+            "norm": SequenceParallel(),
+            "output": ColwiseParallel(
+                input_layouts=Shard(1),
+                output_layouts=Replicate()
+            ),
+        }
+    )
+
+
+Apply Loss Parallel
+-------------------
+
+Loss Parallel is a related technique to save memory and communication when the loss function is computed, as model outputs are usually very large. In Loss Parallel, when the model outputs are sharded on the (often huge) vocabulary dimension, the cross-entropy loss can be computed efficiently, without gathering all the model outputs to every single GPU. This not only significantly reduces the memory consumption, but also improves training speed by reducing communication overhead and doing sharded computation in parallel. The picture below briefly illustrates how Loss Parallel avoids gathering all model outputs to every GPU by doing sharded computation.
+
+.. figure:: /_static/img/distributed/loss_parallel.png
+   :width: 100%
+   :align: center
+   :alt: loss parallel
+
+   Figure 2. Cross-entropy loss forward computation with loss parallel on one GPU. Blue represents sharded tensors; green represents replicated tensors; yellow represents tensors with partial values (to be all-reduced). Black arrows are local computations; red arrows are functional collectives among GPUs.
+
+In the PyTorch Tensor Parallel API, Loss Parallel can be enabled via a context manager ``loss_parallel``, with which one can directly use ``torch.nn.functional.cross_entropy`` or ``torch.nn.CrossEntropyLoss`` without modifying other parts of their code.
+
+To apply Loss Parallel, the model predictions, usually of the shape ``[batch size, sequence length, vocabulary size]``, should be sharded on the vocabulary dimension. This can be easily done via marking the output layouts of the last linear projection layer output:
+
+.. code-block:: python
+
+    model = parallelize_module(
+        model,
+        tp_mesh,
+        {
+            "tok_embeddings": RowwiseParallel(
+                input_layouts=Replicate(),
+                output_layouts=Shard(1),
+            ),
+            "norm": SequenceParallel(),
+            "output": ColwiseParallel(
+                input_layouts=Shard(1),
+                # use DTensor as the output
+                use_local_output=False,
+            ),
+        },
+    )
+
+In the code above, we also apply Sequence Parallel to the norm layer before output. We apply ``use_local_output=False`` to let the output stay as a DTensor, to work with the ``loss_parallel`` context manager. After that, one can simply call the cross_entropy loss function as is shown below. Note that the backward computation also needs to happen within the context.
+
+.. code-block:: python
+
+    import torch.nn.functional as F
+    from torch.distributed.tensor.parallel import loss_parallel
+
+    pred = model(input_ids)
+    with loss_parallel():
+        # assuming pred and labels are of the shape [batch, seq, vocab]
+        loss = F.cross_entropy(pred.flatten(0, 1), labels.flatten(0, 1))
+        loss.backward()
+
+
+Combine Tensor Parallel with Fully Sharded Data Parallel together
+-----------------------------------------------------------------
+
+
+Now that we have shown how to apply Tensor/Sequence Parallel to the model, let us also take a look at how Tensor Parallel and Fully Sharded Data Parallel could work together.
+Since Tensor Parallelism incurs communications that block the computation, we want to make sure it runs within a fast communication channel, such as NVLink.
+In practice, we usually apply Tensor Parallel within each host, and apply Fully Sharded Data Parallel across the hosts.
+
+.. figure:: /_static/img/distributed/fsdp_tp.png
+   :width: 100%
+   :align: center
+   :alt: fsdp + tp
+
+   Figure 3. FSDP and TP work on separate device dimensions, FSDP communication happens inter-host and TP communication happens intra-host.
+
+
+This 2-D parallelism pattern can be easily expressed via a 2-D DeviceMesh, and we just need pass each “sub” DeviceMesh to each individual parallelism APIs:
+
+.. code-block:: python
+
+    from torch.distributed.device_mesh import init_device_mesh
+    from torch.distributed.tensor.parallel import ColwiseParallel, RowwiseParallel, parallelize_module
+    from torch.distributed.fsdp import fully_shard
+
+    # i.e. 2-D mesh is [dp, tp], training on 64 GPUs that performs 8 way DP and 8 way TP
+    mesh_2d = init_device_mesh("cuda", (8, 8))
+    tp_mesh = mesh_2d["tp"] # a submesh that connects intra-host devices
+    dp_mesh = mesh_2d["dp"] # a submesh that connects inter-host devices
+
+    model = Model(...)
+
+    tp_plan = {...}
+
+    # apply Tensor Parallel intra-host on tp_mesh
+    model_tp = parallelize_module(model, tp_mesh, tp_plan)
+    # apply FSDP inter-host on dp_mesh
+    model_2d = fully_shard(model_tp, mesh=dp_mesh, ...)
+
+
+This would allow us to easily apply Tensor Parallel within each host (intra-host) and apply FSDP across hosts (inter-hosts), with **0-code changes** to the Llama model.
+The Tensor(Model) Parallel and Data Parallel techniques combined together provides the ability to continue increasing model size and training efficiently using a large number of GPUs.
+
+Conclusion
+----------
+This tutorial demonstrates how to train a large Transformer-like model across hundreds to thousands of GPUs using Tensor Parallel in combination with Fully Sharded Data Parallel.
+It explains how to apply Tensor Parallel to different parts of the model, with **no code changes** to the model itself. Tensor Parallel is a efficient model parallelism technique for large scale training.
+
+To see the complete end-to-end code example explained in this tutorial, please refer to the `Tensor Parallel examples <https://github.com/pytorch/examples/blob/main/distributed/tensor_parallelism/fsdp_tp_example.py>`__ in the pytorch/examples repository.
diff --git a/intermediate_source/_torch_export_nightly_tutorial.py b/intermediate_source/_torch_export_nightly_tutorial.py
new file mode 100644
index 00000000000..fdbe18392e5
--- /dev/null
+++ b/intermediate_source/_torch_export_nightly_tutorial.py
@@ -0,0 +1,635 @@
+# -*- coding: utf-8 -*-
+
+"""
+torch.export Nightly Tutorial
+================
+**Author:** William Wen, Zhengxu Chen, Angela Yi
+"""
+
+######################################################################
+#
+# .. warning::
+#
+#     ``torch.export`` and its related features are in prototype status and are subject to backwards compatibility
+#     breaking changes. This tutorial provides a snapshot of ``torch.export`` usage as of PyTorch 2.1.
+#
+# :func:`torch.export` is the PyTorch 2.X way to export PyTorch models into
+# standardized model representations, intended
+# to be run on different (i.e. Python-less) environments.
+#
+# In this tutorial, you will learn how to use :func:`torch.export` to extract
+# ``ExportedProgram``'s (i.e. single-graph representations) from PyTorch programs.
+# We also detail some considerations/modifications that you may need
+# to make in order to make your model compatible with ``torch.export``.
+#
+# **Contents**
+#
+# .. contents::
+#     :local:
+
+######################################################################
+# Basic Usage
+# -----------
+#
+# ``torch.export`` extracts single-graph representations from PyTorch programs
+# by tracing the target function, given example inputs.
+# ``torch.export.export()`` is the main entry point for ``torch.export``.
+#
+# In this tutorial, ``torch.export`` and ``torch.export.export()`` are practically synonymous,
+# though ``torch.export`` generally refers to the PyTorch 2.X export process, and ``torch.export.export()``
+# generally refers to the actual function call.
+#
+# The signature of ``torch.export.export()`` is:
+#
+# .. code:: python
+#
+#     export(
+#         f: Callable,
+#         args: Tuple[Any, ...],
+#         kwargs: Optional[Dict[str, Any]] = None,
+#         *,
+#         dynamic_shapes: Optional[Dict[str, Dict[int, Dim]]] = None
+#     ) -> ExportedProgram
+#
+# ``torch.export.export()`` traces the tensor computation graph from calling ``f(*args, **kwargs)``
+# and wraps it in an ``ExportedProgram``, which can be serialized or executed later with
+# different inputs. Note that while the output ``ExportedGraph`` is callable and can be
+# called in the same way as the original input callable, it is not a ``torch.nn.Module``.
+# We will detail the ``dynamic_shapes`` argument later in the tutorial.
+
+import torch
+from torch.export import export
+
+class MyModule(torch.nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.lin = torch.nn.Linear(100, 10)
+
+    def forward(self, x, y):
+        return torch.nn.functional.relu(self.lin(x + y), inplace=True)
+
+mod = MyModule()
+exported_mod = export(mod, (torch.randn(8, 100), torch.randn(8, 100)))
+print(type(exported_mod))
+print(exported_mod(torch.randn(8, 100), torch.randn(8, 100)))
+
+######################################################################
+# Let's review some attributes of ``ExportedProgram`` that are of interest.
+#
+# The ``graph`` attribute is an `FX graph <https://pytorch.org/docs/stable/fx.html#torch.fx.Graph>`__
+# traced from the function we exported, that is, the computation graph of all PyTorch operations.
+# The FX graph has some important properties:
+#
+# - The operations are "ATen-level" operations.
+# - The graph is "functionalized", meaning that no operations are mutations.
+#
+# The ``graph_module`` attribute is the ``GraphModule`` that wraps the ``graph`` attribute
+# so that it can be ran as a ``torch.nn.Module``.
+
+print(exported_mod)
+print(exported_mod.graph_module)
+
+######################################################################
+# The printed code shows that FX graph only contains ATen-level ops (such as ``torch.ops.aten``)
+# and that mutations were removed. For example, the mutating op ``torch.nn.functional.relu(..., inplace=True)``
+# is represented in the printed code by ``torch.ops.aten.relu.default``, which does not mutate.
+# Future uses of input to the original mutating ``relu`` op are replaced by the additional new output
+# of the replacement non-mutating ``relu`` op.
+#
+# Other attributes of interest in ``ExportedProgram`` include:
+#
+# - ``graph_signature`` -- the inputs, outputs, parameters, buffers, etc. of the exported graph.
+# - ``range_constraints`` and ``equality_constraints`` -- constraints, covered later
+
+print(exported_mod.graph_signature)
+
+######################################################################
+# See the ``torch.export`` `documentation <https://pytorch.org/docs/main/export.html#torch.export.export>`__
+# for more details.
+
+######################################################################
+# Graph Breaks
+# ------------
+#
+# Although ``torch.export`` shares components with ``torch.compile``,
+# the key limitation of ``torch.export``, especially when compared to ``torch.compile``, is that it does not
+# support graph breaks. This is because handling graph breaks involves interpreting
+# the unsupported operation with default Python evaluation, which is incompatible
+# with the export use case. Therefore, in order to make your model code compatible
+# with ``torch.export``, you will need to modify your code to remove graph breaks.
+#
+# A graph break is necessary in cases such as:
+#
+# - data-dependent control flow
+
+def bad1(x):
+    if x.sum() > 0:
+        return torch.sin(x)
+    return torch.cos(x)
+
+import traceback as tb
+try:
+    export(bad1, (torch.randn(3, 3),))
+except Exception:
+    tb.print_exc()
+
+######################################################################
+# - accessing tensor data with ``.data``
+
+def bad2(x):
+    x.data[0, 0] = 3
+    return x
+
+try:
+    export(bad2, (torch.randn(3, 3),))
+except Exception:
+    tb.print_exc()
+
+######################################################################
+# - calling unsupported functions (such as many built-in functions)
+
+def bad3(x):
+    x = x + 1
+    return x + id(x)
+
+try:
+    export(bad3, (torch.randn(3, 3),))
+except Exception:
+    tb.print_exc()
+
+######################################################################
+# - unsupported Python language features (e.g. throwing exceptions, match statements)
+
+def bad4(x):
+    try:
+        x = x + 1
+        raise RuntimeError("bad")
+    except:
+        x = x + 2
+    return x
+
+try:
+    export(bad4, (torch.randn(3, 3),))
+except Exception:
+    tb.print_exc()
+
+######################################################################
+# The sections below demonstrate some ways you can modify your code
+# in order to remove graph breaks.
+
+######################################################################
+# Control Flow Ops
+# ----------------
+#
+# ``torch.export`` actually does support data-dependent control flow.
+# But these need to be expressed using control flow ops. For example,
+# we can fix the control flow example above using the ``cond`` op, like so:
+
+from functorch.experimental.control_flow import cond
+
+def bad1_fixed(x):
+    def true_fn(x):
+        return torch.sin(x)
+    def false_fn(x):
+        return torch.cos(x)
+    return cond(x.sum() > 0, true_fn, false_fn, [x])
+
+exported_bad1_fixed = export(bad1_fixed, (torch.randn(3, 3),))
+print(exported_bad1_fixed(torch.ones(3, 3)))
+print(exported_bad1_fixed(-torch.ones(3, 3)))
+
+######################################################################
+# There are limitations to ``cond`` that one should be aware of:
+#
+# - The predicate (i.e. ``x.sum() > 0``) must result in a boolean or a single-element tensor.
+# - The operands (i.e. ``[x]``) must be tensors.
+# - The branch function (i.e. ``true_fn`` and ``false_fn``) signature must match with the
+#   operands and they must both return a single tensor with the same metadata (for example, ``dtype``, ``shape``, etc.).
+# - Branch functions cannot mutate input or global variables.
+# - Branch functions cannot access closure variables, except for ``self`` if the function is
+#   defined in the scope of a method.
+#
+# For more details about ``cond``, check out the `documentation <https://pytorch.org/docs/main/cond.html>`__.
+
+######################################################################
+# ..
+#     [NOTE] map is not documented at the moment
+#     We can also use ``map``, which applies a function across the first dimension
+#     of the first tensor argument.
+#
+#     from functorch.experimental.control_flow import map
+#
+#     def map_example(xs):
+#         def map_fn(x, const):
+#             def true_fn(x):
+#                 return x + const
+#             def false_fn(x):
+#                 return x - const
+#             return control_flow.cond(x.sum() > 0, true_fn, false_fn, [x])
+#         return control_flow.map(map_fn, xs, torch.tensor([2.0]))
+#
+#     exported_map_example= export(map_example, (torch.randn(4, 3),))
+#     inp = torch.cat((torch.ones(2, 3), -torch.ones(2, 3)))
+#     print(exported_map_example(inp))
+
+######################################################################
+# Constraints/Dynamic Shapes
+# --------------------------
+#
+# Ops can have different specializations/behaviors for different tensor shapes, so by default,
+# ``torch.export`` requires inputs to ``ExportedProgram`` to have the same shape as the respective
+# example inputs given to the initial ``torch.export.export()`` call.
+# If we try to run the ``ExportedProgram`` in the example below with a tensor
+# with a different shape, we get an error:
+
+class MyModule2(torch.nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.lin = torch.nn.Linear(100, 10)
+
+    def forward(self, x, y):
+        return torch.nn.functional.relu(self.lin(x + y), inplace=True)
+
+mod2 = MyModule2()
+exported_mod2 = export(mod2, (torch.randn(8, 100), torch.randn(8, 100)))
+
+try:
+    exported_mod2(torch.randn(10, 100), torch.randn(10, 100))
+except Exception:
+    tb.print_exc()
+
+######################################################################
+# We can relax this constraint using the ``dynamic_shapes`` argument of
+# ``torch.export.export()``, which allows us to specify, using ``torch.export.Dim``
+# (`documentation <https://pytorch.org/docs/main/export.html#torch.export.Dim>`__),
+# which dimensions of the input tensors are dynamic.
+#
+# For each tensor argument of the input callable, we can specify a mapping from the dimension
+# to a ``torch.export.Dim``.
+# A ``torch.export.Dim`` is essentially a named symbolic integer with optional
+# minimum and maximum bounds.
+#
+# Then, the format of ``torch.export.export()``'s ``dynamic_shapes`` argument is a mapping
+# from the input callable's tensor argument names, to dimension --> dim mappings as described above.
+# If there is no ``torch.export.Dim`` given to a tensor argument's dimension, then that dimension is
+# assumed to be static.
+#
+# The first argument of ``torch.export.Dim`` is the name for the symbolic integer, used for debugging.
+# Then we can specify an optional minimum and maximum bound (inclusive). Below, we show example usage.
+#
+# In the example below, our input
+# ``inp1`` has an unconstrained first dimension, but the size of the second
+# dimension must be in the interval [4, 18].
+
+from torch.export import Dim
+
+inp1 = torch.randn(10, 10, 2)
+
+def dynamic_shapes_example1(x):
+    x = x[:, 2:]
+    return torch.relu(x)
+
+inp1_dim0 = Dim("inp1_dim0")
+inp1_dim1 = Dim("inp1_dim1", min=4, max=18)
+dynamic_shapes1 = {
+    "x": {0: inp1_dim0, 1: inp1_dim1},
+}
+
+exported_dynamic_shapes_example1 = export(dynamic_shapes_example1, (inp1,), dynamic_shapes=dynamic_shapes1)
+
+print(exported_dynamic_shapes_example1(torch.randn(5, 5, 2)))
+
+try:
+    exported_dynamic_shapes_example1(torch.randn(8, 1, 2))
+except Exception:
+    tb.print_exc()
+
+try:
+    exported_dynamic_shapes_example1(torch.randn(8, 20, 2))
+except Exception:
+    tb.print_exc()
+
+try:
+    exported_dynamic_shapes_example1(torch.randn(8, 8, 3))
+except Exception:
+    tb.print_exc()
+
+######################################################################
+# Note that if our example inputs to ``torch.export`` do not satisfy the constraints
+# given by ``dynamic_shapes``, then we get an error.
+
+inp1_dim1_bad = Dim("inp1_dim1_bad", min=11, max=18)
+dynamic_shapes1_bad = {
+    "x": {0: inp1_dim0, 1: inp1_dim1_bad},
+}
+
+try:
+    export(dynamic_shapes_example1, (inp1,), dynamic_shapes=dynamic_shapes1_bad)
+except Exception:
+    tb.print_exc()
+
+######################################################################
+# We can enforce that equalities between dimensions of different tensors
+# by using the same ``torch.export.Dim`` object, for example, in matrix multiplication:
+
+inp2 = torch.randn(4, 8)
+inp3 = torch.randn(8, 2)
+
+def dynamic_shapes_example2(x, y):
+    return x @ y
+
+inp2_dim0 = Dim("inp2_dim0")
+inner_dim = Dim("inner_dim")
+inp3_dim1 = Dim("inp3_dim1")
+
+dynamic_shapes2 = {
+    "x": {0: inp2_dim0, 1: inner_dim},
+    "y": {0: inner_dim, 1: inp3_dim1},
+}
+
+exported_dynamic_shapes_example2 = export(dynamic_shapes_example2, (inp2, inp3), dynamic_shapes=dynamic_shapes2)
+
+print(exported_dynamic_shapes_example2(torch.randn(2, 16), torch.randn(16, 4)))
+
+try:
+    exported_dynamic_shapes_example2(torch.randn(4, 8), torch.randn(4, 2))
+except Exception:
+    tb.print_exc()
+
+######################################################################
+# We can actually use ``torch.export`` to guide us as to which ``dynamic_shapes`` constraints
+# are necessary. We can do this by relaxing all constraints (recall that if we
+# do not provide constraints for a dimension, the default behavior is to constrain
+# to the exact shape value of the example input) and letting ``torch.export``
+# error out.
+
+inp4 = torch.randn(8, 16)
+inp5 = torch.randn(16, 32)
+
+def dynamic_shapes_example3(x, y):
+    if x.shape[0] <= 16:
+        return x @ y[:, :16]
+    return y
+
+dynamic_shapes3 = {
+    "x": {i: Dim(f"inp4_dim{i}") for i in range(inp4.dim())},
+    "y": {i: Dim(f"inp5_dim{i}") for i in range(inp5.dim())},
+}
+
+try:
+    export(dynamic_shapes_example3, (inp4, inp5), dynamic_shapes=dynamic_shapes3)
+except Exception:
+    tb.print_exc()
+
+######################################################################
+# We can see that the error message gives us suggested fixes to our
+# dynamic shape constraints. Let us follow those suggestions (exact
+# suggestions may differ slightly):
+
+def suggested_fixes():
+    inp4_dim1 = Dim('shared_dim')
+    # suggested fixes below
+    inp4_dim0 = Dim('inp4_dim0', max=16)
+    inp5_dim1 = Dim('inp5_dim1', min=17)
+    inp5_dim0 = inp4_dim1
+    # end of suggested fixes
+    return {
+        "x": {0: inp4_dim0, 1: inp4_dim1},
+        "y": {0: inp5_dim0, 1: inp5_dim1},
+    }
+
+dynamic_shapes3_fixed = suggested_fixes()
+exported_dynamic_shapes_example3 = export(dynamic_shapes_example3, (inp4, inp5), dynamic_shapes=dynamic_shapes3_fixed)
+print(exported_dynamic_shapes_example3(torch.randn(4, 32), torch.randn(32, 64)))
+
+######################################################################
+# Note that in the example above, because we constrained the value of ``x.shape[0]`` in
+# ``dynamic_shapes_example3``, the exported program is sound even though there is a
+# raw ``if`` statement.
+#
+# If you want to see why ``torch.export`` generated these constraints, you can
+# re-run the script with the environment variable ``TORCH_LOGS=dynamic,dynamo``,
+# or use ``torch._logging.set_logs``.
+
+import logging
+torch._logging.set_logs(dynamic=logging.INFO, dynamo=logging.INFO)
+exported_dynamic_shapes_example3 = export(dynamic_shapes_example3, (inp4, inp5), dynamic_shapes=dynamic_shapes3_fixed)
+
+# reset to previous values
+torch._logging.set_logs(dynamic=logging.WARNING, dynamo=logging.WARNING)
+
+######################################################################
+# We can view an ``ExportedProgram``'s constraints using the ``range_constraints`` and
+# ``equality_constraints`` attributes. The logging above reveals what the symbols ``s0, s1, ...``
+# represent.
+
+print(exported_dynamic_shapes_example3.range_constraints)
+print(exported_dynamic_shapes_example3.equality_constraints)
+
+######################################################################
+# Custom Ops
+# ----------
+#
+# ``torch.export`` can export PyTorch programs with custom operators.
+#
+#
+# Currently, the steps to register a custom op for use by ``torch.export`` are:
+#
+# - If you’re writing custom ops purely in Python, use torch.library.custom_op.
+
+import torch.library
+import numpy as np
+
+@torch.library.custom_op("mylib::sin", mutates_args=())
+def sin(x):
+    x_np = x.numpy()
+    y_np = np.sin(x_np)
+    return torch.from_numpy(y_np)
+
+######################################################################
+# - You will need to provide abstract implementation so that PT2 can trace through it.
+
+@torch.library.register_fake("mylib::sin")
+def _(x):
+    return torch.empty_like(x)
+
+# - Sometimes, the custom op you are exporting has data-dependent output, meaning
+# we can't determine the shape of the output at compile time. In this case, you can do
+# following:
+@torch.library.custom_op("mylib::nonzero", mutates_args=())
+def nonzero(x):
+    x_np = x.cpu().numpy()
+    res = np.stack(np.nonzero(x_np), axis=1)
+    return torch.tensor(res, device=x.device)
+
+@torch.library.register_fake("mylib::nonzero")
+def _(x):
+    # The number of nonzero-elements is data-dependent.
+    # Since we cannot peek at the data in an abstract implementation,
+    # we use the `ctx` object to construct a new ``symint`` that
+    # represents the data-dependent size.
+    ctx = torch.library.get_ctx()
+    nnz = ctx.new_dynamic_size()
+    shape = [nnz, x.dim()]
+    result = x.new_empty(shape, dtype=torch.int64)
+    return result
+
+######################################################################
+# - Call the custom op from the code you want to export using ``torch.ops``
+
+def custom_op_example(x):
+    x = torch.sin(x)
+    x = torch.ops.mylib.sin(x)
+    x = torch.cos(x)
+    y = torch.ops.mylib.nonzero(x)
+    return x + y.sum()
+
+######################################################################
+# - Export the code as before
+
+exported_custom_op_example = export(custom_op_example, (torch.randn(3, 3),))
+exported_custom_op_example.graph_module.print_readable()
+print(exported_custom_op_example(torch.randn(3, 3)))
+
+######################################################################
+# Note in the above outputs that the custom op is included in the exported graph.
+# And when we call the exported graph as a function, the original custom op is called,
+# as evidenced by the ``print`` call.
+#
+# If you have a custom operator implemented in C++, please refer to
+# `this document <https://docs.google.com/document/d/1_W62p8WJOQQUzPsJYa7s701JXt0qf2OfLub2sbkHOaU/edit#heading=h.ahugy69p2jmz>`__
+# to make it compatible with ``torch.export``.
+
+######################################################################
+# Decompositions
+# --------------
+#
+# The graph produced by ``torch.export`` by default returns a graph containing
+# only functional ATen operators. This functional ATen operator set (or "opset") contains around 2000
+# operators, all of which are functional, that is, they do not
+# mutate or alias inputs.  You can find a list of all ATen operators
+# `here <https://github.com/pytorch/pytorch/blob/main/aten/src/ATen/native/native_functions.yaml>`__
+# and you can inspect if an operator is functional by checking
+# ``op._schema.is_mutable``, for example:
+
+print(torch.ops.aten.add.Tensor._schema.is_mutable)
+print(torch.ops.aten.add_.Tensor._schema.is_mutable)
+
+######################################################################
+# By default, the environment in which you want to run the exported graph
+# should support all ~2000 of these operators.
+# However, you can use the following API on the exported program
+# if your specific environment is only able to support a subset of
+# the ~2000 operators.
+#
+# .. code:: python
+#
+#     def run_decompositions(
+#         self: ExportedProgram,
+#         decomposition_table: Optional[Dict[torch._ops.OperatorBase, Callable]]
+#     ) -> ExportedProgram
+#
+# ``run_decompositions`` takes in a decomposition table, which is a mapping of
+# operators to a function specifying how to reduce, or decompose, that operator
+# into an equivalent sequence of other ATen operators.
+#
+# The default decomposition table for ``run_decompositions`` is the
+# `Core ATen decomposition table <https://github.com/pytorch/pytorch/blob/b460c3089367f3fadd40aa2cb3808ee370aa61e1/torch/_decomp/__init__.py#L252>`__
+# which will decompose the all ATen operators to the
+# `Core ATen Operator Set <https://pytorch.org/docs/main/torch.compiler_ir.html#core-aten-ir>`__
+# which consists of only ~180 operators.
+
+class M(torch.nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.linear = torch.nn.Linear(3, 4)
+
+    def forward(self, x):
+        return self.linear(x)
+
+ep = export(M(), (torch.randn(2, 3),))
+print(ep.graph)
+
+core_ir_ep = ep.run_decompositions()
+print(core_ir_ep.graph)
+
+######################################################################
+# Notice that after running ``run_decompositions`` the
+# ``torch.ops.aten.t.default`` operator, which is not part of the Core ATen
+# Opset, has been replaced with ``torch.ops.aten.permute.default`` which is part
+# of the Core ATen Opset.
+
+######################################################################
+# Most ATen operators already have decompositions, which are located
+# `here <https://github.com/pytorch/pytorch/blob/b460c3089367f3fadd40aa2cb3808ee370aa61e1/torch/_decomp/decompositions.py>`__.
+# If you would like to use some of these existing decomposition functions,
+# you can pass in a list of operators you would like to decompose to the
+# `get_decompositions <https://github.com/pytorch/pytorch/blob/b460c3089367f3fadd40aa2cb3808ee370aa61e1/torch/_decomp/__init__.py#L191>`__
+# function, which will return a decomposition table using existing
+# decomposition implementations.
+
+class M(torch.nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.linear = torch.nn.Linear(3, 4)
+
+    def forward(self, x):
+        return self.linear(x)
+
+ep = export(M(), (torch.randn(2, 3),))
+print(ep.graph)
+
+from torch._decomp import get_decompositions
+decomp_table = get_decompositions([torch.ops.aten.t.default, torch.ops.aten.transpose.int])
+core_ir_ep = ep.run_decompositions(decomp_table)
+print(core_ir_ep.graph)
+
+######################################################################
+# If there is no existing decomposition function for an ATen operator that you would
+# like to decompose, feel free to send a pull request into PyTorch
+# implementing the decomposition!
+
+######################################################################
+# ExportDB
+# --------
+#
+# ``torch.export`` will only ever export a single computation graph from a PyTorch program. Because of this requirement,
+# there will be Python or PyTorch features that are not compatible with ``torch.export``, which will require users to
+# rewrite parts of their model code. We have seen examples of this earlier in the tutorial -- for example, rewriting
+# if-statements using ``cond``.
+#
+# `ExportDB <https://pytorch.org/docs/main/generated/exportdb/index.html>`__ is the standard reference that documents
+# supported and unsupported Python/PyTorch features for ``torch.export``. It is essentially a list a program samples, each
+# of which represents the usage of one particular Python/PyTorch feature and its interaction with ``torch.export``.
+# Examples are also tagged by category so that they can be more easily searched.
+#
+# For example, let's use ExportDB to get a better understanding of how the predicate works in the ``cond`` operator.
+# We can look at the example called ``cond_predicate``, which has a ``torch.cond`` tag. The example code looks like:
+
+def cond_predicate(x):
+    """
+    The conditional statement (aka predicate) passed to ``cond()`` must be one of the following:
+      - torch.Tensor with a single element
+      - boolean expression
+    NOTE: If the `pred` is test on a dim with batch size < 2, it will be specialized.
+    """
+    pred = x.dim() > 2 and x.shape[2] > 10
+    return cond(pred, lambda x: x.cos(), lambda y: y.sin(), [x])
+
+######################################################################
+# More generally, ExportDB can be used as a reference when one of the following occurs:
+#
+# 1. Before attempting ``torch.export``, you know ahead of time that your model uses some tricky Python/PyTorch features
+#    and you want to know if ``torch.export`` covers that feature.
+# 2. When attempting ``torch.export``, there is a failure and it's unclear how to work around it.
+#
+# ExportDB is not exhaustive, but is intended to cover all use cases found in typical PyTorch code. Feel free to reach
+# out if there is an important Python/PyTorch feature that should be added to ExportDB or supported by ``torch.export``.
+
+######################################################################
+# Conclusion
+# ----------
+#
+# We introduced ``torch.export``, the new PyTorch 2.X way to export single computation
+# graphs from PyTorch programs. In particular, we demonstrate several code modifications
+# and considerations (control flow ops, constraints, etc.) that need to be made in order to export a graph.
diff --git a/intermediate_source/autograd_saved_tensors_hooks_tutorial.py b/intermediate_source/autograd_saved_tensors_hooks_tutorial.py
new file mode 100644
index 00000000000..ed581426c2e
--- /dev/null
+++ b/intermediate_source/autograd_saved_tensors_hooks_tutorial.py
@@ -0,0 +1,514 @@
+"""
+Hooks for autograd saved tensors
+================================
+
+"""
+
+
+######################################################################
+# PyTorch typically computes gradients using backpropagation. However,
+# certain operations require intermediary results to be saved in order to
+# perform backpropagation. This tutorial walks through how these tensors
+# are saved/retrieved and how you can define hooks to control the
+# packing/unpacking process.
+#
+# This tutorial assumes you are familiar with how backpropagation works in
+# theory. If not, read `this <https://colab.research.google.com/drive/1aWNdmYt7RcHMbUk-Xz2Cv5-cGFSWPXe0#scrollTo=AHcEJ6nXUb7W>`_ first.
+#
+
+
+######################################################################
+# Saved tensors
+# -------------
+#
+
+
+######################################################################
+# Training a model usually consumes more memory than running it for
+# inference. Broadly speaking, one can say that it is because “PyTorch
+# needs to save the computation graph, which is needed to call
+# ``backward``”, hence the additional memory usage. One goal of this
+# tutorial is to finetune this understanding.
+#
+# In fact, the graph in itself sometimes does not consume much more memory
+# as it never copies any tensors. However, the graph can keep *references*
+# to tensors that would otherwise have gone out of scope: those are
+# referred to as **saved tensors**.
+#
+
+
+######################################################################
+# Why does training a model (typically) requires more memory than evaluating it?
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+
+
+######################################################################
+# We start with a simple example: :math:`y = a \cdot b` , for which
+# we know the gradients of :math:`y` with respect to :math:`a` and
+# :math:`b`:
+#
+# .. math::  \frac{\partial y}{\partial a} = b
+#
+# .. math::  \frac{\partial y}{\partial b} = a
+#
+
+import torch
+
+a = torch.randn(5, requires_grad=True)
+b = torch.ones(5, requires_grad=True)
+y = a * b
+
+#################################################################
+# Using a torchviz, we can visualize the computation graph
+#
+#  .. figure:: https://user-images.githubusercontent.com/8019486/130124513-72e016a3-c36f-42b9-88e2-53baf3e016c5.png
+#    :width: 300
+#    :align: center
+
+
+######################################################################
+# In this example, PyTorch saves intermediary values :math:`a` and
+# :math:`b` in order to compute the gradient during the backward.
+#
+#  .. figure:: https://user-images.githubusercontent.com/8019486/130124538-3da50977-6f0b-46d0-8909-5456ade9b598.png
+#    :width: 300
+#    :align: center
+
+
+######################################################################
+# Those intermediary values (in orange above) can be accessed (for
+# debugging purposes) by looking for attributes of the ``grad_fn`` of
+# ``y`` which start with the prefix ``_saved``:
+#
+
+print(y.grad_fn._saved_self)
+print(y.grad_fn._saved_other)
+
+
+######################################################################
+# As the computation graph grows in depth, it will store more *saved
+# tensors*. Meanwhile, those tensors would have gone out of scope if not
+# for the graph.
+#
+
+def f(x):
+    return x * x
+
+x = torch.randn(5, requires_grad=True)
+y = f(f(f(x)))
+
+######################################################################
+#  .. figure:: https://user-images.githubusercontent.com/8019486/130124570-f1074098-1bb3-459e-bf5a-03bf6f65b403.png
+#    :width: 500
+#    :align: center
+
+
+######################################################################
+# In the example above, executing without grad would only have kept ``x``
+# and ``y`` in the scope, But the graph additionally stores ``f(x)`` and
+# ``f(f(x))``. Hence, running a forward pass during training will be more
+# costly in memory usage than during evaluation (more precisely, when
+# autograd is not required).
+#
+
+
+######################################################################
+# The concept of packing / unpacking
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+
+
+######################################################################
+# Going back to the first example: ``y.grad_fn._saved_self`` and
+# ``y.grad_fn._saved_other`` point to the original tensor object,
+# respectively ``a`` and ``b``.
+#
+
+a = torch.randn(5, requires_grad=True)
+b = torch.ones(5, requires_grad=True)
+y = a * b
+
+print(y.grad_fn._saved_self is a)   # True
+print(y.grad_fn._saved_other is b)  # True
+
+
+######################################################################
+# However, that may not always be the case.
+#
+
+a = torch.randn(5, requires_grad=True)
+y = torch.exp(a)
+print(y.grad_fn._saved_result.equal(y))  # True
+print(y.grad_fn._saved_result is y)      # False
+
+
+######################################################################
+# Under the hood, PyTorch has **packed** and **unpacked** the tensor
+# ``y`` to prevent reference cycles.
+#
+# As a rule of thumb, you should *not* rely on the fact that accessing
+# the tensor saved for backward will yield the same tensor object as the
+# original tensor. They will however share the same *storage*.
+#
+
+
+######################################################################
+# Saved tensors hooks
+# -------------------
+#
+
+
+######################################################################
+# PyTorch provides an API to control how saved tensors should be packed /
+# unpacked.
+#
+
+def pack_hook(x):
+    print("Packing", x)
+    return x
+
+def unpack_hook(x):
+    print("Unpacking", x)
+    return x
+a = torch.ones(5, requires_grad=True)
+b = torch.ones(5, requires_grad=True) * 2
+
+with torch.autograd.graph.saved_tensors_hooks(pack_hook, unpack_hook):
+    y = a * b
+
+y.sum().backward()
+
+
+######################################################################
+# The ``pack_hook`` function will be called every time an operation saves
+# a tensor for backward.
+# The output of ``pack_hook`` is then stored in the computation graph
+# instead of the original tensor.
+# The ``unpack_hook`` uses that return value to compute a new tensor,
+# which is the one actually used during the backward pass.
+# In general, you want ``unpack_hook(pack_hook(t))`` to be equal to
+# ``t``.
+#
+
+x = torch.randn(5, requires_grad=True)
+with torch.autograd.graph.saved_tensors_hooks(lambda x: x * 4, lambda x: x / 4):
+    y = torch.pow(x, 2)
+y.sum().backward()
+assert(x.grad.equal(2 * x))
+
+
+######################################################################
+# One thing to note is that the output of ``pack_hook`` can be *any Python
+# object*, as long as ``unpack_hook`` can derive a tensor with the correct
+# value from it.
+#
+
+
+######################################################################
+# Some unconventional examples
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+
+
+######################################################################
+# First, some silly examples to illustrate what is possible but you
+# probably don’t ever want to do it.
+#
+
+######################################################################
+# Returning an ``int``
+# ^^^^^^^^^^^^^^^^^^^^
+#
+# Returning the index of a Python list
+# Relatively harmless but with debatable usefulness
+
+storage = []
+
+def pack(x):
+    storage.append(x)
+    return len(storage) - 1
+
+def unpack(x):
+    return storage[x]
+
+x = torch.randn(5, requires_grad=True)
+with torch.autograd.graph.saved_tensors_hooks(pack, unpack):
+    y = x * x
+y.sum().backward()
+
+assert(x.grad.equal(2 * x))
+
+######################################################################
+# Returning a tuple
+# ^^^^^^^^^^^^^^^^^
+#
+# Returning some tensor and a function how to unpack it
+# Quite unlikely to be useful in its current form
+
+def pack(x):
+    delta = torch.randn(*x.size())
+    return x - delta, lambda x: x + delta
+
+def unpack(packed):
+    x, f = packed
+    return f(x)
+
+
+x = torch.randn(5, requires_grad=True)
+with torch.autograd.graph.saved_tensors_hooks(pack, unpack):
+    y = x * x
+y.sum().backward()
+
+assert(torch.allclose(x.grad, 2 * x))
+
+######################################################################
+# Returning a ``str``
+# ^^^^^^^^^^^^^^^^^^^
+#
+# Returning the ``__repr__ of`` the tensor
+# Probably never do this
+
+x = torch.randn(5, requires_grad=True)
+with torch.autograd.graph.saved_tensors_hooks(lambda x: repr(x), lambda x: eval("torch." + x)):
+    y = x * x
+y.sum().backward()
+assert(torch.all(x.grad - 2 * x <= 1e-4))
+
+
+######################################################################
+# Although those examples will not be useful in practice, they
+# illustrate that the output of ``pack_hook`` can really be any Python
+# object as long as it contains enough information to retrieve the
+# content of the original tensor.
+# In the next sections, we focus on more useful applications.
+#
+
+
+######################################################################
+# Saving tensors to CPU
+# ~~~~~~~~~~~~~~~~~~~~~
+#
+
+
+######################################################################
+# Very often, the tensors involved in the computation graph live on GPU.
+# Keeping a reference to those tensors in the graph is what causes most
+# models to run out of GPU memory during training while they would have
+# done fine during evaluation.
+#
+# Hooks provide a very simple way to implement that.
+#
+
+def pack_hook(x):
+    return (x.device, x.cpu())
+
+def unpack_hook(packed):
+    device, tensor = packed
+    return tensor.to(device)
+
+x = torch.randn(5, requires_grad=True)
+with torch.autograd.graph.saved_tensors_hooks(pack, unpack):
+    y = x * x
+y.sum().backward()
+
+torch.allclose(x.grad, (2 * x))
+
+
+######################################################################
+# In fact, PyTorch provides an API to conveniently use those hooks (as
+# well as the ability to use pinned memory).
+#
+
+import torch.nn as nn
+
+class Model(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.w = nn.Parameter(torch.randn(5))
+
+    def forward(self, x):
+        with torch.autograd.graph.save_on_cpu(pin_memory=True):
+            # some computation
+            return self.w * x
+
+x = torch.randn(5)
+model = Model()
+loss = model(x).sum()
+loss.backward()
+
+
+######################################################################
+# In practice, on a A100 GPU, for a ResNet-152 with batch size 256, this
+# corresponds to a GPU memory usage reduction from 48GB to 5GB, at the
+# cost of a 6x slowdown.
+#
+# Of course, you can modulate the tradeoff by only saving to CPU certain
+# parts of the network.
+#
+# For instance, you could define a special ``nn.Module`` that wraps any
+# module and saves its tensors to CPU.
+#
+
+class SaveToCpu(nn.Module):
+    def __init__(self, module):
+        super().__init__()
+        self.module = module
+
+    def forward(self, *args, **kwargs):
+        with torch.autograd.graph.save_on_cpu(pin_memory=True):
+            return self.module(*args, **kwargs)
+
+model = nn.Sequential(
+    nn.Linear(10, 100),
+    SaveToCpu(nn.Linear(100, 100)),
+    nn.Linear(100, 10),
+)
+
+x = torch.randn(10)
+loss = model(x).sum()
+loss.backward()
+
+
+######################################################################
+# Saving tensors to disk
+# ~~~~~~~~~~~~~~~~~~~~~~
+#
+
+
+######################################################################
+# Similarly, you may want to save those tensors to disk. Again, this is
+# achievable with those hooks.
+#
+
+
+######################################################################
+# A naive version would look like this.
+#
+
+# Naive version - HINT: Don't do this
+
+import uuid
+tmp_dir = "temp"
+
+def pack_hook(tensor):
+    name = os.path.join(tmp_dir, str(uuid.uuid4()))
+    torch.save(tensor, name)
+    return name
+
+def unpack_hook(name):
+    return torch.load(name, weights_only=True)
+
+
+######################################################################
+# The reason the above code is bad is that we are leaking files on the
+# disk and they are never cleared. Fixing this is not as trivial as it
+# seems.
+#
+
+# Incorrect version - HINT: Don't do this
+
+import uuid
+import os
+import tempfile
+tmp_dir_obj = tempfile.TemporaryDirectory()
+tmp_dir = tmp_dir_obj.name
+
+def pack_hook(tensor):
+    name = os.path.join(tmp_dir, str(uuid.uuid4()))
+    torch.save(tensor, name)
+    return name
+
+def unpack_hook(name):
+    tensor = torch.load(name, weights_only=True)
+    os.remove(name)
+    return tensor
+
+
+######################################################################
+# The reason the above code doesn’t work is that ``unpack_hook`` can be
+# called multiple times. If we delete the file during unpacking the first
+# time, it will not be available when the saved tensor is accessed a
+# second time, which will raise an error.
+#
+
+x = torch.ones(5, requires_grad=True)
+with torch.autograd.graph.saved_tensors_hooks(pack_hook, unpack_hook):
+    y = x.pow(2)
+print(y.grad_fn._saved_self)
+try:
+    print(y.grad_fn._saved_self)
+    print("Double access succeeded!")
+except:
+    print("Double access failed!")
+
+
+######################################################################
+# To fix this, we can write a version of those hooks that takes advantage
+# of the fact that PyTorch automatically releases (deletes) the saved data
+# when it is no longer needed.
+#
+
+class SelfDeletingTempFile():
+    def __init__(self):
+        self.name = os.path.join(tmp_dir, str(uuid.uuid4()))
+
+    def __del__(self):
+        os.remove(self.name)
+
+def pack_hook(tensor):
+    temp_file = SelfDeletingTempFile()
+    torch.save(tensor, temp_file.name)
+    return temp_file
+
+def unpack_hook(temp_file):
+    return torch.load(temp_file.name, weights_only=True)
+
+
+######################################################################
+# When we call ``backward``, the output of ``pack_hook`` will be deleted,
+# which causes the file to be removed, so we’re no longer leaking the
+# files.
+#
+# This can then be used in your model, in the following way:
+#
+
+# Only save on disk tensors that have size >= 1000
+SAVE_ON_DISK_THRESHOLD = 1000
+
+def pack_hook(x):
+    if x.numel() < SAVE_ON_DISK_THRESHOLD:
+        return x
+    temp_file = SelfDeletingTempFile()
+    torch.save(tensor, temp_file.name)
+    return temp_file
+
+def unpack_hook(tensor_or_sctf):
+    if isinstance(tensor_or_sctf, torch.Tensor):
+        return tensor_or_sctf
+    return torch.load(tensor_or_sctf.name)
+
+class SaveToDisk(nn.Module):
+    def __init__(self, module):
+        super().__init__()
+        self.module = module
+
+    def forward(self, *args, **kwargs):
+        with torch.autograd.graph.saved_tensors_hooks(pack_hook, unpack_hook):
+            return self.module(*args, **kwargs)
+
+net = nn.DataParallel(SaveToDisk(Model()))
+
+
+######################################################################
+# In this last example, we also demonstrate how to filter which tensors
+# should be saved (here, those whose number of elements is greater than
+# 1000) and how to combine this feature with ``nn.DataParallel``.
+#
+
+
+######################################################################
+# If you’ve made it this far, congratulations! You now know how to use
+# saved tensor hooks and how they can be useful in a few scenarios to
+# tradeoff memory for compute.
+#
diff --git a/intermediate_source/ax_multiobjective_nas_tutorial.py b/intermediate_source/ax_multiobjective_nas_tutorial.py
new file mode 100644
index 00000000000..0f1ae21a556
--- /dev/null
+++ b/intermediate_source/ax_multiobjective_nas_tutorial.py
@@ -0,0 +1,516 @@
+# -*- coding: utf-8 -*-
+"""
+Multi-Objective NAS with Ax
+==================================================
+
+**Authors:** `David Eriksson <https://github.com/dme65>`__,
+`Max Balandat <https://github.com/Balandat>`__,
+and the Adaptive Experimentation team at Meta.
+
+In this tutorial, we show how to use `Ax <https://ax.dev/>`__ to run
+multi-objective neural architecture search (NAS) for a simple neural
+network model on the popular MNIST dataset. While the underlying
+methodology would typically be used for more complicated models and
+larger datasets, we opt for a tutorial that is easily runnable
+end-to-end on a laptop in less than 20 minutes.
+
+In many NAS applications, there is a natural tradeoff between multiple
+objectives of interest. For instance, when deploying models on-device
+we may want to maximize model performance (for example, accuracy), while
+simultaneously minimizing competing metrics like power consumption,
+inference latency, or model size in order to satisfy deployment
+constraints. Often, we may be able to reduce computational requirements
+or latency of predictions substantially by accepting minimally lower
+model performance. Principled methods for exploring such tradeoffs
+efficiently are key enablers of scalable and sustainable AI, and have
+many successful applications at Meta - see for instance our
+`case study <https://research.facebook.com/blog/2021/07/optimizing-model-accuracy-and-latency-using-bayesian-multi-objective-neural-architecture-search/>`__
+on a Natural Language Understanding model.
+
+In our example here, we will tune the widths of two hidden layers,
+the learning rate, the dropout probability, the batch size, and the
+number of training epochs. The goal is to trade off performance
+(accuracy on the validation set) and model size (the number of
+model parameters).
+
+This tutorial makes use of the following PyTorch libraries:
+
+- `PyTorch Lightning <https://github.com/PyTorchLightning/pytorch-lightning>`__ (specifying the model and training loop)
+- `TorchX <https://github.com/pytorch/torchx>`__ (for running training jobs remotely / asynchronously)
+- `BoTorch <https://github.com/pytorch/botorch>`__ (the Bayesian Optimization library powering Ax's algorithms)
+"""
+
+
+######################################################################
+# Defining the TorchX App
+# -----------------------
+#
+# Our goal is to optimize the PyTorch Lightning training job defined in
+# `mnist_train_nas.py <https://github.com/pytorch/tutorials/tree/main/intermediate_source/mnist_train_nas.py>`__.
+# To do this using TorchX, we write a helper function that takes in
+# the values of the architecture and hyperparameters of the training
+# job and creates a `TorchX AppDef <https://pytorch.org/torchx/latest/basics.html>`__
+# with the appropriate settings.
+#
+
+from pathlib import Path
+
+import torchx
+
+from torchx import specs
+from torchx.components import utils
+
+
+def trainer(
+    log_path: str,
+    hidden_size_1: int,
+    hidden_size_2: int,
+    learning_rate: float,
+    epochs: int,
+    dropout: float,
+    batch_size: int,
+    trial_idx: int = -1,
+) -> specs.AppDef:
+
+    # define the log path so we can pass it to the TorchX ``AppDef``
+    if trial_idx >= 0:
+        log_path = Path(log_path).joinpath(str(trial_idx)).absolute().as_posix()
+
+    return utils.python(
+        # command line arguments to the training script
+        "--log_path",
+        log_path,
+        "--hidden_size_1",
+        str(hidden_size_1),
+        "--hidden_size_2",
+        str(hidden_size_2),
+        "--learning_rate",
+        str(learning_rate),
+        "--epochs",
+        str(epochs),
+        "--dropout",
+        str(dropout),
+        "--batch_size",
+        str(batch_size),
+        # other config options
+        name="trainer",
+        script="mnist_train_nas.py",
+        image=torchx.version.TORCHX_IMAGE,
+    )
+
+
+######################################################################
+# Setting up the Runner
+# ---------------------
+#
+# Ax’s `Runner <https://ax.dev/api/core.html#ax.core.runner.Runner>`__
+# abstraction allows writing interfaces to various backends.
+# Ax already comes with Runner for TorchX, and so we just need to
+# configure it. For the purpose of this tutorial we run jobs locally
+# in a fully asynchronous fashion.
+#
+# In order to launch them on a cluster, you can instead specify a
+# different TorchX scheduler and adjust the configuration appropriately.
+# For example, if you have a Kubernetes cluster, you just need to change the
+# scheduler from ``local_cwd`` to ``kubernetes``).
+#
+
+
+import tempfile
+from ax.runners.torchx import TorchXRunner
+
+# Make a temporary dir to log our results into
+log_dir = tempfile.mkdtemp()
+
+ax_runner = TorchXRunner(
+    tracker_base="/tmp/",
+    component=trainer,
+    # NOTE: To launch this job on a cluster instead of locally you can
+    # specify a different scheduler and adjust arguments appropriately.
+    scheduler="local_cwd",
+    component_const_params={"log_path": log_dir},
+    cfg={},
+)
+
+######################################################################
+# Setting up the ``SearchSpace``
+# ------------------------------
+#
+# First, we define our search space. Ax supports both range parameters
+# of type integer and float as well as choice parameters which can have
+# non-numerical types such as strings.
+# We will tune the hidden sizes, learning rate, dropout, and number of
+# epochs as range parameters and tune the batch size as an ordered choice
+# parameter to enforce it to be a power of 2.
+#
+
+from ax.core import (
+    ChoiceParameter,
+    ParameterType,
+    RangeParameter,
+    SearchSpace,
+)
+
+parameters = [
+    # NOTE: In a real-world setting, hidden_size_1 and hidden_size_2
+    # should probably be powers of 2, but in our simple example this
+    # would mean that ``num_params`` can't take on that many values, which
+    # in turn makes the Pareto frontier look pretty weird.
+    RangeParameter(
+        name="hidden_size_1",
+        lower=16,
+        upper=128,
+        parameter_type=ParameterType.INT,
+        log_scale=True,
+    ),
+    RangeParameter(
+        name="hidden_size_2",
+        lower=16,
+        upper=128,
+        parameter_type=ParameterType.INT,
+        log_scale=True,
+    ),
+    RangeParameter(
+        name="learning_rate",
+        lower=1e-4,
+        upper=1e-2,
+        parameter_type=ParameterType.FLOAT,
+        log_scale=True,
+    ),
+    RangeParameter(
+        name="epochs",
+        lower=1,
+        upper=4,
+        parameter_type=ParameterType.INT,
+    ),
+    RangeParameter(
+        name="dropout",
+        lower=0.0,
+        upper=0.5,
+        parameter_type=ParameterType.FLOAT,
+    ),
+    ChoiceParameter(  # NOTE: ``ChoiceParameters`` don't require log-scale
+        name="batch_size",
+        values=[32, 64, 128, 256],
+        parameter_type=ParameterType.INT,
+        is_ordered=True,
+        sort_values=True,
+    ),
+]
+
+search_space = SearchSpace(
+    parameters=parameters,
+    # NOTE: In practice, it may make sense to add a constraint
+    # hidden_size_2 <= hidden_size_1
+    parameter_constraints=[],
+)
+
+
+######################################################################
+# Setting up Metrics
+# ------------------
+#
+# Ax has the concept of a `Metric <https://ax.dev/api/core.html#metric>`__
+# that defines properties of outcomes and how observations are obtained
+# for these outcomes. This allows e.g. encoding how data is fetched from
+# some distributed execution backend and post-processed before being
+# passed as input to Ax.
+#
+# In this tutorial we will use
+# `multi-objective optimization <https://ax.dev/tutorials/multiobjective_optimization.html>`__
+# with the goal of maximizing the validation accuracy and minimizing
+# the number of model parameters. The latter represents a simple proxy
+# of model latency, which is hard to estimate accurately for small ML
+# models (in an actual application we would benchmark the latency while
+# running the model on-device).
+#
+# In our example TorchX will run the training jobs in a fully asynchronous
+# fashion locally and write the results to the ``log_dir`` based on the trial
+# index (see the ``trainer()`` function above). We will define a metric
+# class that is aware of that logging directory. By subclassing
+# `TensorboardCurveMetric <https://ax.dev/api/metrics.html?highlight=tensorboardcurvemetric#ax.metrics.tensorboard.TensorboardCurveMetric>`__
+# we get the logic to read and parse the TensorBoard logs for free.
+#
+
+from ax.metrics.tensorboard import TensorboardMetric
+from tensorboard.backend.event_processing import plugin_event_multiplexer as event_multiplexer
+
+class MyTensorboardMetric(TensorboardMetric):
+
+    # NOTE: We need to tell the new TensorBoard metric how to get the id /
+    # file handle for the TensorBoard logs from a trial. In this case
+    # our convention is to just save a separate file per trial in
+    # the prespecified log dir.
+    def _get_event_multiplexer_for_trial(self, trial):
+        mul = event_multiplexer.EventMultiplexer(max_reload_threads=20)
+        mul.AddRunsFromDirectory(Path(log_dir).joinpath(str(trial.index)).as_posix(), None)
+        mul.Reload()
+    
+        return mul
+
+    # This indicates whether the metric is queryable while the trial is
+    # still running. We don't use this in the current tutorial, but Ax
+    # utilizes this to implement trial-level early-stopping functionality.
+    @classmethod
+    def is_available_while_running(cls):
+        return False
+
+
+######################################################################
+# Now we can instantiate the metrics for accuracy and the number of
+# model parameters. Here `curve_name` is the name of the metric in the
+# TensorBoard logs, while `name` is the metric name used internally
+# by Ax. We also specify `lower_is_better` to indicate the favorable
+# direction of the two metrics.
+#
+
+val_acc = MyTensorboardMetric(
+    name="val_acc",
+    tag="val_acc",
+    lower_is_better=False,
+)
+model_num_params = MyTensorboardMetric(
+    name="num_params",
+    tag="num_params",
+    lower_is_better=True,
+)
+
+
+######################################################################
+# Setting up the ``OptimizationConfig``
+# -------------------------------------
+#
+# The way to tell Ax what it should optimize is by means of an
+# `OptimizationConfig <https://ax.dev/api/core.html#module-ax.core.optimization_config>`__.
+# Here we use a ``MultiObjectiveOptimizationConfig`` as we will
+# be performing multi-objective optimization.
+#
+# Additionally, Ax supports placing constraints on the different
+# metrics by specifying objective thresholds, which bound the region
+# of interest in the outcome space that we want to explore. For this
+# example, we will constrain the validation accuracy to be at least
+# 0.94 (94%) and the number of model parameters to be at most 80,000.
+#
+
+from ax.core import MultiObjective, Objective, ObjectiveThreshold
+from ax.core.optimization_config import MultiObjectiveOptimizationConfig
+
+
+opt_config = MultiObjectiveOptimizationConfig(
+    objective=MultiObjective(
+        objectives=[
+            Objective(metric=val_acc, minimize=False),
+            Objective(metric=model_num_params, minimize=True),
+        ],
+    ),
+    objective_thresholds=[
+        ObjectiveThreshold(metric=val_acc, bound=0.94, relative=False),
+        ObjectiveThreshold(metric=model_num_params, bound=80_000, relative=False),
+    ],
+)
+
+
+######################################################################
+# Creating the Ax Experiment
+# --------------------------
+#
+# In Ax, the `Experiment <https://ax.dev/api/core.html#ax.core.experiment.Experiment>`__
+# object is the object that stores all the information about the problem
+# setup.
+#
+# .. tip:
+#   ``Experiment`` objects can be serialized to JSON or stored to a
+#   database backend such as MySQL in order to persist and be available
+#   to load on different machines. See the the `Ax Docs <https://ax.dev/docs/storage.html>`__
+#   on the storage functionality for details.
+#
+
+from ax.core import Experiment
+
+experiment = Experiment(
+    name="torchx_mnist",
+    search_space=search_space,
+    optimization_config=opt_config,
+    runner=ax_runner,
+)
+
+######################################################################
+# Choosing the Generation Strategy
+# --------------------------------
+#
+# A `GenerationStrategy <https://ax.dev/api/modelbridge.html#ax.modelbridge.generation_strategy.GenerationStrategy>`__
+# is the abstract representation of how we would like to perform the
+# optimization. While this can be customized (if you’d like to do so, see
+# `this tutorial <https://ax.dev/tutorials/generation_strategy.html>`__),
+# in most cases Ax can automatically determine an appropriate strategy
+# based on the search space, optimization config, and the total number
+# of trials we want to run.
+#
+# Typically, Ax chooses to evaluate a number of random configurations
+# before starting a model-based Bayesian Optimization strategy.
+#
+
+
+total_trials = 48  # total evaluation budget
+
+from ax.modelbridge.dispatch_utils import choose_generation_strategy
+
+gs = choose_generation_strategy(
+    search_space=experiment.search_space,
+    optimization_config=experiment.optimization_config,
+    num_trials=total_trials,
+  )
+
+
+######################################################################
+# Configuring the Scheduler
+# -------------------------
+#
+# The ``Scheduler`` acts as the loop control for the optimization.
+# It communicates with the backend to launch trials, check their status,
+# and retrieve results. In the case of this tutorial, it is simply reading
+# and parsing the locally saved logs. In a remote execution setting,
+# it would call APIs. The following illustration from the Ax
+# `Scheduler tutorial <https://ax.dev/tutorials/scheduler.html>`__
+# summarizes how the Scheduler interacts with external systems used to run
+# trial evaluations:
+#
+# .. image:: ../../_static/img/ax_scheduler_illustration.png
+#
+#
+# The ``Scheduler`` requires the ``Experiment`` and the ``GenerationStrategy``.
+# A set of options can be passed in via ``SchedulerOptions``. Here, we
+# configure the number of total evaluations as well as ``max_pending_trials``,
+# the maximum number of trials that should run concurrently. In our
+# local setting, this is the number of training jobs running as individual
+# processes, while in a remote execution setting, this would be the number
+# of machines you want to use in parallel.
+#
+
+
+from ax.service.scheduler import Scheduler, SchedulerOptions
+
+scheduler = Scheduler(
+    experiment=experiment,
+    generation_strategy=gs,
+    options=SchedulerOptions(
+        total_trials=total_trials, max_pending_trials=4
+    ),
+)
+
+
+######################################################################
+# Running the optimization
+# ------------------------
+#
+# Now that everything is configured, we can let Ax run the optimization
+# in a fully automated fashion. The Scheduler will periodically check
+# the logs for the status of all currently running trials, and if a
+# trial completes the scheduler will update its status on the
+# experiment and fetch the observations needed for the Bayesian
+# optimization algorithm.
+#
+
+scheduler.run_all_trials()
+
+
+######################################################################
+# Evaluating the results
+# ----------------------
+#
+# We can now inspect the result of the optimization using helper
+# functions and visualizations included with Ax.
+
+######################################################################
+# First, we generate a dataframe with a summary of the results
+# of the experiment. Each row in this dataframe corresponds to a
+# trial (that is, a training job that was run), and contains information
+# on the status of the trial, the parameter configuration that was
+# evaluated, and the metric values that were observed. This provides
+# an easy way to sanity check the optimization.
+#
+
+from ax.service.utils.report_utils import exp_to_df
+
+df = exp_to_df(experiment)
+df.head(10)
+
+
+######################################################################
+# We can also visualize the Pareto frontier of tradeoffs between the
+# validation accuracy and the number of model parameters.
+#
+# .. tip::
+#   Ax uses Plotly to produce interactive plots, which allow you to
+#   do things like zoom, crop, or hover in order to view details
+#   of components of the plot. Try it out, and take a look at the
+#   `visualization tutorial <https://ax.dev/tutorials/visualizations.html>`__
+#   if you'd like to learn more).
+#
+# The final optimization results are shown in the figure below where
+# the color corresponds to the iteration number for each trial.
+# We see that our method was able to successfully explore the
+# trade-offs and found both large models with high validation
+# accuracy as well as small models with comparatively lower
+# validation accuracy.
+#
+
+from ax.service.utils.report_utils import _pareto_frontier_scatter_2d_plotly
+
+_pareto_frontier_scatter_2d_plotly(experiment)
+
+
+######################################################################
+# To better understand what our surrogate models have learned about
+# the black box objectives, we can take a look at the leave-one-out
+# cross validation results. Since our models are Gaussian Processes,
+# they not only provide point predictions but also uncertainty estimates
+# about these predictions. A good model means that the predicted means
+# (the points in the figure) are close to the 45 degree line and that the
+# confidence intervals cover the 45 degree line with the expected frequency
+# (here we use 95% confidence intervals, so we would expect them to contain
+# the true observation 95% of the time).
+#
+# As the figures below show, the model size (``num_params``) metric is
+# much easier to model than the validation accuracy (``val_acc``) metric.
+#
+
+from ax.modelbridge.cross_validation import compute_diagnostics, cross_validate
+from ax.plot.diagnostic import interact_cross_validation_plotly
+from ax.utils.notebook.plotting import init_notebook_plotting, render
+
+cv = cross_validate(model=gs.model)  # The surrogate model is stored on the ``GenerationStrategy``
+compute_diagnostics(cv)
+
+interact_cross_validation_plotly(cv)
+
+
+######################################################################
+# We can also make contour plots to better understand how the different
+# objectives depend on two of the input parameters. In the figure below,
+# we show the validation accuracy predicted by the model as a function
+# of the two hidden sizes. The validation accuracy clearly increases
+# as the hidden sizes increase.
+#
+
+from ax.plot.contour import interact_contour_plotly
+
+interact_contour_plotly(model=gs.model, metric_name="val_acc")
+
+
+######################################################################
+# Similarly, we show the number of model parameters as a function of
+# the hidden sizes in the figure below and see that it also increases
+# as a function of the hidden sizes (the dependency on ``hidden_size_1``
+# is much larger).
+
+interact_contour_plotly(model=gs.model, metric_name="num_params")
+
+
+######################################################################
+# Acknowledgments
+# ----------------
+#
+# We thank the TorchX team (in particular Kiuk Chung and Tristan Rice)
+# for their help with integrating TorchX with Ax.
+#
diff --git a/intermediate_source/char_rnn_classification_tutorial.py b/intermediate_source/char_rnn_classification_tutorial.py
index cde75e41510..6d56029f5d5 100644
--- a/intermediate_source/char_rnn_classification_tutorial.py
+++ b/intermediate_source/char_rnn_classification_tutorial.py
@@ -1,39 +1,41 @@
 # -*- coding: utf-8 -*-
 """
-Classifying Names with a Character-Level RNN
-*********************************************
-**Author**: `Sean Robertson <https://github.com/spro/practical-pytorch>`_
+NLP From Scratch: Classifying Names with a Character-Level RNN
+**************************************************************
+**Author**: `Sean Robertson <https://github.com/spro>`_
 
-We will be building and training a basic character-level RNN to classify
-words. A character-level RNN reads words as a series of characters -
+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 show how
+preprocessing to model NLP works at a low level.
+
+A character-level RNN reads words as a series of characters -
 outputting a prediction and "hidden state" at each step, feeding its
 previous hidden state into each next step. We take the final prediction
 to be the output, i.e. which class the word belongs to.
 
 Specifically, we'll train on a few thousand surnames from 18 languages
 of origin, and predict which language a name is from based on the
-spelling:
-
-::
-
-    $ python predict.py Hinton
-    (-0.47) Scottish
-    (-1.52) English
-    (-3.57) Irish
+spelling.
 
-    $ python predict.py Schmidhuber
-    (-0.19) German
-    (-2.48) Czech
-    (-2.68) Dutch
+Recommended Preparation
+=======================
 
-
-**Recommended Reading:**
-
-I assume you have at least installed PyTorch, know Python, and
-understand Tensors:
+Before starting this tutorial it is recommended that you have installed PyTorch,
+and have a basic understanding of Python programming language and Tensors:
 
 -  https://pytorch.org/ For installation instructions
 -  :doc:`/beginner/deep_learning_60min_blitz` to get started with PyTorch in general
+   and learn the basics of Tensors
 -  :doc:`/beginner/pytorch_with_examples` for a wide and deep overview
 -  :doc:`/beginner/former_torchies_tutorial` if you are former Lua Torch user
 
@@ -46,80 +48,63 @@
    Networks <https://colah.github.io/posts/2015-08-Understanding-LSTMs/>`__
    is about LSTMs specifically but also informative about RNNs in
    general
+"""
+######################################################################
+# Preparing Torch
+# ==========================
+#
+# Set up torch to default to the right device use GPU acceleration depending on your hardware (CPU or CUDA).
+#
 
-Preparing the Data
-==================
-
-.. Note::
-   Download the data from
-   `here <https://download.pytorch.org/tutorial/data.zip>`_
-   and extract it to the current directory.
-
-Included in the ``data/names`` directory are 18 text files named as
-"[Language].txt". Each file contains a bunch of names, one name per
-line, mostly romanized (but we still need to convert from Unicode to
-ASCII).
+import torch
 
-We'll end up with a dictionary of lists of names per language,
-``{language: [names ...]}``. The generic variables "category" and "line"
-(for language and name in our case) are used for later extensibility.
-"""
-from __future__ import unicode_literals, print_function, division
-from io import open
-import glob
-import os
+# Check if CUDA is available
+device = torch.device('cpu')
+if torch.cuda.is_available():
+    device = torch.device('cuda')
 
-def findFiles(path): return glob.glob(path)
+torch.set_default_device(device)
+print(f"Using device = {torch.get_default_device()}")
 
-print(findFiles('data/names/*.txt'))
+######################################################################
+# Preparing the Data
+# ==================
+#
+# Download the data from `here <https://download.pytorch.org/tutorial/data.zip>`__
+# and extract it to the current directory.
+#
+# Included in the ``data/names`` directory are 18 text files named as
+# ``[Language].txt``. Each file contains a bunch of names, one name per
+# line, mostly romanized (but we still need to convert from Unicode to
+# ASCII).
+#
+# The first step is to define and clean our data. Initially, we need to convert Unicode to plain ASCII to
+# limit the RNN input layers. This is accomplished by converting Unicode strings to ASCII and allowing only a small set of allowed characters.
 
-import unicodedata
 import string
+import unicodedata
 
-all_letters = string.ascii_letters + " .,;'"
-n_letters = len(all_letters)
+# We can use "_" to represent an out-of-vocabulary character, that is, any character we are not handling in our model
+allowed_characters = string.ascii_letters + " .,;'" + "_"
+n_letters = len(allowed_characters)
 
 # Turn a Unicode string to plain ASCII, thanks to https://stackoverflow.com/a/518232/2809427
 def unicodeToAscii(s):
     return ''.join(
         c for c in unicodedata.normalize('NFD', s)
         if unicodedata.category(c) != 'Mn'
-        and c in all_letters
+        and c in allowed_characters
     )
 
-print(unicodeToAscii('Ślusàrski'))
-
-# Build the category_lines dictionary, a list of names per language
-category_lines = {}
-all_categories = []
-
-# Read a file and split into lines
-def readLines(filename):
-    lines = open(filename, encoding='utf-8').read().strip().split('\n')
-    return [unicodeToAscii(line) for line in lines]
-
-for filename in findFiles('data/names/*.txt'):
-    category = os.path.splitext(os.path.basename(filename))[0]
-    all_categories.append(category)
-    lines = readLines(filename)
-    category_lines[category] = lines
-
-n_categories = len(all_categories)
-
-
-######################################################################
-# Now we have ``category_lines``, a dictionary mapping each category
-# (language) to a list of lines (names). We also kept track of
-# ``all_categories`` (just a list of languages) and ``n_categories`` for
-# later reference.
+#########################
+# Here's an example of converting a unicode alphabet name to plain ASCII. This simplifies the input layer
 #
 
-print(category_lines['Italian'][:5])
-
+print (f"converting 'Ślusàrski' to {unicodeToAscii('Ślusàrski')}")
 
 ######################################################################
 # Turning Names into Tensors
-# --------------------------
+# ==========================
 #
 # Now that we have all the names organized, we need to turn them into
 # Tensors to make any use of them.
@@ -133,19 +118,14 @@ def readLines(filename):
 #
 # That extra 1 dimension is because PyTorch assumes everything is in
 # batches - we're just using a batch size of 1 here.
-#
-
-import torch
 
 # Find letter index from all_letters, e.g. "a" = 0
 def letterToIndex(letter):
-    return all_letters.find(letter)
-
-# Just for demonstration, turn a letter into a <1 x n_letters> Tensor
-def letterToTensor(letter):
-    tensor = torch.zeros(1, n_letters)
-    tensor[0][letterToIndex(letter)] = 1
-    return tensor
+    # return our out-of-vocabulary character if we encounter a letter unknown to our model
+    if letter not in allowed_characters:
+        return allowed_characters.find("_")
+    else:
+        return allowed_characters.find(letter)
 
 # Turn a line into a <line_length x 1 x n_letters>,
 # or an array of one-hot letter vectors
@@ -155,9 +135,87 @@ def lineToTensor(line):
         tensor[li][0][letterToIndex(letter)] = 1
     return tensor
 
-print(letterToTensor('J'))
+#########################
+# Here are some examples of how to use ``lineToTensor()`` for a single and multiple character string.
 
-print(lineToTensor('Jones').size())
+print (f"The letter 'a' becomes {lineToTensor('a')}") #notice that the first position in the tensor = 1
+print (f"The name 'Ahn' becomes {lineToTensor('Ahn')}") #notice 'A' sets the 27th index to 1
+
+#########################
+# Congratulations, you have built the foundational tensor objects for this learning task! You can use a similar approach
+# for other RNN tasks with text.
+#
+# Next, we need to combine all our examples into a dataset so we can train, test and validate our models. For this,
+# we will use the `Dataset and DataLoader <https://pytorch.org/tutorials/beginner/basics/data_tutorial.html>`__ classes
+# to hold our dataset. Each Dataset needs to implement three functions: ``__init__``, ``__len__``, and ``__getitem__``.
+from io import open
+import glob
+import os
+import time
+
+import torch
+from torch.utils.data import Dataset
+
+class NamesDataset(Dataset):
+
+    def __init__(self, data_dir):
+        self.data_dir = data_dir #for provenance of the dataset
+        self.load_time = time.localtime #for provenance of the dataset
+        labels_set = set() #set of all classes
+
+        self.data = []
+        self.data_tensors = []
+        self.labels = []
+        self.labels_tensors = []
+
+        #read all the ``.txt`` files in the specified directory
+        text_files = glob.glob(os.path.join(data_dir, '*.txt'))
+        for filename in text_files:
+            label = os.path.splitext(os.path.basename(filename))[0]
+            labels_set.add(label)
+            lines = open(filename, encoding='utf-8').read().strip().split('\n')
+            for name in lines:
+                self.data.append(name)
+                self.data_tensors.append(lineToTensor(name))
+                self.labels.append(label)
+
+        #Cache the tensor representation of the labels
+        self.labels_uniq = list(labels_set)
+        for idx in range(len(self.labels)):
+            temp_tensor = torch.tensor([self.labels_uniq.index(self.labels[idx])], dtype=torch.long)
+            self.labels_tensors.append(temp_tensor)
+
+    def __len__(self):
+        return len(self.data)
+
+    def __getitem__(self, idx):
+        data_item = self.data[idx]
+        data_label = self.labels[idx]
+        data_tensor = self.data_tensors[idx]
+        label_tensor = self.labels_tensors[idx]
+
+        return label_tensor, data_tensor, data_label, data_item
+
+
+#########################
+#Here we can load our example data into the ``NamesDataset``
+
+alldata = NamesDataset("data/names")
+print(f"loaded {len(alldata)} items of data")
+print(f"example = {alldata[0]}")
+
+#########################
+#Using the dataset object allows us to easily split the data into train and test sets. Here we create a 80/20
+# split but the ``torch.utils.data`` has more useful utilities. Here we specify a generator since we need to use the
+#same device as PyTorch defaults to above.
+
+train_set, test_set = torch.utils.data.random_split(alldata, [.85, .15], generator=torch.Generator(device=device).manual_seed(2024))
+
+print(f"train examples = {len(train_set)}, validation examples = {len(test_set)}")
+
+#########################
+# Now we have a basic dataset containing **20074** examples where each example is a pairing of label and name. We have also
+#split the dataset into training and testing so we can validate the model that we build.
 
 
 ######################################################################
@@ -170,118 +228,57 @@ def lineToTensor(line):
 # graph itself. This means you can implement a RNN in a very "pure" way,
 # as regular feed-forward layers.
 #
-# This RNN module (mostly copied from `the PyTorch for Torch users
-# tutorial <https://pytorch.org/tutorials/beginner/former_torchies/
-# nn_tutorial.html#example-2-recurrent-net>`__)
-# is just 2 linear layers which operate on an input and hidden state, with
-# a LogSoftmax layer after the output.
-#
-# .. figure:: https://i.imgur.com/Z2xbySO.png
-#    :alt:
-#
+# This CharRNN class implements an RNN with three components.
+# First, we use the `nn.RNN implementation <https://pytorch.org/docs/stable/generated/torch.nn.RNN.html>`__.
+# Next, we define a layer that maps the RNN hidden layers to our output. And finally, we apply a ``softmax`` function. Using ``nn.RNN``
+# leads to a significant improvement in performance, such as cuDNN-accelerated kernels, versus implementing
+# each layer as a ``nn.Linear``. It also simplifies the implementation in ``forward()``.
 #
 
 import torch.nn as nn
+import torch.nn.functional as F
 
-class RNN(nn.Module):
+class CharRNN(nn.Module):
     def __init__(self, input_size, hidden_size, output_size):
-        super(RNN, self).__init__()
-
-        self.hidden_size = hidden_size
+        super(CharRNN, self).__init__()
 
-        self.i2h = nn.Linear(input_size + hidden_size, hidden_size)
-        self.i2o = nn.Linear(input_size + hidden_size, output_size)
+        self.rnn = nn.RNN(input_size, hidden_size)
+        self.h2o = nn.Linear(hidden_size, output_size)
         self.softmax = nn.LogSoftmax(dim=1)
 
-    def forward(self, input, hidden):
-        combined = torch.cat((input, hidden), 1)
-        hidden = self.i2h(combined)
-        output = self.i2o(combined)
+    def forward(self, line_tensor):
+        rnn_out, hidden = self.rnn(line_tensor)
+        output = self.h2o(hidden[0])
         output = self.softmax(output)
-        return output, hidden
 
-    def initHidden(self):
-        return torch.zeros(1, self.hidden_size)
+        return output
 
-n_hidden = 128
-rnn = RNN(n_letters, n_hidden, n_categories)
-
-
-######################################################################
-# To run a step of this network we need to pass an input (in our case, the
-# Tensor for the current letter) and a previous hidden state (which we
-# initialize as zeros at first). We'll get back the output (probability of
-# each language) and a next hidden state (which we keep for the next
-# step).
-#
 
-input = letterToTensor('A')
-hidden =torch.zeros(1, n_hidden)
-
-output, next_hidden = rnn(input, hidden)
+###########################
+# We can then create an RNN with 58 input nodes, 128 hidden nodes, and 18 outputs:
 
+n_hidden = 128
+rnn = CharRNN(n_letters, n_hidden, len(alldata.labels_uniq))
+print(rnn)
 
 ######################################################################
-# For the sake of efficiency we don't want to be creating a new Tensor for
-# every step, so we will use ``lineToTensor`` instead of
-# ``letterToTensor`` and use slices. This could be further optimized by
-# pre-computing batches of Tensors.
-#
+# After that we can pass our Tensor to the RNN to obtain a predicted output. Subsequently,
+# we use a helper function, ``label_from_output``, to derive a text label for the class.
 
-input = lineToTensor('Albert')
-hidden = torch.zeros(1, n_hidden)
+def label_from_output(output, output_labels):
+    top_n, top_i = output.topk(1)
+    label_i = top_i[0].item()
+    return output_labels[label_i], label_i
 
-output, next_hidden = rnn(input[0], hidden)
+input = lineToTensor('Albert')
+output = rnn(input) #this is equivalent to ``output = rnn.forward(input)``
 print(output)
-
-
-######################################################################
-# As you can see the output is a ``<1 x n_categories>`` Tensor, where
-# every item is the likelihood of that category (higher is more likely).
-#
-
+print(label_from_output(output, alldata.labels_uniq))
 
 ######################################################################
 #
 # Training
 # ========
-# Preparing for Training
-# ----------------------
-#
-# Before going into training we should make a few helper functions. The
-# first is to interpret the output of the network, which we know to be a
-# likelihood of each category. We can use ``Tensor.topk`` to get the index
-# of the greatest value:
-#
-
-def categoryFromOutput(output):
-    top_n, top_i = output.topk(1)
-    category_i = top_i[0].item()
-    return all_categories[category_i], category_i
-
-print(categoryFromOutput(output))
-
-
-######################################################################
-# We will also want a quick way to get a training example (a name and its
-# language):
-#
-
-import random
-
-def randomChoice(l):
-    return l[random.randint(0, len(l) - 1)]
-
-def randomTrainingExample():
-    category = randomChoice(all_categories)
-    line = randomChoice(category_lines[category])
-    category_tensor = torch.tensor([all_categories.index(category)], dtype=torch.long)
-    line_tensor = lineToTensor(line)
-    return category, line, category_tensor, line_tensor
-
-for i in range(10):
-    category, line, category_tensor, line_tensor = randomTrainingExample()
-    print('category =', category, '/ line =', line)
 
 
 ######################################################################
@@ -291,93 +288,67 @@ def randomTrainingExample():
 # Now all it takes to train this network is show it a bunch of examples,
 # have it make guesses, and tell it if it's wrong.
 #
-# For the loss function ``nn.NLLLoss`` is appropriate, since the last
-# layer of the RNN is ``nn.LogSoftmax``.
-#
-
-criterion = nn.NLLLoss()
-
-
-######################################################################
-# Each loop of training will:
-#
-# -  Create input and target tensors
-# -  Create a zeroed initial hidden state
-# -  Read each letter in and
-#
-#    -  Keep hidden state for next letter
-#
-# -  Compare final output to target
-# -  Back-propagate
-# -  Return the output and loss
-#
-
-learning_rate = 0.005 # If you set this too high, it might explode. If too low, it might not learn
-
-def train(category_tensor, line_tensor):
-    hidden = rnn.initHidden()
-
-    rnn.zero_grad()
-
-    for i in range(line_tensor.size()[0]):
-        output, hidden = rnn(line_tensor[i], hidden)
-
-    loss = criterion(output, category_tensor)
-    loss.backward()
-
-    # Add parameters' gradients to their values, multiplied by learning rate
-    for p in rnn.parameters():
-        p.data.add_(-learning_rate, p.grad.data)
-
-    return output, loss.item()
-
-
-######################################################################
-# Now we just have to run that with a bunch of examples. Since the
-# ``train`` function returns both the output and loss we can print its
-# guesses and also keep track of loss for plotting. Since there are 1000s
-# of examples we print only every ``print_every`` examples, and take an
-# average of the loss.
-#
-
-import time
-import math
-
-n_iters = 100000
-print_every = 5000
-plot_every = 1000
-
+# We do this by defining a ``train()`` function which trains the model on a given dataset using minibatches. RNNs
+# RNNs are trained similarly to other networks; therefore, for completeness, we include a batched training method here.
+# The loop (``for i in batch``) computes the losses for each of the items in the batch before adjusting the
+# weights. This operation is repeated until the number of epochs is reached.
 
+import random
+import numpy as np
+
+def train(rnn, training_data, n_epoch = 10, n_batch_size = 64, report_every = 50, learning_rate = 0.2, criterion = nn.NLLLoss()):
+    """
+    Learn on a batch of training_data for a specified number of iterations and reporting thresholds
+    """
+    # Keep track of losses for plotting
+    current_loss = 0
+    all_losses = []
+    rnn.train()
+    optimizer = torch.optim.SGD(rnn.parameters(), lr=learning_rate)
+
+    start = time.time()
+    print(f"training on data set with n = {len(training_data)}")
+
+    for iter in range(1, n_epoch + 1):
+        rnn.zero_grad() # clear the gradients
+
+        # create some minibatches
+        # we cannot use dataloaders because each of our names is a different length
+        batches = list(range(len(training_data)))
+        random.shuffle(batches)
+        batches = np.array_split(batches, len(batches) //n_batch_size )
+
+        for idx, batch in enumerate(batches):
+            batch_loss = 0
+            for i in batch: #for each example in this batch
+                (label_tensor, text_tensor, label, text) = training_data[i]
+                output = rnn.forward(text_tensor)
+                loss = criterion(output, label_tensor)
+                batch_loss += loss
+
+            # optimize parameters
+            batch_loss.backward()
+            nn.utils.clip_grad_norm_(rnn.parameters(), 3)
+            optimizer.step()
+            optimizer.zero_grad()
+
+            current_loss += batch_loss.item() / len(batch)
+
+        all_losses.append(current_loss / len(batches) )
+        if iter % report_every == 0:
+            print(f"{iter} ({iter / n_epoch:.0%}): \t average batch loss = {all_losses[-1]}")
+        current_loss = 0
 
-# Keep track of losses for plotting
-current_loss = 0
-all_losses = []
+    return all_losses
 
-def timeSince(since):
-    now = time.time()
-    s = now - since
-    m = math.floor(s / 60)
-    s -= m * 60
-    return '%dm %ds' % (m, s)
+##########################################################################
+# We can now train a dataset with minibatches for a specified number of epochs. The number of epochs for this
+# example is reduced to speed up the build. You can get better results with different parameters.
 
 start = time.time()
-
-for iter in range(1, n_iters + 1):
-    category, line, category_tensor, line_tensor = randomTrainingExample()
-    output, loss = train(category_tensor, line_tensor)
-    current_loss += loss
-
-    # Print iter number, loss, name and guess
-    if iter % print_every == 0:
-        guess, guess_i = categoryFromOutput(output)
-        correct = '✓' if guess == category else '✗ (%s)' % category
-        print('%d %d%% (%s) %.4f %s / %s %s' % (iter, iter / n_iters * 100, timeSince(start), loss, line, guess, correct))
-
-    # Add current loss avg to list of losses
-    if iter % plot_every == 0:
-        all_losses.append(current_loss / plot_every)
-        current_loss = 0
-
+all_losses = train(rnn, train_set, n_epoch=27, learning_rate=0.15, report_every=5)
+end = time.time()
+print(f"training took {end-start}s")
 
 ######################################################################
 # Plotting the Results
@@ -392,7 +363,7 @@ def timeSince(since):
 
 plt.figure()
 plt.plot(all_losses)
-
+plt.show()
 
 ######################################################################
 # Evaluating the Results
@@ -405,47 +376,44 @@ def timeSince(since):
 # ``evaluate()``, which is the same as ``train()`` minus the backprop.
 #
 
-# Keep track of correct guesses in a confusion matrix
-confusion = torch.zeros(n_categories, n_categories)
-n_confusion = 10000
+def evaluate(rnn, testing_data, classes):
+    confusion = torch.zeros(len(classes), len(classes))
 
-# Just return an output given a line
-def evaluate(line_tensor):
-    hidden = rnn.initHidden()
+    rnn.eval() #set to eval mode
+    with torch.no_grad(): # do not record the gradients during eval phase
+        for i in range(len(testing_data)):
+            (label_tensor, text_tensor, label, text) = testing_data[i]
+            output = rnn(text_tensor)
+            guess, guess_i = label_from_output(output, classes)
+            label_i = classes.index(label)
+            confusion[label_i][guess_i] += 1
 
-    for i in range(line_tensor.size()[0]):
-        output, hidden = rnn(line_tensor[i], hidden)
+    # Normalize by dividing every row by its sum
+    for i in range(len(classes)):
+        denom = confusion[i].sum()
+        if denom > 0:
+            confusion[i] = confusion[i] / denom
 
-    return output
+    # Set up plot
+    fig = plt.figure()
+    ax = fig.add_subplot(111)
+    cax = ax.matshow(confusion.cpu().numpy()) #numpy uses cpu here so we need to use a cpu version
+    fig.colorbar(cax)
 
-# Go through a bunch of examples and record which are correctly guessed
-for i in range(n_confusion):
-    category, line, category_tensor, line_tensor = randomTrainingExample()
-    output = evaluate(line_tensor)
-    guess, guess_i = categoryFromOutput(output)
-    category_i = all_categories.index(category)
-    confusion[category_i][guess_i] += 1
+    # Set up axes
+    ax.set_xticks(np.arange(len(classes)), labels=classes, rotation=90)
+    ax.set_yticks(np.arange(len(classes)), labels=classes)
 
-# Normalize by dividing every row by its sum
-for i in range(n_categories):
-    confusion[i] = confusion[i] / confusion[i].sum()
+    # Force label at every tick
+    ax.xaxis.set_major_locator(ticker.MultipleLocator(1))
+    ax.yaxis.set_major_locator(ticker.MultipleLocator(1))
 
-# Set up plot
-fig = plt.figure()
-ax = fig.add_subplot(111)
-cax = ax.matshow(confusion.numpy())
-fig.colorbar(cax)
+    # sphinx_gallery_thumbnail_number = 2
+    plt.show()
 
-# Set up axes
-ax.set_xticklabels([''] + all_categories, rotation=90)
-ax.set_yticklabels([''] + all_categories)
 
-# Force label at every tick
-ax.xaxis.set_major_locator(ticker.MultipleLocator(1))
-ax.yaxis.set_major_locator(ticker.MultipleLocator(1))
 
-# sphinx_gallery_thumbnail_number = 2
-plt.show()
+evaluate(rnn, test_set, classes=alldata.labels_uniq)
 
 
 ######################################################################
@@ -456,72 +424,20 @@ def evaluate(line_tensor):
 #
 
 
-######################################################################
-# Running on User Input
-# ---------------------
-#
-
-def predict(input_line, n_predictions=3):
-    print('\n> %s' % input_line)
-    with torch.no_grad():
-        output = evaluate(lineToTensor(input_line))
-
-        # Get top N categories
-        topv, topi = output.topk(n_predictions, 1, True)
-        predictions = []
-
-        for i in range(n_predictions):
-            value = topv[0][i].item()
-            category_index = topi[0][i].item()
-            print('(%.2f) %s' % (value, all_categories[category_index]))
-            predictions.append([value, all_categories[category_index]])
-
-predict('Dovesky')
-predict('Jackson')
-predict('Satoshi')
-
-
-######################################################################
-# The final versions of the scripts `in the Practical PyTorch
-# repo <https://github.com/spro/practical-pytorch/tree/master/char-rnn-classification>`__
-# split the above code into a few files:
-#
-# -  ``data.py`` (loads files)
-# -  ``model.py`` (defines the RNN)
-# -  ``train.py`` (runs training)
-# -  ``predict.py`` (runs ``predict()`` with command line arguments)
-# -  ``server.py`` (serve prediction as a JSON API with bottle.py)
-#
-# Run ``train.py`` to train and save the network.
-#
-# Run ``predict.py`` with a name to view predictions:
-#
-# ::
-#
-#     $ python predict.py Hazaki
-#     (-0.42) Japanese
-#     (-1.39) Polish
-#     (-3.51) Czech
-#
-# Run ``server.py`` and visit http://localhost:5533/Yourname to get JSON
-# output of predictions.
-#
-
-
 ######################################################################
 # Exercises
 # =========
 #
-# -  Try with a different dataset of line -> category, for example:
-#
-#    -  Any word -> language
-#    -  First name -> gender
-#    -  Character name -> writer
-#    -  Page title -> blog or subreddit
-#
 # -  Get better results with a bigger and/or better shaped network
 #
-#    -  Add more linear layers
+#    -  Adjust the hyperparameters to enhance performance, such as changing the number of epochs, batch size, and learning rate
 #    -  Try the ``nn.LSTM`` and ``nn.GRU`` layers
+#    -  Modify the size of the layers, such as increasing or decreasing the number of hidden nodes or adding additional linear layers
 #    -  Combine multiple of these RNNs as a higher level network
 #
+# -  Try with a different dataset of line -> label, for example:
+#
+#    -  Any word -> language
+#    -  First name -> gender
+#    -  Character name -> writer
+#    -  Page title -> blog or subreddit
\ No newline at end of file
diff --git a/intermediate_source/char_rnn_generation_tutorial.py b/intermediate_source/char_rnn_generation_tutorial.py
index 6f040b58778..50a6afa11b7 100644
--- a/intermediate_source/char_rnn_generation_tutorial.py
+++ b/intermediate_source/char_rnn_generation_tutorial.py
@@ -1,14 +1,21 @@
 # -*- coding: utf-8 -*-
 """
-Generating Names with a Character-Level RNN
-*******************************************
-**Author**: `Sean Robertson <https://github.com/spro/practical-pytorch>`_
+NLP From Scratch: Generating Names with a Character-Level RNN
+*************************************************************
+**Author**: `Sean Robertson <https://github.com/spro>`_
 
-In the :doc:`last tutorial </intermediate/char_rnn_classification_tutorial>`
+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
 we'll turn around and generate names from languages.
 
-::
+.. code-block:: sh
 
     > python sample.py Russian RUS
     Rovakov
@@ -63,7 +70,7 @@
 Preparing the Data
 ==================
 
-.. Note::
+.. note::
    Download the data from
    `here <https://download.pytorch.org/tutorial/data.zip>`_
    and extract it to the current directory.
@@ -74,7 +81,6 @@
 and end up with a dictionary ``{language: [names ...]}``.
 
 """
-from __future__ import unicode_literals, print_function, division
 from io import open
 import glob
 import os
@@ -96,8 +102,8 @@ def unicodeToAscii(s):
 
 # Read a file and split into lines
 def readLines(filename):
-    lines = open(filename, encoding='utf-8').read().strip().split('\n')
-    return [unicodeToAscii(line) for line in lines]
+    with open(filename, encoding='utf-8') as some_file:
+        return [unicodeToAscii(line.strip()) for line in some_file]
 
 # Build the category_lines dictionary, a list of lines per category
 category_lines = {}
@@ -233,7 +239,7 @@ def inputTensor(line):
         tensor[li][0][all_letters.find(letter)] = 1
     return tensor
 
-# LongTensor of second letter to end (EOS) for target
+# ``LongTensor`` of second letter to end (EOS) for target
 def targetTensor(line):
     letter_indexes = [all_letters.find(line[li]) for li in range(1, len(line))]
     letter_indexes.append(n_letters - 1) # EOS
@@ -277,7 +283,7 @@ def train(category_tensor, input_line_tensor, target_line_tensor):
 
     rnn.zero_grad()
 
-    loss = 0
+    loss = torch.Tensor([0]) # you can also just simply use ``loss = 0``
 
     for i in range(input_line_tensor.size(0)):
         output, hidden = rnn(category_tensor, input_line_tensor[i], hidden)
@@ -287,7 +293,7 @@ def train(category_tensor, input_line_tensor, target_line_tensor):
     loss.backward()
 
     for p in rnn.parameters():
-        p.data.add_(-learning_rate, p.grad.data)
+        p.data.add_(p.grad.data, alpha=-learning_rate)
 
     return output, loss.item() / input_line_tensor.size(0)
 
@@ -321,7 +327,7 @@ def timeSince(since):
 print_every = 5000
 plot_every = 500
 all_losses = []
-total_loss = 0 # Reset every plot_every iters
+total_loss = 0 # Reset every ``plot_every`` ``iters``
 
 start = time.time()
 
@@ -346,7 +352,6 @@ def timeSince(since):
 #
 
 import matplotlib.pyplot as plt
-import matplotlib.ticker as ticker
 
 plt.figure()
 plt.plot(all_losses)
@@ -371,7 +376,7 @@ def timeSince(since):
 #
 # -  Return the final name
 #
-# .. Note::
+# .. note::
 #    Rather than having to give it a starting letter, another
 #    strategy would have been to include a "start of string" token in
 #    training and have the network choose its own starting letter.
@@ -429,6 +434,6 @@ def samples(category, start_letters='ABC'):
 #    choosing a start letter
 # -  Get better results with a bigger and/or better shaped network
 #
-#    -  Try the nn.LSTM and nn.GRU layers
+#    -  Try the ``nn.LSTM`` and ``nn.GRU`` layers
 #    -  Combine multiple of these RNNs as a higher level network
 #
diff --git a/intermediate_source/compiled_autograd_tutorial.rst b/intermediate_source/compiled_autograd_tutorial.rst
new file mode 100644
index 00000000000..1091b19a49e
--- /dev/null
+++ b/intermediate_source/compiled_autograd_tutorial.rst
@@ -0,0 +1,221 @@
+Compiled Autograd: Capturing a larger backward graph for ``torch.compile``
+==========================================================================
+**Author:** `Simon Fan <https://github.com/xmfan>`_
+
+.. grid:: 2
+
+    .. grid-item-card:: :octicon:`mortar-board;1em;` What you will learn
+       :class-card: card-prerequisites
+
+       * How compiled autograd interacts with ``torch.compile``
+       * How to use the compiled autograd API
+       * How to inspect logs using ``TORCH_LOGS``
+
+    .. grid-item-card:: :octicon:`list-unordered;1em;` Prerequisites
+       :class-card: card-prerequisites
+
+       * PyTorch 2.4
+       * Complete the `Introduction to torch.compile <https://pytorch.org/tutorials/intermediate/torch_compile_tutorial.html>`_
+       * Read through the TorchDynamo and AOTAutograd sections of `Get Started with PyTorch 2.x <https://pytorch.org/get-started/pytorch-2.0/>`_
+
+Overview
+--------
+Compiled Autograd is a ``torch.compile`` extension introduced in PyTorch 2.4
+that allows the capture of a larger backward graph.
+
+While ``torch.compile`` does capture the backward graph, it does so **partially**. The AOTAutograd component captures the backward graph ahead-of-time, with certain limitations:
+
+* Graph breaks in the forward lead to graph breaks in the backward
+* `Backward hooks <https://pytorch.org/docs/stable/notes/autograd.html#backward-hooks-execution>`_ are not captured
+
+Compiled Autograd addresses these limitations by directly integrating with the autograd engine, allowing
+it to capture the full backward graph at runtime. Models with these two characteristics should try
+Compiled Autograd, and potentially observe better performance.
+
+However, Compiled Autograd introduces its own limitations:
+
+* Added runtime overhead at the start of the backward for cache lookup
+* More prone to recompiles and graph breaks in dynamo due to the larger capture
+
+.. note:: Compiled Autograd is under active development and is not yet compatible with all existing PyTorch features. For the latest status on a particular feature, refer to `Compiled Autograd Landing Page <https://docs.google.com/document/d/11VucFBEewzqgkABIjebZIzMvrXr3BtcY1aGKpX61pJY>`_.
+
+Setup
+-----
+In this tutorial, we will base our examples on this simple neural network model.
+It takes a 10-dimensional input vector, processes it through a single linear layer, and outputs another 10-dimensional vector.
+
+.. code:: python
+
+   import torch
+
+   class Model(torch.nn.Module):
+      def __init__(self):
+         super().__init__()
+         self.linear = torch.nn.Linear(10, 10)
+
+      def forward(self, x):
+         return self.linear(x)
+
+Basic usage
+------------
+Before calling the ``torch.compile`` API, make sure to set ``torch._dynamo.config.compiled_autograd`` to ``True``:
+
+.. code:: python
+
+   model = Model()
+   x = torch.randn(10)
+
+   torch._dynamo.config.compiled_autograd = True
+   @torch.compile
+   def train(model, x):
+      loss = model(x).sum()
+      loss.backward()
+
+   train(model, x) 
+
+In the code above, we create an instance of the ``Model`` class and generate a random 10-dimensional tensor ``x`` by using ``torch.randn(10)``.
+We define the training loop function ``train`` and decorate it with @torch.compile to optimize its execution.
+When ``train(model, x)`` is called:
+
+* Python Interpreter calls Dynamo, since this call was decorated with ``@torch.compile``.
+* Dynamo intercepts the Python bytecode, simulates their execution and records the operations into a graph.
+* ``AOTDispatcher`` disables hooks and calls the autograd engine to compute gradients for ``model.linear.weight`` and ``model.linear.bias``, and records the operations into a graph. Using ``torch.autograd.Function``, AOTDispatcher rewrites the forward and backward implementation of ``train``.
+* Inductor generates a function corresponding to an optimized implementation of the AOTDispatcher forward and backward.
+* Dynamo sets the optimized function to be evaluated next by Python Interpreter.
+* Python Interpreter executes the optimized function, which executes ``loss = model(x).sum()``.
+* Python Interpreter executes ``loss.backward()``, calling into the autograd engine, which routes to the Compiled Autograd engine since we set ``torch._dynamo.config.compiled_autograd = True``.
+* Compiled Autograd computes the gradients for ``model.linear.weight`` and ``model.linear.bias``, and records the operations into a graph, including any hooks it encounters. During this process, it will record the backward previously rewritten by AOTDispatcher. Compiled Autograd then generates a new function which corresponds to a fully-traced implementation of ``loss.backward()``, and executes it with ``torch.compile`` in inference mode.
+* The same steps recursively apply to the Compiled Autograd graph, but this time AOTDispatcher will not need to partition the graph.
+
+Inspecting the compiled autograd logs
+-------------------------------------
+Run the script with the ``TORCH_LOGS`` environment variables:
+
+* To only print the compiled autograd graph, use ``TORCH_LOGS="compiled_autograd" python example.py``
+* To print the graph with more tensor metadata and recompile reasons, at the cost of performance, use ``TORCH_LOGS="compiled_autograd_verbose" python example.py``
+
+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.
+
+
+.. 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.
+
+Compiling the forward and backward pass using different flags
+-------------------------------------------------------------
+You can use different compiler configs for the two compilations, for example, the backward may be a fullgraph even if there are graph breaks in the forward.
+
+.. code:: python
+
+   def train(model, x):
+       model = torch.compile(model)
+       loss = model(x).sum()
+       torch._dynamo.config.compiled_autograd = True
+       torch.compile(lambda: loss.backward(), fullgraph=True)()
+
+Or you can use the context manager, which will apply to all autograd calls within its scope.
+
+.. code:: python
+
+   def train(model, x):
+      model = torch.compile(model)
+      loss = model(x).sum()
+      with torch._dynamo.compiled_autograd.enable(torch.compile(fullgraph=True)):
+         loss.backward()
+
+
+Compiled Autograd addresses certain limitations of AOTAutograd
+--------------------------------------------------------------
+1. Graph breaks in the forward pass no longer necessarily lead to graph breaks in the backward pass:
+
+.. code:: python
+
+   @torch.compile(backend="aot_eager")
+   def fn(x):
+      # 1st graph
+      temp = x + 10
+      torch._dynamo.graph_break()
+      # 2nd graph
+      temp = temp + 10
+      torch._dynamo.graph_break()
+      # 3rd graph
+      return temp.sum()
+
+   x = torch.randn(10, 10, requires_grad=True)
+   torch._dynamo.utils.counters.clear()
+   loss = fn(x)
+
+   # 1. base torch.compile 
+   loss.backward(retain_graph=True)
+   assert(torch._dynamo.utils.counters["stats"]["unique_graphs"] == 3)
+   torch._dynamo.utils.counters.clear()
+
+   # 2. torch.compile with compiled autograd
+   with torch._dynamo.compiled_autograd.enable(torch.compile(backend="aot_eager")):
+      loss.backward()
+
+   # single graph for the backward
+   assert(torch._dynamo.utils.counters["stats"]["unique_graphs"] == 1)
+
+
+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.
+
+.. 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
+
+   @torch.compile(backend="aot_eager")
+   def fn(x):
+      return x.sum()
+
+   x = torch.randn(10, 10, requires_grad=True)
+   x.register_hook(lambda grad: grad+10)
+   loss = fn(x)
+
+   with torch._dynamo.compiled_autograd.enable(torch.compile(backend="aot_eager")):
+      loss.backward()
+
+There should be a ``call_hook`` node in the graph, which dynamo will later inline into the following:
+
+.. image:: ../_static/img/compiled_autograd/call_hook_node.png
+
+Common recompilation reasons for Compiled Autograd
+--------------------------------------------------
+1. Due to changes in the autograd structure of the loss value:
+
+.. code:: python
+
+   torch._dynamo.config.compiled_autograd = True
+   x = torch.randn(10, requires_grad=True)
+   for op in [torch.add, torch.sub, torch.mul, torch.div]:
+      loss = op(x, x).sum()
+      torch.compile(lambda: loss.backward(), backend="eager")()
+
+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**.
+
+.. image:: ../_static/img/compiled_autograd/recompile_due_to_node.png
+
+2. Due to tensors changing shapes:
+
+.. code:: python
+
+   torch._dynamo.config.compiled_autograd = True
+   for i in [10, 100, 10]:
+      x = torch.randn(i, i, requires_grad=True)
+      loss = x.sum()
+      torch.compile(lambda: loss.backward(), backend="eager")()
+
+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**.
+
+.. image:: ../_static/img/compiled_autograd/recompile_due_to_dynamic.png
+
+Conclusion
+----------
+In this tutorial, we went over the high-level ecosystem of ``torch.compile`` with compiled autograd, the basics of compiled autograd and a few common recompilation reasons. Stay tuned for deep dives on `dev-discuss <https://dev-discuss.pytorch.org/>`_.
diff --git a/intermediate_source/custom_function_conv_bn_tutorial.py b/intermediate_source/custom_function_conv_bn_tutorial.py
new file mode 100644
index 00000000000..a9fcd8838ae
--- /dev/null
+++ b/intermediate_source/custom_function_conv_bn_tutorial.py
@@ -0,0 +1,394 @@
+# -*- coding: utf-8 -*-
+"""
+Fusing Convolution and Batch Norm using Custom Function
+=======================================================
+
+Fusing adjacent convolution and batch norm layers together is typically an
+inference-time optimization to improve run-time. It is usually achieved
+by eliminating the batch norm layer entirely and updating the weight
+and bias of the preceding convolution [0]. However, this technique is not
+applicable for training models.
+
+In this tutorial, we will show a different technique to fuse the two layers
+that can be applied during training. Rather than improved runtime, the
+objective of this optimization is to reduce memory usage.
+
+The idea behind this optimization is to see that both convolution and
+batch norm (as well as many other ops) need to save a copy of their input
+during forward for the backward pass. For large
+batch sizes, these saved inputs are responsible for most of your memory usage,
+so being able to avoid allocating another input tensor for every
+convolution batch norm pair can be a significant reduction.
+
+In this tutorial, we avoid this extra allocation by combining convolution
+and batch norm into a single layer (as a custom function). In the forward
+of this combined layer, we perform normal convolution and batch norm as-is,
+with the only difference being that we will only save the inputs to the convolution.
+To obtain the input of batch norm, which is necessary to backward through
+it, we recompute convolution forward again during the backward pass.
+
+It is important to note that the usage of this optimization is situational.
+Though (by avoiding one buffer saved) we always reduce the memory allocated at
+the end of the forward pass, there are cases when the *peak* memory allocated
+may not actually be reduced. See the final section for more details.
+
+For simplicity, in this tutorial we hardcode `bias=False`, `stride=1`, `padding=0`, `dilation=1`,
+and `groups=1` for Conv2D. For BatchNorm2D, we hardcode `eps=1e-3`, `momentum=0.1`,
+`affine=False`, and `track_running_statistics=False`. Another small difference
+is that we add epsilon in the denominator outside of the square root in the computation
+of batch norm.
+
+[0] https://nenadmarkus.com/p/fusing-batchnorm-and-conv/
+"""
+
+######################################################################
+# Backward Formula Implementation for Convolution
+# -------------------------------------------------------------------
+# Implementing a custom function requires us to implement the backward
+# ourselves. In this case, we need both the backward formulas for Conv2D
+# and BatchNorm2D. Eventually we'd chain them together in our unified
+# backward function, but below we first implement them as their own
+# custom functions so we can validate their correctness individually
+import torch
+from torch.autograd.function import once_differentiable
+import torch.nn.functional as F
+
+def convolution_backward(grad_out, X, weight):
+    grad_input = F.conv2d(X.transpose(0, 1), grad_out.transpose(0, 1)).transpose(0, 1)
+    grad_X = F.conv_transpose2d(grad_out, weight)
+    return grad_X, grad_input
+
+class Conv2D(torch.autograd.Function):
+    @staticmethod
+    def forward(ctx, X, weight):
+        ctx.save_for_backward(X, weight)
+        return F.conv2d(X, weight)
+
+    # Use @once_differentiable by default unless we intend to double backward
+    @staticmethod
+    @once_differentiable
+    def backward(ctx, grad_out):
+        X, weight = ctx.saved_tensors
+        return convolution_backward(grad_out, X, weight)
+
+######################################################################
+# When testing with ``gradcheck``, it is important to use double precision
+weight = torch.rand(5, 3, 3, 3, requires_grad=True, dtype=torch.double)
+X = torch.rand(10, 3, 7, 7, requires_grad=True, dtype=torch.double)
+torch.autograd.gradcheck(Conv2D.apply, (X, weight))
+
+######################################################################
+# Backward Formula Implementation for Batch Norm
+# -------------------------------------------------------------------
+# Batch Norm has two modes: training and ``eval`` mode. In training mode
+# the sample statistics are a function of the inputs. In ``eval`` mode,
+# we use the saved running statistics, which are not a function of the inputs.
+# This makes non-training mode's backward significantly simpler. Below
+# we implement and test only the training mode case.
+def unsqueeze_all(t):
+    # Helper function to ``unsqueeze`` all the dimensions that we reduce over
+    return t[None, :, None, None]
+
+def batch_norm_backward(grad_out, X, sum, sqrt_var, N, eps):
+    # We use the formula: ``out = (X - mean(X)) / (sqrt(var(X)) + eps)``
+    # in batch norm 2D forward. To simplify our derivation, we follow the
+    # chain rule and compute the gradients as follows before accumulating
+    # them all into a final grad_input.
+    #  1) ``grad of out wrt var(X)`` * ``grad of var(X) wrt X``
+    #  2) ``grad of out wrt mean(X)`` * ``grad of mean(X) wrt X``
+    #  3) ``grad of out wrt X in the numerator`` * ``grad of X wrt X``
+    # We then rewrite the formulas to use as few extra buffers as possible
+    tmp = ((X - unsqueeze_all(sum) / N) * grad_out).sum(dim=(0, 2, 3))
+    tmp *= -1
+    d_denom = tmp / (sqrt_var + eps)**2  # ``d_denom = -num / denom**2``
+    # It is useful to delete tensors when you no longer need them with ``del``
+    # For example, we could've done ``del tmp`` here because we won't use it later
+    # In this case, it's not a big difference because ``tmp`` only has size of (C,)
+    # The important thing is avoid allocating NCHW-sized tensors unnecessarily
+    d_var = d_denom / (2 * sqrt_var)  # ``denom = torch.sqrt(var) + eps``
+    # Compute ``d_mean_dx`` before allocating the final NCHW-sized grad_input buffer
+    d_mean_dx = grad_out / unsqueeze_all(sqrt_var + eps)
+    d_mean_dx = unsqueeze_all(-d_mean_dx.sum(dim=(0, 2, 3)) / N)
+    # ``d_mean_dx`` has already been reassigned to a C-sized buffer so no need to worry
+
+    # ``(1) unbiased_var(x) = ((X - unsqueeze_all(mean))**2).sum(dim=(0, 2, 3)) / (N - 1)``
+    grad_input = X * unsqueeze_all(d_var * N)
+    grad_input += unsqueeze_all(-d_var * sum)
+    grad_input *= 2 / ((N - 1) * N)
+    # (2) mean (see above)
+    grad_input += d_mean_dx
+    # (3) Add 'grad_out / <factor>' without allocating an extra buffer
+    grad_input *= unsqueeze_all(sqrt_var + eps)
+    grad_input += grad_out
+    grad_input /= unsqueeze_all(sqrt_var + eps)  # ``sqrt_var + eps > 0!``
+    return grad_input
+
+class BatchNorm(torch.autograd.Function):
+    @staticmethod
+    def forward(ctx, X, eps=1e-3):
+        # Don't save ``keepdim`` values for backward
+        sum = X.sum(dim=(0, 2, 3))
+        var = X.var(unbiased=True, dim=(0, 2, 3))
+        N = X.numel() / X.size(1)
+        sqrt_var = torch.sqrt(var)
+        ctx.save_for_backward(X)
+        ctx.eps = eps
+        ctx.sum = sum
+        ctx.N = N
+        ctx.sqrt_var = sqrt_var
+        mean = sum / N
+        denom = sqrt_var + eps
+        out = X - unsqueeze_all(mean)
+        out /= unsqueeze_all(denom)
+        return out
+
+    @staticmethod
+    @once_differentiable
+    def backward(ctx, grad_out):
+        X, = ctx.saved_tensors
+        return batch_norm_backward(grad_out, X, ctx.sum, ctx.sqrt_var, ctx.N, ctx.eps)
+
+######################################################################
+# Testing with ``gradcheck``
+a = torch.rand(1, 2, 3, 4, requires_grad=True, dtype=torch.double)
+torch.autograd.gradcheck(BatchNorm.apply, (a,), fast_mode=False)
+
+######################################################################
+# Fusing Convolution and BatchNorm
+# -------------------------------------------------------------------
+# Now that the bulk of the work has been done, we can combine
+# them together. Note that in (1) we only save a single buffer
+# for backward, but this also means we recompute convolution forward
+# in (5). Also see that in (2), (3), (4), and (6), it's the same
+# exact code as the examples above.
+class FusedConvBN2DFunction(torch.autograd.Function):
+    @staticmethod
+    def forward(ctx, X, conv_weight, eps=1e-3):
+        assert X.ndim == 4  # N, C, H, W
+        # (1) Only need to save this single buffer for backward!
+        ctx.save_for_backward(X, conv_weight)
+
+        # (2) Exact same Conv2D forward from example above
+        X = F.conv2d(X, conv_weight)
+        # (3) Exact same BatchNorm2D forward from example above
+        sum = X.sum(dim=(0, 2, 3))
+        var = X.var(unbiased=True, dim=(0, 2, 3))
+        N = X.numel() / X.size(1)
+        sqrt_var = torch.sqrt(var)
+        ctx.eps = eps
+        ctx.sum = sum
+        ctx.N = N
+        ctx.sqrt_var = sqrt_var
+        mean = sum / N
+        denom = sqrt_var + eps
+        # Try to do as many things in-place as possible
+        # Instead of `out = (X - a) / b`, doing `out = X - a; out /= b`
+        # avoids allocating one extra NCHW-sized buffer here
+        out = X - unsqueeze_all(mean)
+        out /= unsqueeze_all(denom)
+        return out
+
+    @staticmethod
+    def backward(ctx, grad_out):
+        X, conv_weight, = ctx.saved_tensors
+        # (4) Batch norm backward
+        # (5) We need to recompute conv
+        X_conv_out = F.conv2d(X, conv_weight)
+        grad_out = batch_norm_backward(grad_out, X_conv_out, ctx.sum, ctx.sqrt_var,
+                                       ctx.N, ctx.eps)
+        # (6) Conv2d backward
+        grad_X, grad_input = convolution_backward(grad_out, X, conv_weight)
+        return grad_X, grad_input, None, None, None, None, None
+
+######################################################################
+# The next step is to wrap our functional variant in a stateful
+# `nn.Module`
+import torch.nn as nn
+import math
+
+class FusedConvBN(nn.Module):
+    def __init__(self, in_channels, out_channels, kernel_size, exp_avg_factor=0.1,
+                 eps=1e-3, device=None, dtype=None):
+        super(FusedConvBN, self).__init__()
+        factory_kwargs = {'device': device, 'dtype': dtype}
+        # Conv parameters
+        weight_shape = (out_channels, in_channels, kernel_size, kernel_size)
+        self.conv_weight = nn.Parameter(torch.empty(*weight_shape, **factory_kwargs))
+        # Batch norm parameters
+        num_features = out_channels
+        self.num_features = num_features
+        self.eps = eps
+        # Initialize
+        self.reset_parameters()
+
+    def forward(self, X):
+        return FusedConvBN2DFunction.apply(X, self.conv_weight, self.eps)
+
+    def reset_parameters(self) -> None:
+        nn.init.kaiming_uniform_(self.conv_weight, a=math.sqrt(5))
+
+######################################################################
+# Use ``gradcheck`` to validate the correctness of our backward formula
+weight = torch.rand(5, 3, 3, 3, requires_grad=True, dtype=torch.double)
+X = torch.rand(2, 3, 4, 4, requires_grad=True, dtype=torch.double)
+torch.autograd.gradcheck(FusedConvBN2DFunction.apply, (X, weight))
+
+######################################################################
+# Testing out our new Layer
+# -------------------------------------------------------------------
+# Use ``FusedConvBN`` to train a basic network
+# The code below is after some light modifications to the example here:
+# https://github.com/pytorch/examples/tree/master/mnist
+import torch.optim as optim
+from torchvision import datasets, transforms
+from torch.optim.lr_scheduler import StepLR
+
+# Record memory allocated at the end of the forward pass
+memory_allocated = [[],[]]
+
+class Net(nn.Module):
+    def __init__(self, fused=True):
+        super(Net, self).__init__()
+        self.fused = fused
+        if fused:
+            self.convbn1 = FusedConvBN(1, 32, 3)
+            self.convbn2 = FusedConvBN(32, 64, 3)
+        else:
+            self.conv1 = nn.Conv2d(1, 32, 3, 1, bias=False)
+            self.bn1 = nn.BatchNorm2d(32, affine=False, track_running_stats=False)
+            self.conv2 = nn.Conv2d(32, 64, 3, 1, bias=False)
+            self.bn2 = nn.BatchNorm2d(64, affine=False, track_running_stats=False)
+        self.fc1 = nn.Linear(9216, 128)
+        self.dropout = nn.Dropout(0.5)
+        self.fc2 = nn.Linear(128, 10)
+
+    def forward(self, x):
+        if self.fused:
+            x = self.convbn1(x)
+        else:
+            x = self.conv1(x)
+            x = self.bn1(x)
+        F.relu_(x)
+        if self.fused:
+            x = self.convbn2(x)
+        else:
+            x = self.conv2(x)
+            x = self.bn2(x)
+        F.relu_(x)
+        x = F.max_pool2d(x, 2)
+        F.relu_(x)
+        x = x.flatten(1)
+        x = self.fc1(x)
+        x = self.dropout(x)
+        F.relu_(x)
+        x = self.fc2(x)
+        output = F.log_softmax(x, dim=1)
+        if fused:
+            memory_allocated[0].append(torch.cuda.memory_allocated())
+        else:
+            memory_allocated[1].append(torch.cuda.memory_allocated())
+        return output
+
+def train(model, device, train_loader, optimizer, epoch):
+    model.train()
+    for batch_idx, (data, target) in enumerate(train_loader):
+        data, target = data.to(device), target.to(device)
+        optimizer.zero_grad()
+        output = model(data)
+        loss = F.nll_loss(output, target)
+        loss.backward()
+        optimizer.step()
+        if batch_idx % 2 == 0:
+            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
+                epoch, batch_idx * len(data), len(train_loader.dataset),
+                100. * batch_idx / len(train_loader), loss.item()))
+
+def test(model, device, test_loader):
+    model.eval()
+    test_loss = 0
+    correct = 0
+    # Use inference mode instead of no_grad, for free improved test-time performance
+    with torch.inference_mode():
+        for data, target in test_loader:
+            data, target = data.to(device), target.to(device)
+            output = model(data)
+            # sum up batch loss
+            test_loss += F.nll_loss(output, target, reduction='sum').item()
+            # get the index of the max log-probability
+            pred = output.argmax(dim=1, keepdim=True)
+            correct += pred.eq(target.view_as(pred)).sum().item()
+
+    test_loss /= len(test_loader.dataset)
+
+    print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
+        test_loss, correct, len(test_loader.dataset),
+        100. * correct / len(test_loader.dataset)))
+
+use_cuda = torch.cuda.is_available()
+device = torch.device("cuda" if use_cuda else "cpu")
+train_kwargs = {'batch_size': 2048}
+test_kwargs = {'batch_size': 2048}
+
+if use_cuda:
+    cuda_kwargs = {'num_workers': 1,
+                   'pin_memory': True,
+                   'shuffle': True}
+    train_kwargs.update(cuda_kwargs)
+    test_kwargs.update(cuda_kwargs)
+
+transform = transforms.Compose([
+    transforms.ToTensor(),
+    transforms.Normalize((0.1307,), (0.3081,))
+])
+dataset1 = datasets.MNIST('../data', train=True, download=True,
+                          transform=transform)
+dataset2 = datasets.MNIST('../data', train=False,
+                          transform=transform)
+train_loader = torch.utils.data.DataLoader(dataset1, **train_kwargs)
+test_loader = torch.utils.data.DataLoader(dataset2, **test_kwargs)
+
+######################################################################
+# A Comparison of Memory Usage
+# -------------------------------------------------------------------
+# If CUDA is enabled, print out memory usage for both `fused=True` and `fused=False`
+# For an example run on NVIDIA GeForce RTX 3070, NVIDIA CUDA® Deep Neural Network library (cuDNN) 8.0.5: fused peak memory: 1.56GB,
+# unfused peak memory: 2.68GB
+#
+# It is important to note that the *peak* memory usage for this model may vary depending
+# the specific cuDNN convolution algorithm used. For shallower models, it
+# may be possible for the peak memory allocated of the fused model to exceed
+# that of the unfused model! This is because the memory allocated to compute
+# certain cuDNN convolution algorithms can be high enough to "hide" the typical peak
+# you would expect to be near the start of the backward pass.
+#
+# For this reason, we also record and display the memory allocated at the end
+# of the forward pass as an approximation, and to demonstrate that we indeed
+# allocate one fewer buffer per fused ``conv-bn`` pair.
+from statistics import mean
+
+torch.backends.cudnn.enabled = True
+
+if use_cuda:
+    peak_memory_allocated = []
+
+    for fused in (True, False):
+        torch.manual_seed(123456)
+
+        model = Net(fused=fused).to(device)
+        optimizer = optim.Adadelta(model.parameters(), lr=1.0)
+        scheduler = StepLR(optimizer, step_size=1, gamma=0.7)
+
+        for epoch in range(1):
+            train(model, device, train_loader, optimizer, epoch)
+            test(model, device, test_loader)
+            scheduler.step()
+        peak_memory_allocated.append(torch.cuda.max_memory_allocated())
+        torch.cuda.reset_peak_memory_stats()
+    print("cuDNN version:", torch.backends.cudnn.version())
+    print()
+    print("Peak memory allocated:")
+    print(f"fused: {peak_memory_allocated[0]/1024**3:.2f}GB, unfused: {peak_memory_allocated[1]/1024**3:.2f}GB")
+    print("Memory allocated at end of forward pass:")
+    print(f"fused: {mean(memory_allocated[0])/1024**3:.2f}GB, unfused: {mean(memory_allocated[1])/1024**3:.2f}GB")
+
+
diff --git a/intermediate_source/custom_function_double_backward_tutorial.rst b/intermediate_source/custom_function_double_backward_tutorial.rst
new file mode 100644
index 00000000000..bbb7701f185
--- /dev/null
+++ b/intermediate_source/custom_function_double_backward_tutorial.rst
@@ -0,0 +1,301 @@
+Double Backward with Custom Functions
+=====================================
+
+It is sometimes useful to run backwards twice through backward graph, for
+example to compute higher-order gradients. It takes an understanding of
+autograd and some care to support double backwards, however. Functions
+that support performing backward a single time are not necessarily
+equipped to support double backward. In this tutorial we show how to
+write a custom autograd function that supports double backward, and
+point out some things to look out for.
+
+
+When writing a custom autograd function to backward through twice,
+it is important to know when operations performed in a custom function
+are recorded by autograd, when they aren't, and most importantly, how
+`save_for_backward` works with all of this.
+
+Custom functions implicitly affects grad mode in two ways:
+
+- During forward, autograd does not record any the graph for any
+  operations performed within the forward function. When forward
+  completes, the backward function of the custom function
+  becomes the `grad_fn` of each of the forward's outputs
+
+- During backward, autograd records the computation graph used to
+  compute the backward pass if create_graph is specified
+
+Next, to understand how `save_for_backward` interacts with the above,
+we can explore a couple examples:
+
+
+Saving the Inputs
+-------------------------------------------------------------------
+Consider this simple squaring function. It saves an input tensor
+for backward. Double backward works automatically when autograd
+is able to record operations in the backward pass, so there is usually
+nothing to worry about when we save an input for backward as
+the input should have grad_fn if it is a function of any tensor
+that requires grad. This allows the gradients to be properly propagated.
+
+.. code:: python
+
+    import torch
+
+    class Square(torch.autograd.Function):
+        @staticmethod
+        def forward(ctx, x):
+            # Because we are saving one of the inputs use `save_for_backward`
+            # Save non-tensors and non-inputs/non-outputs directly on ctx
+            ctx.save_for_backward(x)
+            return x**2
+
+        @staticmethod
+        def backward(ctx, grad_out):
+            # A function support double backward automatically if autograd
+            # is able to record the computations performed in backward
+            x, = ctx.saved_tensors
+            return grad_out * 2 * x
+
+    # Use double precision because finite differencing method magnifies errors
+    x = torch.rand(3, 3, requires_grad=True, dtype=torch.double)
+    torch.autograd.gradcheck(Square.apply, x)
+    # Use gradcheck to verify second-order derivatives
+    torch.autograd.gradgradcheck(Square.apply, x)
+
+
+We can use torchviz to visualize the graph to see why this works
+
+.. code-block:: python
+
+   import torchviz
+
+   x = torch.tensor(1., requires_grad=True).clone()
+   out = Square.apply(x)
+   grad_x, = torch.autograd.grad(out, x, create_graph=True)
+   torchviz.make_dot((grad_x, x, out), {"grad_x": grad_x, "x": x, "out": out})
+
+We can see that the gradient wrt to x, is itself a function of x (dout/dx = 2x)
+And the graph of this function has been properly constructed
+
+.. image:: https://user-images.githubusercontent.com/13428986/126559699-e04f3cb1-aaf2-4a9a-a83d-b8767d04fbd9.png
+   :width: 400
+
+
+Saving the Outputs
+-------------------------------------------------------------------
+A slight variation on the previous example is to save an output
+instead of input. The mechanics are similar because outputs are also
+associated with a grad_fn.
+
+.. code-block:: python
+
+    class Exp(torch.autograd.Function):
+        # Simple case where everything goes well
+        @staticmethod
+        def forward(ctx, x):
+            # This time we save the output
+            result = torch.exp(x)
+            # Note that we should use `save_for_backward` here when
+            # the tensor saved is an ouptut (or an input).
+            ctx.save_for_backward(result)
+            return result
+
+        @staticmethod
+        def backward(ctx, grad_out):
+            result, = ctx.saved_tensors
+            return result * grad_out
+
+    x = torch.tensor(1., requires_grad=True, dtype=torch.double).clone()
+    # Validate our gradients using gradcheck
+    torch.autograd.gradcheck(Exp.apply, x)
+    torch.autograd.gradgradcheck(Exp.apply, x)
+
+Use torchviz to visualize the graph:
+
+.. code-block:: python
+
+   out = Exp.apply(x)
+   grad_x, = torch.autograd.grad(out, x, create_graph=True)
+   torchviz.make_dot((grad_x, x, out), {"grad_x": grad_x, "x": x, "out": out})
+
+.. image:: https://user-images.githubusercontent.com/13428986/126559780-d141f2ba-1ee8-4c33-b4eb-c9877b27a954.png
+   :width: 332
+
+
+Saving Intermediate Results
+-------------------------------------------------------------------
+A more tricky case is when we need to save an intermediate result.
+We demonstrate this case by implementing:
+
+.. math::
+  sinh(x) := \frac{e^x - e^{-x}}{2}
+
+Since the derivative of sinh is cosh, it might be useful to reuse
+`exp(x)` and `exp(-x)`, the two intermediate results in forward
+in the backward computation.
+
+Intermediate results should not be directly saved and used in backward though.
+Because forward is performed in no-grad mode, if an intermediate result
+of the forward pass is used to compute gradients in the backward pass
+the backward graph of the gradients would not include the operations
+that computed the intermediate result. This leads to incorrect gradients.
+
+.. code-block:: python
+
+    class Sinh(torch.autograd.Function):
+        @staticmethod
+        def forward(ctx, x):
+            expx = torch.exp(x)
+            expnegx = torch.exp(-x)
+            ctx.save_for_backward(expx, expnegx)
+            # In order to be able to save the intermediate results, a trick is to
+            # include them as our outputs, so that the backward graph is constructed
+            return (expx - expnegx) / 2, expx, expnegx
+
+        @staticmethod
+        def backward(ctx, grad_out, _grad_out_exp, _grad_out_negexp):
+            expx, expnegx = ctx.saved_tensors
+            grad_input = grad_out * (expx + expnegx) / 2
+            # We cannot skip accumulating these even though we won't use the outputs
+            # directly. They will be used later in the second backward.
+            grad_input += _grad_out_exp * expx
+            grad_input -= _grad_out_negexp * expnegx
+            return grad_input
+
+    def sinh(x):
+        # Create a wrapper that only returns the first output
+        return Sinh.apply(x)[0]
+
+    x = torch.rand(3, 3, requires_grad=True, dtype=torch.double)
+    torch.autograd.gradcheck(sinh, x)
+    torch.autograd.gradgradcheck(sinh, x)
+
+
+Use torchviz to visualize the graph:
+
+.. code-block:: python
+
+   out = sinh(x)
+   grad_x, = torch.autograd.grad(out.sum(), x, create_graph=True)
+   torchviz.make_dot((grad_x, x, out), params={"grad_x": grad_x, "x": x, "out": out})
+
+.. image:: https://user-images.githubusercontent.com/13428986/126560494-e48eba62-be84-4b29-8c90-a7f6f40b1438.png
+   :width: 460
+
+
+Saving Intermediate Results: What not to do
+-------------------------------------------------------------------
+Now we show what happens when we don't also return our intermediate
+results as outputs: `grad_x` would not even have a  backward graph
+because it is purely a function `exp` and `expnegx`, which don't
+require grad.
+
+.. code-block:: python
+
+    class SinhBad(torch.autograd.Function):
+        # This is an example of what NOT to do!
+        @staticmethod
+        def forward(ctx, x):
+            expx = torch.exp(x)
+            expnegx = torch.exp(-x)
+            ctx.expx = expx
+            ctx.expnegx = expnegx
+            return (expx - expnegx) / 2
+
+        @staticmethod
+        def backward(ctx, grad_out):
+            expx = ctx.expx
+            expnegx = ctx.expnegx
+            grad_input = grad_out * (expx + expnegx) / 2
+            return grad_input
+
+
+Use torchviz to visualize the graph. Notice that `grad_x` is not
+part of the graph!
+
+.. code-block:: python
+
+   out = SinhBad.apply(x)
+   grad_x, = torch.autograd.grad(out.sum(), x, create_graph=True)
+   torchviz.make_dot((grad_x, x, out), params={"grad_x": grad_x, "x": x, "out": out})
+
+.. image:: https://user-images.githubusercontent.com/13428986/126565889-13992f01-55bc-411a-8aee-05b721fe064a.png
+   :width: 232
+
+
+
+When Backward is not Tracked
+-------------------------------------------------------------------
+Finally, let's consider an example when it may not be possible for
+autograd to track gradients for a functions backward at all.
+We can imagine cube_backward to be a function that may require a
+non-PyTorch library like SciPy or NumPy, or written as a
+C++ extension. The workaround demonstrated here is to create another
+custom function CubeBackward where you also manually specify the
+backward of cube_backward!
+
+
+.. code-block:: python
+
+    def cube_forward(x):
+        return x**3
+
+    def cube_backward(grad_out, x):
+        return grad_out * 3 * x**2
+
+    def cube_backward_backward(grad_out, sav_grad_out, x):
+        return grad_out * sav_grad_out * 6 * x
+
+    def cube_backward_backward_grad_out(grad_out, x):
+        return grad_out * 3 * x**2
+
+    class Cube(torch.autograd.Function):
+        @staticmethod
+        def forward(ctx, x):
+            ctx.save_for_backward(x)
+            return cube_forward(x)
+
+        @staticmethod
+        def backward(ctx, grad_out):
+            x, = ctx.saved_tensors
+            return CubeBackward.apply(grad_out, x)
+
+    class CubeBackward(torch.autograd.Function):
+        @staticmethod
+        def forward(ctx, grad_out, x):
+            ctx.save_for_backward(x, grad_out)
+            return cube_backward(grad_out, x)
+
+        @staticmethod
+        def backward(ctx, grad_out):
+            x, sav_grad_out = ctx.saved_tensors
+            dx = cube_backward_backward(grad_out, sav_grad_out, x)
+            dgrad_out = cube_backward_backward_grad_out(grad_out, x)
+            return dgrad_out, dx
+
+    x = torch.tensor(2., requires_grad=True, dtype=torch.double)
+
+    torch.autograd.gradcheck(Cube.apply, x)
+    torch.autograd.gradgradcheck(Cube.apply, x)
+
+
+Use torchviz to visualize the graph:
+
+.. code-block:: python
+
+   out = Cube.apply(x)
+   grad_x, = torch.autograd.grad(out, x, create_graph=True)
+   torchviz.make_dot((grad_x, x, out), params={"grad_x": grad_x, "x": x, "out": out})
+
+.. image:: https://user-images.githubusercontent.com/13428986/126559935-74526b4d-d419-4983-b1f0-a6ee99428531.png
+   :width: 352
+
+
+To conclude, whether double backward works for your custom function
+simply depends on whether the backward pass can be tracked by autograd.
+With the first two examples we show situations where double backward
+works out of the box. With the third and fourth examples, we demonstrate
+techniques that enable a backward function to be tracked, when they
+otherwise would not be.
+
diff --git a/intermediate_source/ddp_series_minGPT.rst b/intermediate_source/ddp_series_minGPT.rst
new file mode 100644
index 00000000000..27e63996f75
--- /dev/null
+++ b/intermediate_source/ddp_series_minGPT.rst
@@ -0,0 +1,86 @@
+`Introduction <../beginner/ddp_series_intro.html>`__ \|\| `What is DDP <../beginner/ddp_series_theory.html>`__ \|\| `Single-Node
+Multi-GPU Training <../beginner/ddp_series_multigpu.html>`__ \|\| `Fault
+Tolerance <../beginner/ddp_series_fault_tolerance.html>`__ \|\| `Multi-Node
+training <ddp_series_multinode.html>`__ \|\| **minGPT Training**
+
+Training “real-world” models with DDP
+=====================================
+
+Authors: `Suraj Subramanian <https://github.com/subramen>`__
+
+.. grid:: 2
+
+   .. grid-item-card:: :octicon:`mortar-board;1em;` What you will learn
+      :class-card: card-prerequisites
+
+      -  Best practices when writing a distributed training script
+      -  Increased flexibility with saving/loading artifacts in the cloud
+      -  When DDP is NOT suitable
+
+      .. grid:: 1
+
+         .. grid-item::
+
+            :octicon:`code-square;1.0em;` View the code used in this tutorial on `GitHub <https://github.com/pytorch/examples/tree/main/distributed/minGPT-ddp>`__
+
+   .. grid-item-card:: :octicon:`list-unordered;1em;` Prerequisites
+      :class-card: card-prerequisites
+
+      - PyTorch `installed <https://pytorch.org/get-started/locally/>`__ with CUDA on all machines
+      - Familiarity with `multi-GPU training <../beginner/ddp_series_multigpu.html>`__ and `torchrun <../beginner/ddp_series_fault_tolerance.html>`__
+      - [Optional] Familiarity with `multinode training <ddp_series_multinode.html>`__
+      - 2 or more TCP-reachable GPU machines for multi-node training (this tutorial uses AWS p3.2xlarge instances)
+
+
+Follow along with the video below or on `youtube <https://www.youtube.com/watch/XFsFDGKZHh4>`__.
+
+.. raw:: html
+
+   <div style="margin-top:10px; margin-bottom:10px;">
+     <iframe width="560" height="315" src="https://www.youtube.com/embed/XFsFDGKZHh4" frameborder="0" allow="accelerometer; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
+   </div>
+
+In this video, we will review the process of training a GPT model in multinode DDP.
+We first clone the `minGPT repo <https://github.com/karpathy/minGPT>`__ and refactor the Trainer
+to resemble the structure we have used in this series. Watch the video for details on these changes.
+
+We use `hydra <https://hydra.cc/>`__ to centrally manage all the configurations for our training run.
+Once the code has been refactored, we run it first on a single-node with 4 GPUs, and then on a slurm cluster.
+
+Files used for training
+~~~~~~~~~~~~~~~~~~~~~~~~
+- `trainer.py <https://github.com/pytorch/examples/blob/main/distributed/minGPT-ddp/mingpt/trainer.py>`__ includes the Trainer class that runs the distributed training iterations on the model with the provided dataset.
+- `model.py <https://github.com/pytorch/examples/blob/main/distributed/minGPT-ddp/mingpt/model.py>`__ defines the model architecture.
+- `char_dataset.py <https://github.com/pytorch/examples/blob/main/distributed/minGPT-ddp/mingpt/char_dataset.py>`__ contains the ``Dataset`` class for a character-level dataset.
+- `gpt2_train_cfg.yaml <https://github.com/pytorch/examples/blob/main/distributed/minGPT-ddp/mingpt/gpt2_train_cfg.yaml>`__ contains the configurations for data, model, optimizer, and training run.
+- `main.py <https://github.com/pytorch/examples/blob/main/distributed/minGPT-ddp/mingpt/main.py>`__ is the entry point to the training job. It sets up the DDP process group, reads all the configurations and runs the training job.
+
+
+Saving and Loading from the cloud
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+In the video above, we save training snapshots directly to the cloud. This gives us the flexibility to continue training
+from any node that has access to the cloud bucket.
+
+
+Using Mixed Precision
+~~~~~~~~~~~~~~~~~~~~~~~~
+To speed things up, you might be able to use `Mixed Precision <https://pytorch.org/docs/stable/amp.html>`__ to train your models.
+In Mixed Precision, some parts of the training process are carried out in reduced precision, while other steps
+that are more sensitive to precision drops are maintained in FP32 precision.
+
+
+When is DDP not enough?
+~~~~~~~~~~~~~~~~~~~~~~~~
+A typical training run's memory footprint consists of model weights, activations, gradients, the input batch, and the optimizer state.
+Since DDP replicates the model on each GPU, it only works when GPUs have sufficient capacity to accomodate the full footprint.
+When models grow larger, more aggressive techniques might be useful:
+
+-  `Activation checkpointing <https://pytorch.org/docs/stable/checkpoint.html>`__: Instead of saving intermediate activations during the forward pass, the activations are recomputed during the backward pass. In this approach, we run more compute but save on memory footprint.
+-  `Fully-Sharded Data Parallel <https://docs.pytorch.org/docs/stable/distributed.fsdp.fully_shard.html>`__: Here the model is not replicated but "sharded" across all the GPUs, and computation is overlapped with communication in the forward and backward passes. Read our `blog <https://medium.com/pytorch/training-a-1-trillion-parameter-model-with-pytorch-fully-sharded-data-parallel-on-aws-3ac13aa96cff>`__ to learn how we trained a 1 Trillion parameter model with FSDP.
+
+Further Reading
+---------------
+-  `Multi-Node training with DDP <ddp_series_multinode.html>`__ (previous tutorial in this series)
+-  `Mixed Precision training <https://pytorch.org/docs/stable/amp.html>`__
+-  `Fully-Sharded Data Parallel tutorial <https://docs.pytorch.org/tutorials/intermediate/FSDP_tutorial.html>`__
+-  `Training a 1T parameter model with FSDP <https://medium.com/pytorch/training-a-1-trillion-parameter-model-with-pytorch-fully-sharded-data-parallel-on-aws-3ac13aa96cff>`__
diff --git a/intermediate_source/ddp_series_multinode.rst b/intermediate_source/ddp_series_multinode.rst
new file mode 100644
index 00000000000..8746eb19bbd
--- /dev/null
+++ b/intermediate_source/ddp_series_multinode.rst
@@ -0,0 +1,94 @@
+`Introduction <../beginner/ddp_series_intro.html>`__ \|\| `What is DDP <../beginner/ddp_series_theory.html>`__ \|\| `Single-Node
+Multi-GPU Training <../beginner/ddp_series_multigpu.html>`__ \|\| `Fault
+Tolerance <../beginner/ddp_series_fault_tolerance.html>`__ \|\| **Multi-Node
+training** \|\| `minGPT Training <ddp_series_minGPT.html>`__
+
+Multinode Training
+==================
+
+Authors: `Suraj Subramanian <https://github.com/subramen>`__
+
+.. grid:: 2
+
+   .. grid-item-card:: :octicon:`mortar-board;1em;` What you will learn
+      :class-card: card-prerequisites
+
+      -  Launching multinode training jobs with ``torchrun``
+      -  Code changes (and things to keep in mind) when moving from single-node to multinode training.
+
+      .. 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/multinode.py>`__
+
+   .. grid-item-card:: :octicon:`list-unordered;1em;` Prerequisites
+      :class-card: card-prerequisites
+
+      -  Familiarity with `multi-GPU training <../beginner/ddp_series_multigpu.html>`__ and `torchrun <../beginner/ddp_series_fault_tolerance.html>`__ 
+      -  2 or more TCP-reachable GPU machines (this tutorial uses AWS p3.2xlarge instances)
+      -  PyTorch `installed <https://pytorch.org/get-started/locally/>`__ with CUDA on all machines
+
+Follow along with the video below or on `youtube <https://www.youtube.com/watch/KaAJtI1T2x4>`__. 
+
+.. raw:: html
+
+   <div style="margin-top:10px; margin-bottom:10px;">
+     <iframe width="560" height="315" src="https://www.youtube.com/embed/KaAJtI1T2x4" frameborder="0" allow="accelerometer; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
+   </div>
+
+Multinode training involves deploying a training job across several
+machines. There are two ways to do this:
+
+-  running a ``torchrun`` command on each machine with identical rendezvous arguments, or
+-  deploying it on a compute cluster using a workload manager (like SLURM)
+
+In this video we will go over the (minimal) code changes required to move from single-node multigpu to
+multinode training, and run our training script in both of the above ways.
+
+Note that multinode training is bottlenecked by inter-node communication latencies. Running a training job
+on 4 GPUs on a single node will be faster than running it on 4 nodes with 1 GPU each.
+
+Local and Global ranks
+~~~~~~~~~~~~~~~~~~~~~~~~
+In single-node settings, we were tracking the 
+``gpu_id`` of each device running our training process. ``torchrun`` tracks this value in an environment variable ``LOCAL_RANK``
+which uniquely identifies each GPU-process on a node. For a unique identifier across all the nodes, ``torchrun`` provides another variable
+``RANK`` which refers to the global rank of a process.
+
+.. warning::
+   Do not use ``RANK`` for critical logic in your training job. When ``torchrun`` restarts processes after a failure or membership changes, there is no guarantee
+   that the processes will hold the same ``LOCAL_RANK`` and ``RANKS``. 
+ 
+
+Heteregeneous Scaling
+~~~~~~~~~~~~~~~~~~~~~~
+Torchrun supports *heteregenous scaling* i.e. each of your multinode machines can have different number of 
+GPUs participating in the training job. In the video, I deployed the code on 2 machines where one machine has 4 GPUs and the
+other used only 2 GPUs.
+
+
+Troubleshooting
+~~~~~~~~~~~~~~~~~~
+
+-  Ensure that your nodes are able to communicate with each other over
+   TCP.
+-  Set env variable ``NCCL_DEBUG`` to ``INFO`` (using
+   ``export NCCL_DEBUG=INFO``) to print verbose logs that can help
+   diagnose the issue.
+-  Sometimes you might need to explicitly set the network interface for
+   the distributed backend (``export NCCL_SOCKET_IFNAME=eth0``). Read
+   more about this
+   `here <https://pytorch.org/docs/stable/distributed.html#choosing-the-network-interface-to-use>`__.
+
+
+Further Reading
+---------------
+-  `Training a GPT model with DDP <ddp_series_minGPT.html>`__  (next tutorial in this series)
+-  `Fault Tolerant distributed training <../beginner/ddp_series_fault_tolerance.html>`__ (previous tutorial in this series)
+-  `torchrun <https://pytorch.org/docs/stable/elastic/run.html>`__
+-  `Rendezvous
+   arguments <https://pytorch.org/docs/stable/elastic/run.html#note-on-rendezvous-backend>`__
+-  `Setting up a cluster on
+   AWS <https://github.com/pytorch/examples/blob/main/distributed/ddp-tutorial-series/slurm/setup_pcluster_slurm.md>`__
+-  `Slurm docs <https://slurm.schedmd.com/>`__
diff --git a/intermediate_source/ddp_tutorial.rst b/intermediate_source/ddp_tutorial.rst
index 18098b853c2..c63321ad14c 100644
--- a/intermediate_source/ddp_tutorial.rst
+++ b/intermediate_source/ddp_tutorial.rst
@@ -1,35 +1,82 @@
 Getting Started with Distributed Data Parallel
-=============================================
+=================================================
 **Author**: `Shen Li <https://mrshenli.github.io/>`_
 
-`DistributedDataParallel <https://pytorch.org/docs/stable/_modules/torch/nn/parallel/distributed.html>`__
-(DDP) implements data parallelism at the module level. It uses communication
-collectives in the `torch.distributed <https://pytorch.org/tutorials/intermediate/dist_tuto.html>`__
-package to synchronize gradients, parameters, and buffers. Parallelism is
-available both within a process and across processes. Within a process, DDP
-replicates the input module to devices specified in ``device_ids``, scatters
-inputs along the batch dimension accordingly, and gathers outputs to the
-``output_device``, which is similar to
-`DataParallel <https://pytorch.org/tutorials/beginner/blitz/data_parallel_tutorial.html>`__.
-Across processes, DDP inserts necessary parameter synchronizations in forward
-passes and gradient synchronizations in backward passes. It is up to users to
-map processes to available resources, as long as processes do not share GPU
-devices. The recommended (usually fastest) approach is to create a process for
-every module replica, i.e., no module replication within a process. The code in
-this tutorial runs on an 8-GPU server, but it can be easily generalized to
-other environments.
+**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>`__.
+
+Prerequisites:
+
+-  `PyTorch Distributed Overview <../beginner/dist_overview.html>`__
+-  `DistributedDataParallel API documents <https://pytorch.org/docs/master/generated/torch.nn.parallel.DistributedDataParallel.html>`__
+-  `DistributedDataParallel notes <https://pytorch.org/docs/master/notes/ddp.html>`__
+
+
+`DistributedDataParallel <https://pytorch.org/docs/stable/nn.html#module-torch.nn.parallel>`__
+(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 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).
+
+
+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::
+  The code in this tutorial runs on an 8-GPU server, but it can be easily
+  generalized to other environments.
+
+
+Comparison between ``DataParallel`` and ``DistributedDataParallel``
+-------------------------------------------------------------------
+
+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-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**, 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.
 
 Basic Use Case
 --------------
 
-To create DDP modules, first set up process groups properly. More details can
+To create a DDP module, you must first set up process groups properly. More details can
 be found in
-`WRITING DISTRIBUTED APPLICATIONS WITH PYTORCH <https://pytorch.org/tutorials/intermediate/dist_tuto.html>`__.
+`Writing Distributed Applications with PyTorch <https://pytorch.org/tutorials/intermediate/dist_tuto.html>`__.
 
 .. code:: python
 
     import os
+    import sys
     import tempfile
     import torch
     import torch.distributed as dist
@@ -39,26 +86,36 @@ be found in
 
     from torch.nn.parallel import DistributedDataParallel as DDP
 
+    # On Windows platform, the torch.distributed package only
+    # supports Gloo backend, FileStore and TcpStore.
+    # For FileStore, set init_method parameter in init_process_group
+    # to a local file. Example as follow:
+    # init_method="file:///f:/libtmp/some_file"
+    # dist.init_process_group(
+    #    "gloo",
+    #    rank=rank,
+    #    init_method=init_method,
+    #    world_size=world_size)
+    # For TcpStore, same way as on Linux.
 
     def setup(rank, world_size):
         os.environ['MASTER_ADDR'] = 'localhost'
         os.environ['MASTER_PORT'] = '12355'
 
+        # We want to be able to train our model on an `accelerator <https://pytorch.org/docs/stable/torch.html#accelerators>`__
+        # such as CUDA, MPS, MTIA, or XPU.
+        acc = torch.accelerator.current_accelerator()
+        backend = torch.distributed.get_default_backend_for_device(acc)
         # initialize the process group
-        dist.init_process_group("gloo", rank=rank, world_size=world_size)
-
-        # Explicitly setting seed to make sure that models created in two processes
-        # start from same random weights and biases.
-        torch.manual_seed(42)
-
+        dist.init_process_group(backend, rank=rank, world_size=world_size)
 
     def cleanup():
         dist.destroy_process_group()
 
-Now, let's create a toy module, wrap it with DDP, and feed it with some dummy
-input data. Please note, if training starts from random parameters, you might
-want to make sure that all DDP processes use the same initial values.
-Otherwise, global gradient synchronizes will not make sense.
+Now, let's create a toy module, wrap it with DDP, and feed it some dummy
+input data. Please note, as DDP broadcasts model states from rank 0 process to
+all other processes in the DDP constructor, you do not need to worry about
+different DDP processes starting from different initial model parameter values.
 
 .. code:: python
 
@@ -74,28 +131,24 @@ Otherwise, global gradient synchronizes will not make sense.
 
 
     def demo_basic(rank, world_size):
+        print(f"Running basic DDP example on rank {rank}.")
         setup(rank, world_size)
 
-        # setup devices for this process, rank 1 uses GPUs [0, 1, 2, 3] and
-        # rank 2 uses GPUs [4, 5, 6, 7].
-        n = torch.cuda.device_count() // world_size
-        device_ids = list(range(rank * n, (rank + 1) * n))
-
-        # create model and move it to device_ids[0]
-        model = ToyModel().to(device_ids[0])
-        # output_device defaults to device_ids[0]
-        ddp_model = DDP(model, device_ids=device_ids)
+        # create model and move it to GPU with id rank
+        model = ToyModel().to(rank)
+        ddp_model = DDP(model, device_ids=[rank])
 
         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(device_ids[0])
+        labels = torch.randn(20, 5).to(rank)
         loss_fn(outputs, labels).backward()
         optimizer.step()
 
         cleanup()
+        print(f"Finished running basic DDP example on rank {rank}.")
 
 
     def run_demo(demo_fn, world_size):
@@ -104,23 +157,27 @@ Otherwise, global gradient synchronizes will not make sense.
                  nprocs=world_size,
                  join=True)
 
-As you can see, DDP wraps lower level distributed communication details, and
-provides a clean API as if it is a local model. For basic use cases, DDP only
-requires a few more LoCs to set up the process group. When applying DDP to more
-advanced use cases, there are some caveats that require cautions.
+As you can see, DDP wraps lower-level distributed communication details and
+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 lines of code to set up the process group. When applying DDP to more
+advanced use cases, some caveats require caution.
 
 Skewed Processing Speeds
 ------------------------
 
-In DDP, constructor, forward method, and differentiation of the outputs are
-distributed synchronization points. Different processes are expected to reach
-synchronization points in the same order and enter each synchronization point
-at roughly the same time. Otherwise, fast processes might arrive early and
-timeout on waiting for stragglers. Hence, users are responsible for balancing
-workloads distributions across processes. Sometimes, skewed processing speeds
-are inevitable due to, e.g., network delays, resource contentions,
-unpredictable workload spikes. To avoid timeouts in these situations, make
-sure that you pass a sufficiently large ``timeout`` value when calling
+In DDP, the constructor, the forward pass, and the backward pass are
+distributed synchronization points. Different processes are expected to launch
+the same number of synchronizations and reach these synchronization points in
+the same order and enter each synchronization point at roughly the same time.
+Otherwise, fast processes might arrive early and timeout while waiting for
+stragglers. Hence, users are responsible for balancing workload distributions
+across processes. Sometimes, skewed processing speeds are inevitable due to,
+e.g., network delays, resource contentions, or unpredictable workload spikes. To
+avoid timeouts in these situations, make sure that you pass a sufficiently
+large ``timeout`` value when calling
 `init_process_group <https://pytorch.org/docs/stable/distributed.html#torch.distributed.init_process_group>`__.
 
 Save and Load Checkpoints
@@ -130,33 +187,28 @@ 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 same values. If you use this optimization, make sure all
-processes do not start loading before the saving is finished. Besides, when
+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 to step 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.
+same machine using the same set of devices. For more advanced failure recovery
+and elasticity support, please refer to `TorchElastic <https://pytorch.org/elastic>`__.
 
 .. code:: python
 
     def demo_checkpoint(rank, world_size):
+        print(f"Running DDP checkpoint example on rank {rank}.")
         setup(rank, world_size)
 
-        # setup devices for this process, rank 1 uses GPUs [0, 1, 2, 3] and
-        # rank 2 uses GPUs [4, 5, 6, 7].
-        n = torch.cuda.device_count() // world_size
-        device_ids = list(range(rank * n, (rank + 1) * n))
+        model = ToyModel().to(rank)
+        ddp_model = DDP(model, device_ids=[rank])
 
-        model = ToyModel().to(device_ids[0])
-        # output_device defaults to device_ids[0]
-        ddp_model = DDP(model, device_ids=device_ids)
-
-        loss_fn = nn.MSELoss()
-        optimizer = optim.SGD(ddp_model.parameters(), lr=0.001)
 
         CHECKPOINT_PATH = tempfile.gettempdir() + "/model.checkpoint"
         if rank == 0:
@@ -168,39 +220,39 @@ same machine using the same set of devices.
         # Use a barrier() to make sure that process 1 loads the model after process
         # 0 saves it.
         dist.barrier()
+        # We want to be able to train our model on an `accelerator <https://pytorch.org/docs/stable/torch.html#accelerators>`__
+        # such as CUDA, MPS, MTIA, or XPU.
+        acc = torch.accelerator.current_accelerator()
         # configure map_location properly
-        rank0_devices = [x - rank * len(device_ids) for x in device_ids]
-        device_pairs = zip(rank0_devices, device_ids)
-        map_location = {'cuda:%d' % x: 'cuda:%d' % y for x, y in device_pairs}
+        map_location = {f'{acc}:0': f'{acc}:{rank}'}
         ddp_model.load_state_dict(
-            torch.load(CHECKPOINT_PATH, map_location=map_location))
+            torch.load(CHECKPOINT_PATH, map_location=map_location, weights_only=True))
+
+        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(device_ids[0])
-        loss_fn = nn.MSELoss()
+        labels = torch.randn(20, 5).to(rank)
+
         loss_fn(outputs, labels).backward()
         optimizer.step()
 
-        # Use a barrier() to make sure that all processes have finished reading the
-        # checkpoint
-        dist.barrier()
+        # Not necessary to use a dist.barrier() to guard the file deletion below
+        # as the AllReduce ops in the backward pass of DDP already served as
+        # a synchronization.
 
         if rank == 0:
             os.remove(CHECKPOINT_PATH)
 
         cleanup()
+        print(f"Finished running DDP checkpoint example on rank {rank}.")
 
-Combine DDP with Model Parallelism
-----------------------------------
+Combining DDP with Model Parallelism
+------------------------------------
 
-DDP also works with multi-GPU models, but replications within a process are not
-supported. You need to create one process per module replica, which usually
-leads to better performance compared to multiple replicas per process. DDP
-wrapping multi-GPU models is especially helpful when training large models with
-a huge amount of data. When using this feature, the multi-GPU model needs to be
-carefully implemented to avoid hard-coded devices, because different model
-replicas will be placed to different devices.
+DDP also works with multi-GPU models. DDP wrapping multi-GPU models is especially
+helpful when training large models with a huge amount of data.
 
 .. code:: python
 
@@ -226,6 +278,7 @@ either the application or the model ``forward()`` method.
 .. code:: python
 
     def demo_model_parallel(rank, world_size):
+        print(f"Running DDP with model parallel example on rank {rank}.")
         setup(rank, world_size)
 
         # setup mp_model and devices for this process
@@ -245,11 +298,95 @@ 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__":
-        run_demo(demo_basic, 2)
-        run_demo(demo_checkpoint, 2)
+        n_gpus = torch.accelerator.device_count()
+        assert n_gpus >= 2, f"Requires at least 2 GPUs to run, but got {n_gpus}"
+        world_size = n_gpus
+        run_demo(demo_basic, world_size)
+        run_demo(demo_checkpoint, world_size)
+        world_size = n_gpus//2
+        run_demo(demo_model_parallel, world_size)
+
+Initialize DDP with torch.distributed.run/torchrun
+---------------------------------------------------
+
+We can leverage PyTorch Elastic to simplify the DDP code and initialize the job more easily.
+Let's still use the Toymodel example and create a file named ``elastic_ddp.py``.
+
+.. code:: python
+
+    import os
+    import torch
+    import torch.distributed as dist
+    import torch.nn as nn
+    import torch.optim as optim
+
+    from torch.nn.parallel import DistributedDataParallel as DDP
+
+    class ToyModel(nn.Module):
+        def __init__(self):
+            super(ToyModel, self).__init__()
+            self.net1 = nn.Linear(10, 10)
+            self.relu = nn.ReLU()
+            self.net2 = nn.Linear(10, 5)
+
+        def forward(self, x):
+            return self.net2(self.relu(self.net1(x)))
+
+
+    def demo_basic():
+        torch.accelerator.set_device_index(int(os.environ["LOCAL_RANK"]))
+        acc = torch.accelerator.current_accelerator()
+        backend = torch.distributed.get_default_backend_for_device(acc)
+        dist.init_process_group(backend)
+        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.accelerator.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)
+
+        optimizer.zero_grad()
+        outputs = ddp_model(torch.randn(20, 10))
+        labels = torch.randn(20, 5).to(device_id)
+        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
+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
+
+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 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
+and set ``MASTER_ADDR`` as:
+
+.. code:: bash
+
+    export MASTER_ADDR=$(scontrol show hostname ${SLURM_NODELIST} | head -n 1)
+
+
+Then we can just run this script using the SLURM command: ``srun --nodes=2 ./torchrun_script.sh``.
+
+This is just an example; you can choose your own cluster scheduling tools to initiate the ``torchrun`` job.
 
-        if torch.cuda.device_count() >= 8:
-            run_demo(demo_model_parallel, 4)
+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 00000000000..ec3e3cf304a
--- /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 36d07f18849..cebc986a190 100644
--- a/intermediate_source/dist_tuto.rst
+++ b/intermediate_source/dist_tuto.rst
@@ -2,7 +2,17 @@ Writing Distributed Applications with PyTorch
 =============================================
 **Author**: `Séb Arnold <https://seba1511.com>`_
 
-In this short tutorial, we will be going over the distributed package of PyTorch. We'll see how to set up the distributed setting, use the different communication strategies, and go over some the internals of the package.
+.. note::
+   |edit| View and edit this tutorial in `github <https://github.com/pytorch/tutorials/blob/main/intermediate_source/dist_tuto.rst>`__.
+
+Prerequisites:
+
+-  `PyTorch Distributed Overview <../beginner/dist_overview.html>`__
+
+In this short tutorial, we will be going over the distributed package
+of PyTorch. We'll see how to set up the distributed setting, use the
+different communication strategies, and go over some of the internals of
+the package.
 
 Setup
 -----
@@ -17,7 +27,7 @@ Setup
 The distributed package included in PyTorch (i.e.,
 ``torch.distributed``) enables researchers and practitioners to easily
 parallelize their computations across processes and clusters of
-machines. To do so, it leverages the messaging passing semantics
+machines. To do so, it leverages message passing semantics
 allowing each process to communicate data to any of the other processes.
 As opposed to the multiprocessing (``torch.multiprocessing``) package,
 processes can use different communication backends and are not
@@ -25,11 +35,11 @@ restricted to being executed on the same machine.
 
 In order to get started we need the ability to run multiple processes
 simultaneously. If you have access to compute cluster you should check
-with your local sysadmin or use your favorite coordination tool. (e.g.,
+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
-tutorial, we will use a single machine and fork multiple processes using
+`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.
 
 .. code:: python
@@ -37,15 +47,16 @@ the following template.
     """run.py:"""
     #!/usr/bin/env python
     import os
+    import sys
     import torch
     import torch.distributed as dist
-    from torch.multiprocessing import Process
+    import torch.multiprocessing as mp
 
     def run(rank, size):
         """ Distributed function to be implemented later. """
         pass
 
-    def init_processes(rank, size, fn, backend='tcp'):
+    def init_process(rank, size, fn, backend='gloo'):
         """ Initialize the distributed environment. """
         os.environ['MASTER_ADDR'] = '127.0.0.1'
         os.environ['MASTER_PORT'] = '29500'
@@ -54,10 +65,15 @@ the following template.
 
 
     if __name__ == "__main__":
-        size = 2
+        world_size = 2
         processes = []
-        for rank in range(size):
-            p = Process(target=init_processes, args=(rank, size, run))
+        if "google.colab" in sys.modules:
+            print("Running in Google Colab")
+            mp.get_context("spawn")
+        else:
+            mp.set_start_method("spawn")
+        for rank in range(world_size):
+            p = mp.Process(target=init_process, args=(rank, world_size, run))
             p.start()
             processes.append(p)
 
@@ -69,12 +85,10 @@ distributed environment, initialize the process group
 (``dist.init_process_group``), and finally execute the given ``run``
 function.
 
-Let's have a look at the ``init_processes`` function. It ensures that
+Let's have a look at the ``init_process`` function. It ensures that
 every process will be able to coordinate through a master, using the
-same ip address and port. Note that we used the TCP backend, but we
-could have used
-`MPI <https://en.wikipedia.org/wiki/Message_Passing_Interface>`__ or
-`Gloo <https://github.com/facebookincubator/gloo>`__ instead. (c.f.
+same ip address and port. Note that we used the ``gloo`` backend but
+other backends are available. (c.f.
 `Section 5.1 <#communication-backends>`__) We will go over the magic
 happening in ``dist.init_process_group`` at the end of this tutorial,
 but it essentially allows processes to communicate with each other by
@@ -116,10 +130,10 @@ 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 ``DistributedRequest`` object upon which we can choose to
+return a ``Work`` object upon which we can choose to
 ``wait()``.
 
 .. code:: python
@@ -141,19 +155,20 @@ return a ``DistributedRequest`` object upon which we can choose to
         req.wait()
         print('Rank ', rank, ' has data ', tensor[0])
 
-When using immediates we have to be careful about with our usage of the sent and received tensors.
+When using immediates we have to be careful about how we use the sent and received tensors.
 Since we do not know when the data will be communicated to the other process,
 we should not modify the sent tensor nor access the received tensor before ``req.wait()`` has completed.
 In other words,
 
 -  writing to ``tensor`` after ``dist.isend()`` will result in undefined behaviour.
--  reading from ``tensor`` after ``dist.irecv()`` will result in undefined behaviour.
+- reading from ``tensor`` after ``dist.irecv()`` will result in undefined
+  behaviour, until ``req.wait()`` has been executed.
 
 However, after ``req.wait()``
 has been executed we are guaranteed that the communication took place,
 and that the value stored in ``tensor[0]`` is 1.0.
 
-Point-to-point communication is useful when we want a fine-grained
+Point-to-point communication is useful when we want more fine-grained
 control over the communication of our processes. They can be used to
 implement fancy algorithms, such as the one used in `Baidu's
 DeepSpeech <https://github.com/baidu-research/baidu-allreduce>`__ or
@@ -193,48 +208,61 @@ As opposed to point-to-point communcation, collectives allow for
 communication patterns across all processes in a **group**. A group is a
 subset of all our processes. To create a group, we can pass a list of
 ranks to ``dist.new_group(group)``. By default, collectives are executed
-on the all processes, also known as the **world**. For example, in order
-to obtain the sum of all tensors at all processes, we can use the
+on all processes, also known as the **world**. For example, in order
+to obtain the sum of all tensors on all processes, we can use the
 ``dist.all_reduce(tensor, op, group)`` collective.
 
 .. code:: python
 
     """ All-Reduce example."""
     def run(rank, size):
-        """ Simple point-to-point communication. """
+        """ Simple collective communication. """
         group = dist.new_group([0, 1])
         tensor = torch.ones(1)
-        dist.all_reduce(tensor, op=dist.reduce_op.SUM, group=group)
+        dist.all_reduce(tensor, op=dist.ReduceOp.SUM, group=group)
         print('Rank ', rank, ' has data ', tensor[0])
 
 Since we want the sum of all tensors in the group, we use
-``dist.reduce_op.SUM`` as the reduce operator. Generally speaking, any
+``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.reduce_op.SUM``,
--  ``dist.reduce_op.PRODUCT``,
--  ``dist.reduce_op.MAX``,
--  ``dist.reduce_op.MIN``.
+-  ``dist.ReduceOp.SUM``,
+-  ``dist.ReduceOp.PRODUCT``,
+-  ``dist.ReduceOp.MAX``,
+-  ``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.
--  ``dist.reduce(tensor, dst, op, group)``: Applies ``op`` to all
+-  ``dist.reduce(tensor, dst, op, group)``: Applies ``op`` to every
    ``tensor`` and stores the result in ``dst``.
 -  ``dist.all_reduce(tensor, op, group)``: Same as reduce, but the
    result is stored in all processes.
--  ``dist.scatter(tensor, src, scatter_list, group)``: Copies the
+-  ``dist.scatter(tensor, scatter_list, src, group)``: Copies the
    :math:`i^{\text{th}}` tensor ``scatter_list[i]`` to the
    :math:`i^{\text{th}}` process.
--  ``dist.gather(tensor, dst, gather_list, group)``: Copies ``tensor``
+-  ``dist.gather(tensor, gather_list, dst, group)``: Copies ``tensor``
    from all processes in ``dst``.
 -  ``dist.all_gather(tensor_list, tensor, group)``: Copies ``tensor``
    from all processes to ``tensor_list``, on all processes.
--  ``dist.barrier(group)``: block all processes in `group` until each one has entered this function.
+-  ``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
 --------------------
@@ -257,7 +285,7 @@ something useful with it. Our goal will be to replicate the
 functionality of
 `DistributedDataParallel <https://pytorch.org/docs/stable/nn.html#torch.nn.parallel.DistributedDataParallel>`__.
 Of course, this will be a didactic example and in a real-world
-situtation you should use the official, well-tested and well-optimized
+situation you should use the official, well-tested and well-optimized
 version linked above.
 
 Quite simply we want to implement a distributed version of stochastic
@@ -266,7 +294,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
@@ -291,7 +319,7 @@ instead of the snippet below.)
         def __init__(self, data, sizes=[0.7, 0.2, 0.1], seed=1234):
             self.data = data
             self.partitions = []
-            rng = Random()
+            rng = Random()  # from random import Random
             rng.seed(seed)
             data_len = len(data)
             indexes = [x for x in range(0, data_len)]
@@ -318,7 +346,7 @@ the following few lines:
                                      transforms.Normalize((0.1307,), (0.3081,))
                                  ]))
         size = dist.get_world_size()
-        bsz = 128 / float(size)
+        bsz = 128 // size
         partition_sizes = [1.0 / size for _ in range(size)]
         partition = DataPartitioner(dataset, partition_sizes)
         partition = partition.use(dist.get_rank())
@@ -333,7 +361,7 @@ number of replicas in order to maintain the *overall* batch size of 128.
 
 We can now write our usual forward-backward-optimize training code, and
 add a function call to average the gradients of our models. (The
-following is largely inspired from the official `PyTorch MNIST
+following is largely inspired by the official `PyTorch MNIST
 example <https://github.com/pytorch/examples/blob/master/mnist/main.py>`__.)
 
 .. code:: python
@@ -370,7 +398,7 @@ world.
     def average_gradients(model):
         size = float(dist.get_world_size())
         for param in model.parameters():
-            dist.all_reduce(param.grad.data, op=dist.reduce_op.SUM)
+            dist.all_reduce(param.grad.data, op=dist.ReduceOp.SUM)
             param.grad.data /= size
 
 *Et voilà*! We successfully implemented distributed synchronous SGD and
@@ -380,48 +408,47 @@ 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
 ~~~~~~~~~~~~~~~~~~~~~~
 
 As an additional challenge, imagine that we wanted to implement
-DeepSpeech's efficient ring allreduce. This is fairly easily implemented
+DeepSpeech's efficient ring allreduce. This is fairly easy to implement
 using point-to-point collectives.
 
 .. code:: python
 
     """ Implementation of a ring-reduce with addition. """
     def allreduce(send, recv):
-        rank = dist.get_rank()
-        size = dist.get_world_size()
-        send_buff = th.zeros(send.size())
-        recv_buff = th.zeros(send.size())
-        accum = th.zeros(send.size())
-        accum[:] = send[:]
-
-        left = ((rank - 1) + size) % size
-        right = (rank + 1) % size
-
-        for i in range(size - 1):
-            if i % 2 == 0:
-                # Send send_buff
-                send_req = dist.isend(send_buff, right)
-                dist.recv(recv_buff, left)
-                accum[:] += recv[:]
-            else:
-                # Send recv_buff
-                send_req = dist.isend(recv_buff, right)
-                dist.recv(send_buff, left)
-                accum[:] += send[:]
-            send_req.wait()
-        recv[:] = accum[:]
+       rank = dist.get_rank()
+       size = dist.get_world_size()
+       send_buff = send.clone()
+       recv_buff = send.clone()
+       accum = send.clone()
+
+       left = ((rank - 1) + size) % size
+       right = (rank + 1) % size
+
+       for i in range(size - 1):
+           if i % 2 == 0:
+               # Send send_buff
+               send_req = dist.isend(send_buff, right)
+               dist.recv(recv_buff, left)
+               accum[:] += recv_buff[:]
+           else:
+               # Send recv_buff
+               send_req = dist.isend(recv_buff, right)
+               dist.recv(send_buff, left)
+               accum[:] += send_buff[:]
+           send_req.wait()
+       recv[:] = accum[:]
 
 In the above script, the ``allreduce(send, recv)`` function has a
 slightly different signature than the ones in PyTorch. It takes a
 ``recv`` tensor and will store the sum of all ``send`` tensors in it. As
 an exercise left to the reader, there is still one difference between
-our version and the one in DeepSpeech: their implementation divide the
+our version and the one in DeepSpeech: their implementation divides the
 gradient tensor into *chunks*, so as to optimally utilize the
 communication bandwidth. (Hint:
 `torch.chunk <https://pytorch.org/docs/stable/torch.html#torch.chunk>`__)
@@ -435,7 +462,7 @@ divided into two subsections:
 
 1. Communication Backends: where we learn how to use MPI and Gloo for
    GPU-GPU communication.
-2. Initialization Methods: where we understand how to best setup the
+2. Initialization Methods: where we understand how to best set up the
    initial coordination phase in ``dist.init_process_group()``.
 
 Communication Backends
@@ -443,49 +470,36 @@ 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: TCP, MPI, and
-Gloo. They each have different specifications and tradeoffs, depending
-on the desired use-case. A comparative table of supported functions can
+there are multiple backends implemented in PyTorch. These backends can be easily selected
+using the `Accelerator API <https://pytorch.org/docs/stable/torch.html#accelerators>`__,
+which provides a interface for working with different accelerator types.
+Some of the most popular backends 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>`__. Note that a fourth backend, NCCL, has been added since the creation of this tutorial.  See `this section <https://pytorch.org/docs/stable/distributed.html#multi-gpu-collective-functions>`__ of the ``torch.distributed`` docs for more information about its use and value.
-
-**TCP Backend**
-
-So far we have made extensive usage of the TCP backend. It is quite
-handy as a development platform, as it is guaranteed to work on most
-machines and operating systems. It also supports all point-to-point and
-collective functions on CPU. However, there is no support for GPUs and
-its communication routines are not as optimized as the MPI one.
+`here <https://pytorch.org/docs/stable/distributed.html#module-torch.distributed>`__.
 
 **Gloo Backend**
 
-The `Gloo backend <https://github.com/facebookincubator/gloo>`__
-provides an optimized implementation of *collective* communication
-procedures, both for CPUs and GPUs. It particularly shines on GPUs as it
-can perform communication without transferring data to the CPU's memory
-using `GPUDirect <https://developer.nvidia.com/gpudirect>`__. It is also
-capable of using `NCCL <https://github.com/NVIDIA/nccl>`__ to perform
-fast intra-node communication and implements its `own
-algorithms <https://github.com/facebookincubator/gloo/blob/master/docs/algorithms.md>`__
-for inter-node routines.
-
-Since version 0.2.0, the Gloo backend is automatically included with the
-pre-compiled binaries of PyTorch. As you have surely noticed, our
+So far we have made extensive usage of the `Gloo backend <https://github.com/facebookincubator/gloo>`__.
+It is quite handy as a development platform, as it is included in
+the pre-compiled PyTorch binaries and works on both Linux (since 0.2)
+and macOS (since 1.3). It supports all point-to-point and collective
+operations on CPU, and all collective operations on GPU. The
+implementation of the collective operations for CUDA tensors is not as
+optimized as the ones provided by the NCCL backend.
+
+As you have surely noticed, our
 distributed SGD example does not work if you put ``model`` on the GPU.
-Let's fix it by first replacing ``backend='gloo'`` in
-``init_processes(rank, size, fn, backend='tcp')``. At this point, the
-script will still run on CPU but uses the Gloo backend behind the
-scenes. In order to use multiple GPUs, let us also do the following
+In order to use multiple GPUs, let us also make the following
 modifications:
 
-0. ``init_processes(rank, size, fn, backend='tcp')`` :math:`\rightarrow`
-   ``init_processes(rank, size, fn, backend='gloo')``
-1.  Use ``device = torch.device("cuda:{}".format(rank))``
-2. ``model = Net()`` :math:`\rightarrow` ``model = Net().to(device)``
-3.  Use ``data, target = data.to(device), target.to(device)``
+1. Use Accelerator API ``device_type = torch.accelerator.current_accelerator()``
+2. Use ``torch.device(f"{device_type}:{rank}")``
+3. ``model = Net()`` :math:`\rightarrow` ``model = Net().to(device)``
+4.  Use ``data, target = data.to(device), target.to(device)``
 
-With the above modifications, our model is now training on two GPUs and
-you can monitor their utilization with ``watch nvidia-smi``.
+With these modifications, your model will now train across two GPUs.
+You can monitor GPU utilization using ``watch nvidia-smi`` if you are running on NVIDIA hardware.
 
 **MPI Backend**
 
@@ -504,7 +518,7 @@ large computer clusters. `Some <https://developer.nvidia.com/mvapich>`__
 advantage of CUDA IPC and GPU Direct technologies in order to avoid
 memory copies through the CPU.
 
-Unfortunately, PyTorch's binaries can not include an MPI implementation
+Unfortunately, PyTorch's binaries cannot include an MPI implementation
 and we'll have to recompile it by hand. Fortunately, this process is
 fairly simple given that upon compilation, PyTorch will look *by itself*
 for an available MPI implementation. The following steps install the MPI
@@ -526,7 +540,7 @@ In order to test our newly installed backend, a few modifications are
 required.
 
 1. Replace the content under ``if __name__ == '__main__':`` with
-   ``init_processes(0, 0, run, backend='mpi')``.
+   ``init_process(0, 0, run, backend='mpi')``.
 2. Run ``mpirun -n 4 python myscript.py``.
 
 The reason for these changes is that MPI needs to create its own
@@ -541,45 +555,35 @@ more <https://www.open-mpi.org/faq/?category=running#mpirun-hostfile>`__)
 Doing so, you should obtain the same familiar output as with the other
 communication backends.
 
+
+**NCCL Backend**
+
+The `NCCL backend <https://github.com/nvidia/nccl>`__ provides an
+optimized implementation of collective operations against CUDA
+tensors. If you only use CUDA tensors for your collective operations,
+consider using this backend for the best in class performance. The
+NCCL backend is included in the pre-built binaries with CUDA support.
+
+**XCCL Backend**
+
+The `XCCL backend` offers an optimized implementation of collective operations for XPU tensors.
+If your workload uses only XPU tensors for collective operations,
+this backend provides best-in-class performance.
+The XCCL backend is included in the pre-built binaries with XPU 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>`__.
-
-Before diving into the initialization methods, let's have a quick look
-at what happens behind ``init_process_group`` from the C/C++
-perspective.
-
-1. First, the arguments are parsed and validated.
-2. The backend is resolved via the ``name2channel.at()`` function. A
-   ``Channel`` class is returned, and will be used to perform the data
-   transmission.
-3. The GIL is dropped, and ``THDProcessGroupInit()`` is called. This
-   instantiates the channel and adds the address of the master node.
-4. The process with rank 0 will execute the ``master`` procedure, while
-   all other ranks will be ``workers``.
-5. The master
-
-   a. Creates sockets for all workers.
-   b. Waits for all workers to connect.
-   c. Sends them information about the location of the other processes.
-
-6. Each worker
-
-   a. Creates a socket to the master.
-   b. Sends their own location information.
-   c. Receives information about the other workers.
-   d. Opens a socket and handshakes with all other workers.
-
-7. The initialization is done, and everyone is connected to everyone.
+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**
 
@@ -596,54 +600,37 @@ finally handshake with them.
 -  ``WORLD_SIZE``: The total number of processes, so that the master
    knows how many workers to wait for.
 -  ``RANK``: Rank of each process, so they will know whether it is the
-   master of a worker.
+   master or a worker.
 
 **Shared File System**
 
 The shared filesystem requires all processes to have access to a shared
 file system, and will coordinate them through a shared file. This means
 that each process will open the file, write its information, and wait
-until everybody did so. After what all required information will be
+until everybody did so. After that all required information will be
 readily available to all processes. In order to avoid race conditions,
 the file system must support locking through
-`fcntl <http://man7.org/linux/man-pages/man2/fcntl.2.html>`__. Note that
-you can specify ranks manually or let the processes figure it out by
-themselves. Be defining a unique ``groupname`` per job you can use the
-same file path for multiple jobs and safely avoid collision.
+`fcntl <http://man7.org/linux/man-pages/man2/fcntl.2.html>`__.
 
 .. code:: python
 
-    dist.init_process_group(init_method='file:///mnt/nfs/sharedfile', world_size=4,
-                            group_name='mygroup')
-
-**TCP Init & Multicast**
-
-Initializing via TCP can be achieved in two different ways:
-
-1. By providing the IP address of the process with rank 0 and the world
-   size.
-2. By providing *any* valid IP `multicast
-   address <https://en.wikipedia.org/wiki/Multicast_address>`__ and the
-   world size.
-
-In the first case, all workers will be able to connect to the process
-with rank 0 and follow the procedure described above.
-
-.. code:: python
+    dist.init_process_group(
+        init_method='file:///mnt/nfs/sharedfile',
+        rank=args.rank,
+        world_size=4)
 
-    dist.init_process_group(init_method='tcp://10.1.1.20:23456', rank=args.rank, world_size=4)
+**TCP**
 
-In the second case, the multicast address specifies the group of nodes
-who might potentially be active and the coordination can be handled by
-allowing each process to have an initial handshake before following the
-above procedure. In addition TCP multicast initialization also supports
-a ``group_name`` argument (as with the shared file method) allowing
-multiple jobs to be scheduled on the same cluster.
+Initializing via TCP can be achieved by providing the IP address of the process with rank 0 and a reachable port number.
+Here, all workers will be able to connect to the process
+with rank 0 and exchange information on how to reach each other.
 
 .. code:: python
 
-    dist.init_process_group(init_method='tcp://[ff15:1e18:5d4c:4cf0:d02d:b659:53ba:b0a7]:23456',
-                            world_size=4)
+    dist.init_process_group(
+        init_method='tcp://10.1.1.20:23456',
+        rank=args.rank,
+        world_size=4)
 
 .. raw:: html
 
@@ -674,7 +661,7 @@ I'd like to thank the PyTorch developers for doing such a good job on
 their implementation, documentation, and tests. When the code was
 unclear, I could always count on the
 `docs <https://pytorch.org/docs/stable/distributed.html>`__ or the
-`tests <https://github.com/pytorch/pytorch/blob/master/test/test_distributed.py>`__
+`tests <https://github.com/pytorch/pytorch/tree/master/test/distributed>`__
 to find an answer. In particular, I'd like to thank Soumith Chintala,
 Adam Paszke, and Natalia Gimelshein for providing insightful comments
 and answering questions on early drafts.
diff --git a/intermediate_source/dqn_with_rnn_tutorial.py b/intermediate_source/dqn_with_rnn_tutorial.py
new file mode 100644
index 00000000000..bcc484f0a00
--- /dev/null
+++ b/intermediate_source/dqn_with_rnn_tutorial.py
@@ -0,0 +1,468 @@
+# -*- coding: utf-8 -*-
+
+"""
+Recurrent DQN: Training recurrent policies
+==========================================
+
+**Author**: `Vincent Moens <https://github.com/vmoens>`_
+
+.. grid:: 2
+
+    .. grid-item-card:: :octicon:`mortar-board;1em;` What you will learn
+       :class-card: card-prerequisites
+
+       * How to incorporating an RNN in an actor in TorchRL
+       * How to use that memory-based policy with a replay buffer and a loss module
+
+    .. grid-item-card:: :octicon:`list-unordered;1em;` Prerequisites
+       :class-card: card-prerequisites
+
+       * PyTorch v2.0.0
+       * gym[mujoco]
+       * tqdm
+"""
+
+#########################################################################
+# Overview
+# --------
+#
+# Memory-based policies are crucial not only when the observations are partially
+# observable but also when the time dimension must be taken into account to
+# make informed decisions.
+#
+# Recurrent neural network have long been a popular tool for memory-based
+# policies. The idea is to keep a recurrent state in memory between two
+# consecutive steps, and use this as an input to the policy along with the
+# current observation.
+#
+# This tutorial shows how to incorporate an RNN in a policy using TorchRL.
+#
+# Key learnings:
+#
+# - Incorporating an RNN in an actor in TorchRL;
+# - Using that memory-based policy with a replay buffer and a loss module.
+#
+# The core idea of using RNNs in TorchRL is to use TensorDict as a data carrier
+# for the hidden states from one step to another. We'll build a policy that
+# reads the previous recurrent state from the current TensorDict, and writes the
+# current recurrent states in the TensorDict of the next state:
+#
+# .. figure:: /_static/img/rollout_recurrent.png
+#    :alt: Data collection with a recurrent policy
+#
+# As this figure shows, our environment populates the TensorDict with zeroed recurrent
+# states which are read by the policy together with the observation to produce an
+# action, and recurrent states that will be used for the next step.
+# When the :func:`~torchrl.envs.utils.step_mdp` function is called, the recurrent states
+# from the next state are brought to the current TensorDict. Let's see how this
+# is implemented in practice.
+
+######################################################################
+# If you are running this in Google Colab, make sure you install the following dependencies:
+#
+# .. code-block:: bash
+#
+#    !pip3 install torchrl
+#    !pip3 install gym[mujoco]
+#    !pip3 install tqdm
+#
+# Setup
+# -----
+#
+
+# sphinx_gallery_start_ignore
+import warnings
+
+warnings.filterwarnings("ignore")
+from torch import multiprocessing
+
+# TorchRL prefers spawn method, that restricts creation of  ``~torchrl.envs.ParallelEnv`` inside
+# `__main__` method call, but for the easy of reading the code switch to fork
+# which is also a default spawn method in Google's Colaboratory
+try:
+    multiprocessing.set_start_method("fork")
+except RuntimeError:
+    pass
+
+# sphinx_gallery_end_ignore
+
+import torch
+import tqdm
+from tensordict.nn import TensorDictModule as Mod, TensorDictSequential as Seq
+from torch import nn
+from torchrl.collectors import SyncDataCollector
+from torchrl.data import LazyMemmapStorage, TensorDictReplayBuffer
+from torchrl.envs import (
+    Compose,
+    ExplorationType,
+    GrayScale,
+    InitTracker,
+    ObservationNorm,
+    Resize,
+    RewardScaling,
+    set_exploration_type,
+    StepCounter,
+    ToTensorImage,
+    TransformedEnv,
+)
+from torchrl.envs.libs.gym import GymEnv
+from torchrl.modules import ConvNet, EGreedyModule, LSTMModule, MLP, QValueModule
+from torchrl.objectives import DQNLoss, SoftUpdate
+
+is_fork = multiprocessing.get_start_method() == "fork"
+device = (
+    torch.device(0)
+    if torch.cuda.is_available() and not is_fork
+    else torch.device("cpu")
+)
+
+######################################################################
+# Environment
+# -----------
+#
+# As usual, the first step is to build our environment: it helps us
+# define the problem and build the policy network accordingly. For this tutorial,
+# we'll be running a single pixel-based instance of the CartPole gym
+# environment with some custom transforms: turning to grayscale, resizing to
+# 84x84, scaling down the rewards and normalizing the observations.
+#
+# .. note::
+#   The :class:`~torchrl.envs.transforms.StepCounter` transform is accessory. Since the CartPole
+#   task goal is to make trajectories as long as possible, counting the steps
+#   can help us track the performance of our policy.
+#
+# Two transforms are important for the purpose of this tutorial:
+#
+# - :class:`~torchrl.envs.transforms.InitTracker` will stamp the
+#   calls to :meth:`~torchrl.envs.EnvBase.reset` by adding a ``"is_init"``
+#   boolean mask in the TensorDict that will track which steps require a reset
+#   of the RNN hidden states.
+# - The :class:`~torchrl.envs.transforms.TensorDictPrimer` transform is a bit more
+#   technical. It is not required to use RNN policies. However, it
+#   instructs the environment (and subsequently the collector) that some extra
+#   keys are to be expected. Once added, a call to `env.reset()` will populate
+#   the entries indicated in the primer with zeroed tensors. Knowing that
+#   these tensors are expected by the policy, the collector will pass them on
+#   during collection. Eventually, we'll be storing our hidden states in the
+#   replay buffer, which will help us bootstrap the computation of the
+#   RNN operations in the loss module (which would otherwise be initiated
+#   with 0s). In summary: not including this transform will not impact hugely
+#   the training of our policy, but it will make the recurrent keys disappear
+#   from the collected data and the replay buffer, which will in turn lead to
+#   a slightly less optimal training.
+#   Fortunately, the :class:`~torchrl.modules.LSTMModule` we propose is
+#   equipped with a helper method to build just that transform for us, so
+#   we can wait until we build it!
+#
+
+env = TransformedEnv(
+    GymEnv("CartPole-v1", from_pixels=True, device=device),
+    Compose(
+        ToTensorImage(),
+        GrayScale(),
+        Resize(84, 84),
+        StepCounter(),
+        InitTracker(),
+        RewardScaling(loc=0.0, scale=0.1),
+        ObservationNorm(standard_normal=True, in_keys=["pixels"]),
+    ),
+)
+
+######################################################################
+# As always, we need to initialize manually our normalization constants:
+#
+env.transform[-1].init_stats(1000, reduce_dim=[0, 1, 2], cat_dim=0, keep_dims=[0])
+td = env.reset()
+
+######################################################################
+# Policy
+# ------
+#
+# Our policy will have 3 components: a :class:`~torchrl.modules.ConvNet`
+# backbone, an :class:`~torchrl.modules.LSTMModule` memory layer and a shallow
+# :class:`~torchrl.modules.MLP` block that will map the LSTM output onto the
+# action values.
+#
+# Convolutional network
+# ~~~~~~~~~~~~~~~~~~~~~
+#
+# We build a convolutional network flanked with a :class:`torch.nn.AdaptiveAvgPool2d`
+# that will squash the output in a vector of size 64. The :class:`~torchrl.modules.ConvNet`
+# can assist us with this:
+#
+
+feature = Mod(
+    ConvNet(
+        num_cells=[32, 32, 64],
+        squeeze_output=True,
+        aggregator_class=nn.AdaptiveAvgPool2d,
+        aggregator_kwargs={"output_size": (1, 1)},
+        device=device,
+    ),
+    in_keys=["pixels"],
+    out_keys=["embed"],
+)
+######################################################################
+# we execute the first module on a batch of data to gather the size of the
+# output vector:
+#
+n_cells = feature(env.reset())["embed"].shape[-1]
+
+######################################################################
+# LSTM Module
+# ~~~~~~~~~~~
+#
+# TorchRL provides a specialized :class:`~torchrl.modules.LSTMModule` class
+# to incorporate LSTMs in your code-base. It is a :class:`~tensordict.nn.TensorDictModuleBase`
+# subclass: as such, it has a set of ``in_keys`` and ``out_keys`` that indicate
+# what values should be expected to be read and written/updated during the
+# execution of the module. The class comes with customizable predefined
+# values for these attributes to facilitate its construction.
+#
+# .. note::
+#   *Usage limitations*: The class supports almost all LSTM features such as
+#   dropout or multi-layered LSTMs.
+#   However, to respect TorchRL's conventions, this LSTM must have the ``batch_first``
+#   attribute set to ``True`` which is **not** the default in PyTorch. However,
+#   our :class:`~torchrl.modules.LSTMModule` changes this default
+#   behavior, so we're good with a native call.
+#
+#   Also, the LSTM cannot have a ``bidirectional`` attribute set to ``True`` as
+#   this wouldn't be usable in online settings. In this case, the default value
+#   is the correct one.
+#
+
+lstm = LSTMModule(
+    input_size=n_cells,
+    hidden_size=128,
+    device=device,
+    in_key="embed",
+    out_key="embed",
+)
+
+######################################################################
+# Let us look at the LSTM Module class, specifically its in and out_keys:
+print("in_keys", lstm.in_keys)
+print("out_keys", lstm.out_keys)
+
+######################################################################
+# We can see that these values contain the key we indicated as the in_key (and out_key)
+# as well as recurrent key names. The out_keys are preceded by a "next" prefix
+# that indicates that they will need to be written in the "next" TensorDict.
+# We use this convention (which can be overridden by passing the in_keys/out_keys
+# arguments) to make sure that a call to :func:`~torchrl.envs.utils.step_mdp` will
+# move the recurrent state to the root TensorDict, making it available to the
+# RNN during the following call (see figure in the intro).
+#
+# As mentioned earlier, we have one more optional transform to add to our
+# environment to make sure that the recurrent states are passed to the buffer.
+# The :meth:`~torchrl.modules.LSTMModule.make_tensordict_primer` method does
+# exactly that:
+#
+env.append_transform(lstm.make_tensordict_primer())
+
+######################################################################
+# and that's it! We can print the environment to check that everything looks good now
+# that we have added the primer:
+print(env)
+
+######################################################################
+# MLP
+# ~~~
+#
+# We use a single-layer MLP to represent the action values we'll be using for
+# our policy.
+#
+mlp = MLP(
+    out_features=2,
+    num_cells=[
+        64,
+    ],
+    device=device,
+)
+######################################################################
+# and fill the bias with zeros:
+
+mlp[-1].bias.data.fill_(0.0)
+mlp = Mod(mlp, in_keys=["embed"], out_keys=["action_value"])
+
+######################################################################
+# Using the Q-Values to select an action
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# The last part of our policy is the Q-Value Module.
+# The Q-Value module :class:`~torchrl.modules.tensordict_module.QValueModule`
+# will read the ``"action_values"`` key that is produced by our MLP and
+# from it, gather the action that has the maximum value.
+# The only thing we need to do is to specify the action space, which can be done
+# either by passing a string or an action-spec. This allows us to use
+# Categorical (sometimes called "sparse") encoding or the one-hot version of it.
+#
+qval = QValueModule(spec=env.action_spec)
+
+######################################################################
+# .. note::
+#   TorchRL also provides a wrapper class :class:`torchrl.modules.QValueActor` that
+#   wraps a module in a Sequential together with a :class:`~torchrl.modules.tensordict_module.QValueModule`
+#   like we are doing explicitly here. There is little advantage to do this
+#   and the process is less transparent, but the end results will be similar to
+#   what we do here.
+#
+# We can now put things together in a :class:`~tensordict.nn.TensorDictSequential`
+#
+stoch_policy = Seq(feature, lstm, mlp, qval)
+
+######################################################################
+# DQN being a deterministic algorithm, exploration is a crucial part of it.
+# We'll be using an :math:`\epsilon`-greedy policy with an epsilon of 0.2 decaying
+# progressively to 0.
+# This decay is achieved via a call to :meth:`~torchrl.modules.EGreedyModule.step`
+# (see training loop below).
+#
+exploration_module = EGreedyModule(
+    annealing_num_steps=1_000_000, spec=env.action_spec, eps_init=0.2
+)
+stoch_policy = Seq(
+    stoch_policy,
+    exploration_module,
+)
+
+######################################################################
+# Using the model for the loss
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# The model as we've built it is well equipped to be used in sequential settings.
+# However, the class :class:`torch.nn.LSTM` can use a cuDNN-optimized backend
+# to run the RNN sequence faster on GPU device. We would not want to miss
+# such an opportunity to speed up our training loop!
+# To use it, we just need to tell the LSTM module to run on "recurrent-mode"
+# when used by the loss.
+# As we'll usually want to have two copies of the LSTM module, we do this by
+# calling a :meth:`~torchrl.modules.LSTMModule.set_recurrent_mode` method that
+# will return a new instance of the LSTM (with shared weights) that will
+# assume that the input data is sequential in nature.
+#
+policy = Seq(feature, lstm.set_recurrent_mode(True), mlp, qval)
+
+######################################################################
+# Because we still have a couple of uninitialized parameters we should
+# initialize them before creating an optimizer and such.
+#
+policy(env.reset())
+
+######################################################################
+# DQN Loss
+# --------
+#
+# Out DQN loss requires us to pass the policy and, again, the action-space.
+# While this may seem redundant, it is important as we want to make sure that
+# the :class:`~torchrl.objectives.DQNLoss` and the :class:`~torchrl.modules.tensordict_module.QValueModule`
+# classes are compatible, but aren't strongly dependent on each other.
+#
+# To use the Double-DQN, we ask for a ``delay_value`` argument that will
+# create a non-differentiable copy of the network parameters to be used
+# as a target network.
+loss_fn = DQNLoss(policy, action_space=env.action_spec, delay_value=True)
+
+######################################################################
+# Since we are using a double DQN, we need to update the target parameters.
+# We'll use a  :class:`~torchrl.objectives.SoftUpdate` instance to carry out
+# this work.
+#
+updater = SoftUpdate(loss_fn, eps=0.95)
+
+optim = torch.optim.Adam(policy.parameters(), lr=3e-4)
+
+######################################################################
+# Collector and replay buffer
+# ---------------------------
+#
+# We build the simplest data collector there is. We'll try to train our algorithm
+# with a million frames, extending the buffer with 50 frames at a time. The buffer
+# will be designed to store 20 thousands trajectories of 50 steps each.
+# At each optimization step (16 per data collection), we'll collect 4 items
+# from our buffer, for a total of 200 transitions.
+# We'll use a :class:`~torchrl.data.replay_buffers.LazyMemmapStorage` storage to keep the data
+# on disk.
+#
+# .. note::
+#   For the sake of efficiency, we're only running a few thousands iterations
+#   here. In a real setting, the total number of frames should be set to 1M.
+#
+collector = SyncDataCollector(env, stoch_policy, frames_per_batch=50, total_frames=200, device=device)
+rb = TensorDictReplayBuffer(
+    storage=LazyMemmapStorage(20_000), batch_size=4, prefetch=10
+)
+
+######################################################################
+# Training loop
+# -------------
+#
+# To keep track of the progress, we will run the policy in the environment once
+# every 50 data collection, and plot the results after training.
+#
+
+utd = 16
+pbar = tqdm.tqdm(total=1_000_000)
+longest = 0
+
+traj_lens = []
+for i, data in enumerate(collector):
+    if i == 0:
+        print(
+            "Let us print the first batch of data.\nPay attention to the key names "
+            "which will reflect what can be found in this data structure, in particular: "
+            "the output of the QValueModule (action_values, action and chosen_action_value),"
+            "the 'is_init' key that will tell us if a step is initial or not, and the "
+            "recurrent_state keys.\n",
+            data,
+        )
+    pbar.update(data.numel())
+    # it is important to pass data that is not flattened
+    rb.extend(data.unsqueeze(0).to_tensordict().cpu())
+    for _ in range(utd):
+        s = rb.sample().to(device, non_blocking=True)
+        loss_vals = loss_fn(s)
+        loss_vals["loss"].backward()
+        optim.step()
+        optim.zero_grad()
+    longest = max(longest, data["step_count"].max().item())
+    pbar.set_description(
+        f"steps: {longest}, loss_val: {loss_vals['loss'].item(): 4.4f}, action_spread: {data['action'].sum(0)}"
+    )
+    exploration_module.step(data.numel())
+    updater.step()
+
+    with set_exploration_type(ExplorationType.DETERMINISTIC), torch.no_grad():
+        rollout = env.rollout(10000, stoch_policy)
+        traj_lens.append(rollout.get(("next", "step_count")).max().item())
+
+######################################################################
+# Let's plot our results:
+#
+if traj_lens:
+    from matplotlib import pyplot as plt
+
+    plt.plot(traj_lens)
+    plt.xlabel("Test collection")
+    plt.title("Test trajectory lengths")
+
+######################################################################
+# Conclusion
+# ----------
+#
+# We have seen how an RNN can be incorporated in a policy in TorchRL.
+# You should now be able:
+#
+# - Create an LSTM module that acts as a :class:`~tensordict.nn.TensorDictModule`
+# - Indicate to the LSTM module that a reset is needed via an :class:`~torchrl.envs.transforms.InitTracker`
+#   transform
+# - Incorporate this module in a policy and in a loss module
+# - Make sure that the collector is made aware of the recurrent state entries
+#   such that they can be stored in the replay buffer along with the rest of
+#   the data
+#
+# Further Reading
+# ---------------
+# 
+# - The TorchRL documentation can be found `here <https://pytorch.org/rl/>`_.
diff --git a/intermediate_source/ensembling.py b/intermediate_source/ensembling.py
new file mode 100644
index 00000000000..9199daf13a3
--- /dev/null
+++ b/intermediate_source/ensembling.py
@@ -0,0 +1,175 @@
+# -*- coding: utf-8 -*-
+"""
+Model ensembling
+================
+
+This tutorial illustrates how to vectorize model ensembling using ``torch.vmap``.
+
+What is model ensembling?
+-------------------------
+Model ensembling combines the predictions from multiple models together.
+Traditionally this is done by running each model on some inputs separately
+and then combining the predictions. However, if you're running models with
+the same architecture, then it may be possible to combine them together
+using ``torch.vmap``. ``vmap`` is a function transform that maps functions across
+dimensions of the input tensors. One of its use cases is eliminating
+for-loops and speeding them up through vectorization.
+
+Let's demonstrate how to do this using an ensemble of simple MLPs.
+
+.. note::
+
+   This tutorial requires PyTorch 2.0.0 or later.
+"""
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+torch.manual_seed(0)
+
+# Here's a simple MLP
+class SimpleMLP(nn.Module):
+    def __init__(self):
+        super(SimpleMLP, self).__init__()
+        self.fc1 = nn.Linear(784, 128)
+        self.fc2 = nn.Linear(128, 128)
+        self.fc3 = nn.Linear(128, 10)
+
+    def forward(self, x):
+        x = x.flatten(1)
+        x = self.fc1(x)
+        x = F.relu(x)
+        x = self.fc2(x)
+        x = F.relu(x)
+        x = self.fc3(x)
+        return x
+
+######################################################################
+# Let’s generate a batch of dummy data and pretend that we’re working with
+# an MNIST dataset. Thus, the dummy images are 28 by 28, and we have a
+# minibatch of size 64. Furthermore, lets say we want to combine the predictions
+# from 10 different models.
+
+device = 'cuda'
+num_models = 10
+
+data = torch.randn(100, 64, 1, 28, 28, device=device)
+targets = torch.randint(10, (6400,), device=device)
+
+models = [SimpleMLP().to(device) for _ in range(num_models)]
+
+######################################################################
+# We have a couple of options for generating predictions. Maybe we want to
+# give each model a different randomized minibatch of data. Alternatively,
+# maybe we want to run the same minibatch of data through each model (e.g.
+# if we were testing the effect of different model initializations).
+
+######################################################################
+# Option 1: different minibatch for each model
+
+minibatches = data[:num_models]
+predictions_diff_minibatch_loop = [model(minibatch) for model, minibatch in zip(models, minibatches)]
+
+######################################################################
+# Option 2: Same minibatch
+
+minibatch = data[0]
+predictions2 = [model(minibatch) for model in models]
+
+######################################################################
+# Using ``vmap`` to vectorize the ensemble
+# ----------------------------------------
+#
+# Let's use ``vmap`` to speed up the for-loop. We must first prepare the models
+# for use with ``vmap``.
+#
+# First, let’s combine the states of the model together by stacking each
+# parameter. For example, ``model[i].fc1.weight`` has shape ``[784, 128]``; we are
+# going to stack the ``.fc1.weight`` of each of the 10 models to produce a big
+# weight of shape ``[10, 784, 128]``.
+#
+# PyTorch offers the ``torch.func.stack_module_state`` convenience function to do
+# this.
+from torch.func import stack_module_state
+
+params, buffers = stack_module_state(models)
+
+######################################################################
+# Next, we need to define a function to ``vmap`` over. The function should,
+# given parameters and buffers and inputs, run the model using those
+# parameters, buffers, and inputs. We'll use ``torch.func.functional_call``
+# to help out:
+
+from torch.func import functional_call
+import copy
+
+# Construct a "stateless" version of one of the models. It is "stateless" in
+# the sense that the parameters are meta Tensors and do not have storage.
+base_model = copy.deepcopy(models[0])
+base_model = base_model.to('meta')
+
+def fmodel(params, buffers, x):
+    return functional_call(base_model, (params, buffers), (x,))
+
+######################################################################
+# Option 1: get predictions using a different minibatch for each model.
+#
+# By default, ``vmap`` maps a function across the first dimension of all inputs to
+# the passed-in function. After using ``stack_module_state``, each of
+# the ``params`` and buffers have an additional dimension of size 'num_models' at
+# the front, and minibatches has a dimension of size 'num_models'.
+
+print([p.size(0) for p in params.values()]) # show the leading 'num_models' dimension
+
+assert minibatches.shape == (num_models, 64, 1, 28, 28) # verify minibatch has leading dimension of size 'num_models'
+
+from torch import vmap
+
+predictions1_vmap = vmap(fmodel)(params, buffers, minibatches)
+
+# verify the ``vmap`` predictions match the
+assert torch.allclose(predictions1_vmap, torch.stack(predictions_diff_minibatch_loop), atol=1e-3, rtol=1e-5)
+
+######################################################################
+# Option 2: get predictions using the same minibatch of data.
+#
+# ``vmap`` has an ``in_dims`` argument that specifies which dimensions to map over.
+# By using ``None``, we tell ``vmap`` we want the same minibatch to apply for all of
+# the 10 models.
+
+predictions2_vmap = vmap(fmodel, in_dims=(0, 0, None))(params, buffers, minibatch)
+
+assert torch.allclose(predictions2_vmap, torch.stack(predictions2), atol=1e-3, rtol=1e-5)
+
+######################################################################
+# A quick note: there are limitations around what types of functions can be
+# transformed by ``vmap``. The best functions to transform are ones that are pure
+# functions: a function where the outputs are only determined by the inputs
+# that have no side effects (e.g. mutation). ``vmap`` is unable to handle mutation
+# of arbitrary Python data structures, but it is able to handle many in-place
+# PyTorch operations.
+
+######################################################################
+# Performance
+# -----------
+# Curious about performance numbers? Here's how the numbers look.
+
+from torch.utils.benchmark import Timer
+without_vmap = Timer(
+    stmt="[model(minibatch) for model, minibatch in zip(models, minibatches)]",
+    globals=globals())
+with_vmap = Timer(
+    stmt="vmap(fmodel)(params, buffers, minibatches)",
+    globals=globals())
+print(f'Predictions without vmap {without_vmap.timeit(100)}')
+print(f'Predictions with vmap {with_vmap.timeit(100)}')
+
+######################################################################
+# There's a large speedup using ``vmap``!
+#
+# In general, vectorization with ``vmap`` should be faster than running a function
+# in a for-loop and competitive with manual batching. There are some exceptions
+# though, like if we haven’t implemented the ``vmap`` rule for a particular
+# operation or if the underlying kernels weren’t optimized for older hardware
+# (GPUs). If you see any of these cases, please let us know by opening an issue
+# on GitHub.
diff --git a/intermediate_source/forced_alignment_with_torchaudio_tutorial.rst b/intermediate_source/forced_alignment_with_torchaudio_tutorial.rst
new file mode 100644
index 00000000000..4c9752d016d
--- /dev/null
+++ b/intermediate_source/forced_alignment_with_torchaudio_tutorial.rst
@@ -0,0 +1,11 @@
+Forced Alignment with Wav2Vec2
+==============================
+
+This tutorial has been moved to https://pytorch.org/audio/stable/tutorials/forced_alignment_tutorial.html
+
+It will redirect in 3 seconds.
+
+.. raw:: html
+
+   <meta http-equiv="Refresh" content="3; url='https://pytorch.org/audio/stable/tutorials/forced_alignment_tutorial.html'" />
+
diff --git a/intermediate_source/forward_ad_usage.py b/intermediate_source/forward_ad_usage.py
new file mode 100644
index 00000000000..10965d64ab9
--- /dev/null
+++ b/intermediate_source/forward_ad_usage.py
@@ -0,0 +1,246 @@
+# -*- coding: utf-8 -*-
+"""
+Forward-mode Automatic Differentiation (Beta)
+=============================================
+
+This tutorial demonstrates how to use forward-mode AD to compute
+directional derivatives (or equivalently, Jacobian-vector products).
+
+The tutorial below uses some APIs only available in versions >= 1.11
+(or nightly builds).
+
+Also note that forward-mode AD is currently in beta. The API is
+subject to change and operator coverage is still incomplete.
+
+Basic Usage
+--------------------------------------------------------------------
+Unlike reverse-mode AD, forward-mode AD computes gradients eagerly
+alongside the forward pass. We can use forward-mode AD to compute a
+directional derivative by performing the forward pass as before,
+except we first associate our input with another tensor representing
+the direction of the directional derivative (or equivalently, the ``v``
+in a Jacobian-vector product). When an input, which we call "primal", is
+associated with a "direction" tensor, which we call "tangent", the
+resultant new tensor object is called a "dual tensor" for its connection
+to dual numbers[0].
+
+As the forward pass is performed, if any input tensors are dual tensors,
+extra computation is performed to propagate this "sensitivity" of the
+function.
+
+"""
+
+import torch
+import torch.autograd.forward_ad as fwAD
+
+primal = torch.randn(10, 10)
+tangent = torch.randn(10, 10)
+
+def fn(x, y):
+    return x ** 2 + y ** 2
+
+# All forward AD computation must be performed in the context of
+# a ``dual_level`` context. All dual tensors created in such a context
+# will have their tangents destroyed upon exit. This is to ensure that
+# if the output or intermediate results of this computation are reused
+# in a future forward AD computation, their tangents (which are associated
+# with this computation) won't be confused with tangents from the later
+# computation.
+with fwAD.dual_level():
+    # To create a dual tensor we associate a tensor, which we call the
+    # primal with another tensor of the same size, which we call the tangent.
+    # If the layout of the tangent is different from that of the primal,
+    # The values of the tangent are copied into a new tensor with the same
+    # metadata as the primal. Otherwise, the tangent itself is used as-is.
+    #
+    # It is also important to note that the dual tensor created by
+    # ``make_dual`` is a view of the primal.
+    dual_input = fwAD.make_dual(primal, tangent)
+    assert fwAD.unpack_dual(dual_input).tangent is tangent
+
+    # To demonstrate the case where the copy of the tangent happens,
+    # we pass in a tangent with a layout different from that of the primal
+    dual_input_alt = fwAD.make_dual(primal, tangent.T)
+    assert fwAD.unpack_dual(dual_input_alt).tangent is not tangent
+
+    # Tensors that do not have an associated tangent are automatically
+    # considered to have a zero-filled tangent of the same shape.
+    plain_tensor = torch.randn(10, 10)
+    dual_output = fn(dual_input, plain_tensor)
+
+    # Unpacking the dual returns a ``namedtuple`` with ``primal`` and ``tangent``
+    # as attributes
+    jvp = fwAD.unpack_dual(dual_output).tangent
+
+assert fwAD.unpack_dual(dual_output).tangent is None
+
+######################################################################
+# Usage with Modules
+# --------------------------------------------------------------------
+# To use ``nn.Module`` with forward AD, replace the parameters of your
+# model with dual tensors before performing the forward pass. At the
+# time of writing, it is not possible to create dual tensor
+# `nn.Parameter`s. As a workaround, one must register the dual tensor
+# as a non-parameter attribute of the module.
+
+import torch.nn as nn
+
+model = nn.Linear(5, 5)
+input = torch.randn(16, 5)
+
+params = {name: p for name, p in model.named_parameters()}
+tangents = {name: torch.rand_like(p) for name, p in params.items()}
+
+with fwAD.dual_level():
+    for name, p in params.items():
+        delattr(model, name)
+        setattr(model, name, fwAD.make_dual(p, tangents[name]))
+
+    out = model(input)
+    jvp = fwAD.unpack_dual(out).tangent
+
+######################################################################
+# Using the functional Module API (beta)
+# --------------------------------------------------------------------
+# Another way to use ``nn.Module`` with forward AD is to utilize
+# the functional Module API (also known as the stateless Module API).
+
+from torch.func import functional_call
+
+# We need a fresh module because the functional call requires the
+# the model to have parameters registered.
+model = nn.Linear(5, 5)
+
+dual_params = {}
+with fwAD.dual_level():
+    for name, p in params.items():
+        # Using the same ``tangents`` from the above section
+        dual_params[name] = fwAD.make_dual(p, tangents[name])
+    out = functional_call(model, dual_params, input)
+    jvp2 = fwAD.unpack_dual(out).tangent
+
+# Check our results
+assert torch.allclose(jvp, jvp2)
+
+######################################################################
+# Custom autograd Function
+# --------------------------------------------------------------------
+# Custom Functions also support forward-mode AD. To create custom Function
+# supporting forward-mode AD, register the ``jvp()`` static method. It is
+# possible, but not mandatory for custom Functions to support both forward
+# and backward AD. See the
+# `documentation <https://pytorch.org/docs/master/notes/extending.html#forward-mode-ad>`_
+# for more information.
+
+class Fn(torch.autograd.Function):
+    @staticmethod
+    def forward(ctx, foo):
+        result = torch.exp(foo)
+        # Tensors stored in ``ctx`` can be used in the subsequent forward grad
+        # computation.
+        ctx.result = result
+        return result
+
+    @staticmethod
+    def jvp(ctx, gI):
+        gO = gI * ctx.result
+        # If the tensor stored in`` ctx`` will not also be used in the backward pass,
+        # one can manually free it using ``del``
+        del ctx.result
+        return gO
+
+fn = Fn.apply
+
+primal = torch.randn(10, 10, dtype=torch.double, requires_grad=True)
+tangent = torch.randn(10, 10)
+
+with fwAD.dual_level():
+    dual_input = fwAD.make_dual(primal, tangent)
+    dual_output = fn(dual_input)
+    jvp = fwAD.unpack_dual(dual_output).tangent
+
+# It is important to use ``autograd.gradcheck`` to verify that your
+# custom autograd Function computes the gradients correctly. By default,
+# ``gradcheck`` only checks the backward-mode (reverse-mode) AD gradients. Specify
+# ``check_forward_ad=True`` to also check forward grads. If you did not
+# implement the backward formula for your function, you can also tell ``gradcheck``
+# to skip the tests that require backward-mode AD by specifying
+# ``check_backward_ad=False``, ``check_undefined_grad=False``, and
+# ``check_batched_grad=False``.
+torch.autograd.gradcheck(Fn.apply, (primal,), check_forward_ad=True,
+                         check_backward_ad=False, check_undefined_grad=False,
+                         check_batched_grad=False)
+
+######################################################################
+# Functional API (beta)
+# --------------------------------------------------------------------
+# We also offer a higher-level functional API in functorch
+# for computing Jacobian-vector products that you may find simpler to use
+# depending on your use case.
+#
+# The benefit of the functional API is that there isn't a need to understand
+# or use the lower-level dual tensor API and that you can compose it with
+# other `functorch transforms (like vmap) <https://pytorch.org/functorch/stable/notebooks/jacobians_hessians.html>`_;
+# the downside is that it offers you less control.
+#
+# Note that the remainder of this tutorial will require functorch
+# (https://github.com/pytorch/functorch) to run. Please find installation
+# instructions at the specified link.
+
+import functorch as ft
+
+primal0 = torch.randn(10, 10)
+tangent0 = torch.randn(10, 10)
+primal1 = torch.randn(10, 10)
+tangent1 = torch.randn(10, 10)
+
+def fn(x, y):
+    return x ** 2 + y ** 2
+
+# Here is a basic example to compute the JVP of the above function.
+# The ``jvp(func, primals, tangents)`` returns ``func(*primals)`` as well as the
+# computed Jacobian-vector product (JVP). Each primal must be associated with a tangent of the same shape.
+primal_out, tangent_out = ft.jvp(fn, (primal0, primal1), (tangent0, tangent1))
+
+# ``functorch.jvp`` requires every primal to be associated with a tangent.
+# If we only want to associate certain inputs to `fn` with tangents,
+# then we'll need to create a new function that captures inputs without tangents:
+primal = torch.randn(10, 10)
+tangent = torch.randn(10, 10)
+y = torch.randn(10, 10)
+
+import functools
+new_fn = functools.partial(fn, y=y)
+primal_out, tangent_out = ft.jvp(new_fn, (primal,), (tangent,))
+
+######################################################################
+# Using the functional API with Modules
+# --------------------------------------------------------------------
+# To use ``nn.Module`` with ``functorch.jvp`` to compute Jacobian-vector products
+# with respect to the model parameters, we need to reformulate the
+# ``nn.Module`` as a function that accepts both the model parameters and inputs
+# to the module.
+
+model = nn.Linear(5, 5)
+input = torch.randn(16, 5)
+tangents = tuple([torch.rand_like(p) for p in model.parameters()])
+
+# Given a ``torch.nn.Module``, ``ft.make_functional_with_buffers`` extracts the state
+# (``params`` and buffers) and returns a functional version of the model that
+# can be invoked like a function.
+# That is, the returned ``func`` can be invoked like
+# ``func(params, buffers, input)``.
+# ``ft.make_functional_with_buffers`` is analogous to the ``nn.Modules`` stateless API
+# that you saw previously and we're working on consolidating the two.
+func, params, buffers = ft.make_functional_with_buffers(model)
+
+# Because ``jvp`` requires every input to be associated with a tangent, we need to
+# create a new function that, when given the parameters, produces the output
+def func_params_only(params):
+    return func(params, buffers, input)
+
+model_output, jvp_out = ft.jvp(func_params_only, (params,), (tangents,))
+
+
+######################################################################
+# [0] https://en.wikipedia.org/wiki/Dual_number
diff --git a/intermediate_source/fx_profiling_tutorial.py b/intermediate_source/fx_profiling_tutorial.py
new file mode 100644
index 00000000000..7f31338d002
--- /dev/null
+++ b/intermediate_source/fx_profiling_tutorial.py
@@ -0,0 +1,233 @@
+# -*- coding: utf-8 -*-
+"""
+(beta) Building a Simple CPU Performance Profiler with FX
+*********************************************************
+**Author**: `James Reed <https://github.com/jamesr66a>`_
+
+In this tutorial, we are going to use FX to do the following:
+
+1) Capture PyTorch Python code in a way that we can inspect and gather
+   statistics about the structure and execution of the code
+2) Build out a small class that will serve as a simple performance "profiler",
+   collecting runtime statistics about each part of the model from actual
+   runs.
+
+"""
+
+######################################################################
+# For this tutorial, we are going to use the torchvision ResNet18 model
+# for demonstration purposes.
+
+import torch
+import torch.fx
+import torchvision.models as models
+
+rn18 = models.resnet18()
+rn18.eval()
+
+######################################################################
+# Now that we have our model, we want to inspect deeper into its
+# performance. That is, for the following invocation, which parts
+# of the model are taking the longest?
+input = torch.randn(5, 3, 224, 224)
+output = rn18(input)
+
+######################################################################
+# A common way of answering that question is to go through the program
+# source, add code that collects timestamps at various points in the
+# program, and compare the difference between those timestamps to see
+# how long the regions between the timestamps take.
+#
+# That technique is certainly applicable to PyTorch code, however it
+# would be nicer if we didn't have to copy over model code and edit it,
+# especially code we haven't written (like this torchvision model).
+# Instead, we are going to use FX to automate this "instrumentation"
+# process without needing to modify any source.
+
+######################################################################
+# First, let's get some imports out of the way (we will be using all
+# of these later in the code).
+
+import statistics, tabulate, time
+from typing import Any, Dict, List
+from torch.fx import Interpreter
+
+######################################################################
+# .. note::
+#     ``tabulate`` is an external library that is not a dependency of PyTorch.
+#     We will be using it to more easily visualize performance data. Please
+#     make sure you've installed it from your favorite Python package source.
+
+######################################################################
+# Capturing the Model with Symbolic Tracing
+# -----------------------------------------
+# Next, we are going to use FX's symbolic tracing mechanism to capture
+# the definition of our model in a data structure we can manipulate
+# and examine.
+
+traced_rn18 = torch.fx.symbolic_trace(rn18)
+print(traced_rn18.graph)
+
+######################################################################
+# This gives us a Graph representation of the ResNet18 model. A Graph
+# consists of a series of Nodes connected to each other. Each Node
+# represents a call-site in the Python code (whether to a function,
+# a module, or a method) and the edges (represented as ``args`` and ``kwargs``
+# on each node) represent the values passed between these call-sites. More
+# information about the Graph representation and the rest of FX's APIs ca
+# be found at the FX documentation https://pytorch.org/docs/master/fx.html.
+
+
+######################################################################
+# Creating a Profiling Interpreter
+# --------------------------------
+# Next, we are going to create a class that inherits from ``torch.fx.Interpreter``.
+# Though the ``GraphModule`` that ``symbolic_trace`` produces compiles Python code
+# that is run when you call a ``GraphModule``, an alternative way to run a
+# ``GraphModule`` is by executing each ``Node`` in the ``Graph`` one by one. That is
+# the functionality that ``Interpreter`` provides: It interprets the graph node-
+# by-node.
+#
+# By inheriting from ``Interpreter``, we can override various functionality and
+# install the profiling behavior we want. The goal is to have an object to which
+# we can pass a model, invoke the model 1 or more times, then get statistics about
+# how long the model and each part of the model took during those runs.
+#
+# Let's define our ``ProfilingInterpreter`` class:
+
+class ProfilingInterpreter(Interpreter):
+    def __init__(self, mod : torch.nn.Module):
+        # Rather than have the user symbolically trace their model,
+        # we're going to do it in the constructor. As a result, the
+        # user can pass in any ``Module`` without having to worry about
+        # symbolic tracing APIs
+        gm = torch.fx.symbolic_trace(mod)
+        super().__init__(gm)
+
+        # We are going to store away two things here:
+        #
+        # 1. A list of total runtimes for ``mod``. In other words, we are
+        #    storing away the time ``mod(...)`` took each time this
+        #    interpreter is called.
+        self.total_runtime_sec : List[float] = []
+        # 2. A map from ``Node`` to a list of times (in seconds) that
+        #    node took to run. This can be seen as similar to (1) but
+        #    for specific sub-parts of the model.
+        self.runtimes_sec : Dict[torch.fx.Node, List[float]] = {}
+
+    ######################################################################
+    # Next, let's override our first method: ``run()``. ``Interpreter``'s ``run``
+    # method is the top-level entry point for execution of the model. We will
+    # want to intercept this so that we can record the total runtime of the
+    # model.
+
+    def run(self, *args) -> Any:
+        # Record the time we started running the model
+        t_start = time.time()
+        # Run the model by delegating back into Interpreter.run()
+        return_val = super().run(*args)
+        # Record the time we finished running the model
+        t_end = time.time()
+        # Store the total elapsed time this model execution took in the
+        # ``ProfilingInterpreter``
+        self.total_runtime_sec.append(t_end - t_start)
+        return return_val
+
+    ######################################################################
+    # Now, let's override ``run_node``. ``Interpreter`` calls ``run_node`` each
+    # time it executes a single node. We will intercept this so that we
+    # can measure and record the time taken for each individual call in
+    # the model.
+
+    def run_node(self, n : torch.fx.Node) -> Any:
+        # Record the time we started running the op
+        t_start = time.time()
+        # Run the op by delegating back into Interpreter.run_node()
+        return_val = super().run_node(n)
+        # Record the time we finished running the op
+        t_end = time.time()
+        # If we don't have an entry for this node in our runtimes_sec
+        # data structure, add one with an empty list value.
+        self.runtimes_sec.setdefault(n, [])
+        # Record the total elapsed time for this single invocation
+        # in the runtimes_sec data structure
+        self.runtimes_sec[n].append(t_end - t_start)
+        return return_val
+
+    ######################################################################
+    # Finally, we are going to define a method (one which doesn't override
+    # any ``Interpreter`` method) that provides us a nice, organized view of
+    # the data we have collected.
+
+    def summary(self, should_sort : bool = False) -> str:
+        # Build up a list of summary information for each node
+        node_summaries : List[List[Any]] = []
+        # Calculate the mean runtime for the whole network. Because the
+        # network may have been called multiple times during profiling,
+        # we need to summarize the runtimes. We choose to use the
+        # arithmetic mean for this.
+        mean_total_runtime = statistics.mean(self.total_runtime_sec)
+
+        # For each node, record summary statistics
+        for node, runtimes in self.runtimes_sec.items():
+            # Similarly, compute the mean runtime for ``node``
+            mean_runtime = statistics.mean(runtimes)
+            # For easier understanding, we also compute the percentage
+            # time each node took with respect to the whole network.
+            pct_total = mean_runtime / mean_total_runtime * 100
+            # Record the node's type, name of the node, mean runtime, and
+            # percent runtime.
+            node_summaries.append(
+                [node.op, str(node), mean_runtime, pct_total])
+
+        # One of the most important questions to answer when doing performance
+        # profiling is "Which op(s) took the longest?". We can make this easy
+        # to see by providing sorting functionality in our summary view
+        if should_sort:
+            node_summaries.sort(key=lambda s: s[2], reverse=True)
+
+        # Use the ``tabulate`` library to create a well-formatted table
+        # presenting our summary information
+        headers : List[str] = [
+            'Op type', 'Op', 'Average runtime (s)', 'Pct total runtime'
+        ]
+        return tabulate.tabulate(node_summaries, headers=headers)
+
+######################################################################
+# .. note::
+#       We use Python's ``time.time`` function to pull wall clock
+#       timestamps and compare them. This is not the most accurate
+#       way to measure performance, and will only give us a first-
+#       order approximation. We use this simple technique only for the
+#       purpose of demonstration in this tutorial.
+
+######################################################################
+# Investigating the Performance of ResNet18
+# -----------------------------------------
+# We can now use ``ProfilingInterpreter`` to inspect the performance
+# characteristics of our ResNet18 model;
+
+interp = ProfilingInterpreter(rn18)
+interp.run(input)
+print(interp.summary(True))
+
+######################################################################
+# There are two things we should call out here:
+#
+# * ``MaxPool2d`` takes up the most time. This is a known issue:
+#   https://github.com/pytorch/pytorch/issues/51393
+#
+#
+# Conclusion
+# ----------
+# As we can see, using FX we can easily capture PyTorch programs (even
+# ones we don't have the source code for!) in a machine-interpretable
+# format and use that for analysis, such as the performance analysis
+# we've done here. FX opens up an exciting world of possibilities for
+# working with PyTorch programs.
+#
+# Finally, since FX is still in beta, we would be happy to hear any
+# feedback you have about using it. Please feel free to use the
+# PyTorch Forums (https://discuss.pytorch.org/) and the issue tracker
+# (https://github.com/pytorch/pytorch/issues) to provide any feedback
+# you might have.
diff --git a/intermediate_source/inductor_debug_cpu.py b/intermediate_source/inductor_debug_cpu.py
new file mode 100644
index 00000000000..4b6d62c0b0d
--- /dev/null
+++ b/intermediate_source/inductor_debug_cpu.py
@@ -0,0 +1,637 @@
+# -*- coding: utf-8 -*-
+
+"""
+Inductor CPU backend debugging and profiling
+============================================
+
+**Authors**: `Xuan Liao <https://github.com/Valentine233>`_, `Haozhe Zhu <https://github.com/zhuhaozhe>`_, `Jiong Gong <https://github.com/jgong5>`_, `Weihan Wang <https://github.com/EikanWang>`_
+"""
+
+#########################################################################
+# Overview
+# --------
+# 
+# PyTorch 2.0 introduced the compilation API called ``torch.compile``. 
+# This new feature offers a significant speedup over eager mode execution through graph-level optimization powered by the default Inductor backend.
+#
+# This tutorial is intended to provide an in-depth introduction on the debugging 
+# and performance profiling on Inductor CPU backend by delving into the intricacies of ``torch.compile``. 
+#
+# Meanwhile, you may also find related tutorials about ``torch.compile`` 
+# around `basic usage <https://pytorch.org/tutorials/intermediate/torch_compile_tutorial.html>`_, 
+# comprehensive `troubleshooting <https://pytorch.org/docs/stable/torch.compiler_troubleshooting.html>`_ 
+# and GPU-specific knowledge like `GPU performance profiling <https://pytorch.org/docs/stable/torch.compiler_inductor_profiling.html>`_.
+#
+# We will start debugging with a motivating example that triggers compilation issues and accuracy problems 
+# by demonstrating the process of debugging to pinpoint the problems.
+#
+# By enabling logging and exploring the underlying generated code, 
+# you can learn how to narrow down the failure step by step and finally figure out the route cause.
+#
+# Following that, we will proceed to discuss how to profile the compiled code and, 
+# through a performance comparison with eager mode, 
+# elaborate on the reasons why ``torch.compile`` can provide an additional performance boost compared to its eager counterpart.
+
+
+######################################################################
+# Debugging
+# ---------
+#
+# Here is a simple example to run the ``torch.compile`` using Inductor and compare its result with eager mode:
+
+import torch
+
+def foo1(x1, x2):
+    a = torch.neg(x1)
+    b = torch.maximum(x2, a)
+    y = torch.cat([b], dim=0)
+    return y
+
+x1 = torch.randint(256, (1, 8), dtype=torch.uint8)
+x2 = torch.randint(256, (8390, 8), dtype=torch.uint8)
+
+compiled_foo1 = torch.compile(foo1)
+result = compiled_foo1(x1, x2)
+
+######################################################################
+# The correct implementation of ``neg`` in the ``cpp`` codegen is as follows:
+
+def neg1(x):
+    return f"decltype({x})(-{x})"
+
+######################################################################
+# In order to demonstrate the debugging, we will modify the function to a wrong one later.
+#
+#
+# Get more logging information
+# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#
+# No debugging information would be provided if you run this simple example by default. In order to get more useful debugging and logging information, we usually add a ``TORCH_COMPILE_DEBUG`` environment variable like below:
+#
+# .. code-block:: shell
+#
+# 	TORCH_COMPILE_DEBUG=1 python xx.py
+#
+# This would print more debug information in the output logs and also dump the intermediate IRs generated during the codegen process. You can find the dumped file paths in the log like below:
+#
+# .. code-block:: shell
+#
+# 	torch._inductor.debug: [WARNING] model___20 debug trace: /tmp/torchinductor_root/rx/crxfi2ybd7yp5sbj2pnhw33wfhtdw7wumvrobyp5sjvdui5ktjc2.debug
+#
+# In this directory, the following files are saved for debugging purposes:
+#
+# +-----------------------------+----------------------------------------------------------------+
+# | File                        | Description                                                    |
+# +=============================+================================================================+
+# | ``fx_graph_runnable.py``    | Executable FX graph, after decomposition, before pattern match |
+# +-----------------------------+----------------------------------------------------------------+
+# | ``fx_graph_transformed.py`` | Transformed FX graph, after pattern match                      |
+# +-----------------------------+----------------------------------------------------------------+
+# | ``ir_pre_fusion.txt``       | Inductor IR before fusion                                      |
+# +-----------------------------+----------------------------------------------------------------+
+# | ``ir_post_fusion.txt``      | Inductor IR after fusion                                       |
+# +-----------------------------+----------------------------------------------------------------+
+# | ``output_code.py``          | Generated Python code for graph, with C++/Triton kernels       |
+# +-----------------------------+----------------------------------------------------------------+
+#
+# Note that ``fx_graph_runnable.py`` and ``output_code.py`` are both runnable and editable in order to make debugging easier. 
+# Here are the main parts of code extracted from the files and we correlate the C++ generated line with the FX code line.
+#
+# ``fx_graph_runnable``:
+#
+
+def forward1(self, arg0_1, arg1_1):
+    neg = torch.ops.aten.neg.default(arg0_1);  arg0_1 = None
+    maximum = torch.ops.aten.maximum.default(arg1_1, neg);  arg1_1 = neg = None
+    clone = torch.ops.aten.clone.default(maximum);  maximum = None
+    return (clone,)
+
+######################################################################
+# C++ kernel in ``output_code``:
+#
+
+import torch
+from torch._inductor.async_compile import AsyncCompile
+async_compile = AsyncCompile()
+
+cpp_fused_cat_maximum_neg_0 = async_compile.cpp('''
+#include "/tmp/torchinductor_root/gv/cgv6n5aotqjo5w4vknjibhengeycuattfto532hkxpozszcgxr3x.h"
+extern "C" void kernel(const unsigned char* in_ptr0,
+                       const unsigned char* in_ptr1,
+                       unsigned char* out_ptr0)
+{
+    {
+        #pragma GCC ivdep
+        for(long i0=static_cast<long>(0L); i0<static_cast<long>(8390L); i0+=static_cast<long>(1L))
+        {
+            #pragma GCC ivdep
+            for(long i1=static_cast<long>(0L); i1<static_cast<long>(8L); i1+=static_cast<long>(1L))
+            {
+                auto tmp0 = in_ptr0[static_cast<long>(i1 + (8L*i0))];
+                auto tmp1 = in_ptr1[static_cast<long>(i1)];
+                // Corresponding FX code line: neg = torch.ops.aten.neg.default(arg0_1);  arg0_1 = None
+                auto tmp2 = decltype(tmp1)(-tmp1);
+                // Corresponding FX code line: maximum = torch.ops.aten.maximum.default(arg1_1, neg);  arg1_1 = neg = None
+                auto tmp3 = max_propagate_nan(tmp0, tmp2);
+                // Corresponding FX code line: clone = torch.ops.aten.clone.default(maximum);  maximum = None
+                out_ptr0[static_cast<long>(i1 + (8L*i0))] = tmp3;
+            }
+        }
+    }
+}''')
+
+
+######################################################################
+# Determine component of error
+# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#
+# When encountering errors or accuracy problems, a straightforward solution to find the bug is to narrow down the problem. The first thing to do is to determine the component where the error occurs. Luckily, it can be simply achieved by changing the backend of ``torch.compile``.
+#
+# +--------------------------------------------+-----------------------------------------+
+# | Code                                       | Description                             |
+# +============================================+=========================================+
+# | ``torch.compile(fn, backend="eager")``     | Enable Dynamo                           |
+# +--------------------------------------------+-----------------------------------------+
+# | ``torch.compile(fn, backend="aot_eager")`` | Enable Dynamo + AOT Autograd            |
+# +--------------------------------------------+-----------------------------------------+
+# | ``torch.compile(fn, backend="inductor")``  | Enable Dynamo + AOT Autograd + Inductor |
+# +--------------------------------------------+-----------------------------------------+
+#
+# If the model can successfully run when the backend is set to ``eager`` or ``aot_eager`` while it fails with ``inductor``, we can narrow down the failure to Inductor.
+#
+#
+# Compilation error
+# ^^^^^^^^^^^^^^^^^
+#
+# As we know, the evolved chain of graph-level optimization is like:
+#
+# .. code-block:: sh
+#
+# 	torch.neg (Python) -> torch.ops.aten.neg.default (within FX graph) -> ops.neg (within IR node) -> tmp2 = -tmp1 (within C++ kernel)
+#
+# If you encounter a compilation error, there is something wrong when compiling C++ kernels in the output code.
+# This type of error indicates that bugs are introduced when lowering IR nodes to output code.
+# The root cause of compilation error is usually shown in the traceback log.
+#
+# For example, the ``neg`` function is modified like this:
+
+def neg2(x):
+    return f"-{x}"
+
+######################################################################
+# The logging gives the following compile error with a rather clear reason.
+#
+# .. code-block::
+#
+#    torch._dynamo.exc.BackendCompilerFailed: backend='inductor' raised:
+#    CppCompileError: C++ compile error
+#    /tmp/torchinductor_root/xg/cxga5tk3b4lkwoxyigrtocjp5s7vc5cg2ikuscf6bk6pjqip2bhx.cpp: In function ‘void kernel(const unsigned char*, const unsigned char*, unsigned char*)’:
+#    /tmp/torchinductor_root/xg/cxga5tk3b4lkwoxyigrtocjp5s7vc5cg2ikuscf6bk6pjqip2bhx.cpp:17:57: error: no matching function for call to ‘max_propagate_nan(unsigned char&, int&)’
+#      17 |                 auto tmp3 = max_propagate_nan(tmp0, tmp2);
+#           |                                                         ^
+#    In file included from /tmp/torchinductor_root/xg/cxga5tk3b4lkwoxyigrtocjp5s7vc5cg2ikuscf6bk6pjqip2bhx.cpp:2:
+#    /tmp/torchinductor_root/gv/cgv6n5aotqjo5w4vknjibhengeycuattfto532hkxpozszcgxr3x.h:27:17: note: candidate: ‘template<class scalar_t> scalar_t max_propagate_nan(scalar_t, scalar_t)’
+#    27 | inline scalar_t max_propagate_nan(scalar_t a, scalar_t b) {
+#         |                 ^~~~~~~~~~~~~~~~~
+#    /tmp/torchinductor_root/gv/cgv6n5aotqjo5w4vknjibhengeycuattfto532hkxpozszcgxr3x.h:27:17: note:   template argument deduction/substitution failed:
+#   /tmp/torchinductor_root/xg/cxga5tk3b4lkwoxyigrtocjp5s7vc5cg2ikuscf6bk6pjqip2bhx.cpp:17:57: note:   deduced conflicting types for parameter ‘scalar_t’ (‘unsigned char’ and ‘int’)
+#    17 |                 auto tmp3 = max_propagate_nan(tmp0, tmp2);
+#         |                                                         ^
+#
+#
+# Let us also see the corresponding C++ kernel in output code and IR node.
+#
+# C++ kernel:
+#
+# .. code:: c
+#
+#     include "/tmp/torchinductor_root/gv/cgv6n5aotqjo5w4vknjibhengeycuattfto532hkxpozszcgxr3x.h"
+#     extern "C" void kernel(const unsigned char* in_ptr0,
+#                         const unsigned char* in_ptr1,
+#                         unsigned char* out_ptr0)
+#     {
+#         {
+#             #pragma GCC ivdep
+#             for(long i0=static_cast<long>(0L); i0<static_cast<long>(8390L); i0+=static_cast<long>(1L))
+#             {
+#                 #pragma GCC ivdep
+#                 for(long i1=static_cast<long>(0L); i1<static_cast<long>(8L); i1+=static_cast<long>(1L))
+#                 {
+#                     auto tmp0 = in_ptr0[static_cast<long>(i1 + (8L*i0))];
+#                     auto tmp1 = in_ptr1[static_cast<long>(i1)];
+#                     auto tmp2 = -tmp1;
+#                     auto tmp3 = max_propagate_nan(tmp0, tmp2);
+#                     out_ptr0[static_cast<long>(i1 + (8L*i0))] = tmp3;
+#                 }
+#             }
+#         }
+#     }
+#
+
+######################################################################
+# IR node:
+#
+# .. code-block:: sh
+#
+#     buf0: SchedulerNode(ComputedBuffer)
+#     buf0.writes = [MemoryDep('buf0', c0, {c0: 67120})]
+#     buf0.unmet_dependencies = []
+#     buf0.met_dependencies = 
+#         [   MemoryDep('arg0_1', c1, {c0: 8390, c1: 8}),
+#             MemoryDep('arg1_1', c0, {c0: 67120})]
+#     buf0.users = [NodeUser(node=OUTPUT, can_inplace=False)]
+#     buf0.group.device = cpu
+#     buf0.group.iteration = ((8390, 8), ())
+#     buf0.sizes = ([8390, 8], [])
+#     class buf0_loop_body:
+#         var_ranges = {z0: 8390, z1: 8}
+#         index0 = 8*z0 + z1
+#         index1 = z1
+#         def body(self, ops):
+#             get_index = self.get_index('index0')
+#             load = ops.load('arg1_1', get_index)
+#             get_index_1 = self.get_index('index1')
+#             load_1 = ops.load('arg0_1', get_index_1)
+#             neg = ops.neg(load_1)
+#             maximum = ops.maximum(load, neg)
+#             get_index_2 = self.get_index('index0')
+#             store = ops.store('buf0', get_index_2, maximum, None)
+#             return store
+#
+
+######################################################################
+# According to the traceback logging, the compilation error is caused by the data type inconsistency of ``max_propagate_nan``'s inputs. 
+# By checking the C++ kernel, we know that ``tmp2`` is no longer ``long`` after doing ``-`` as ``tmp0`` is ``long``.
+# We can easily match ``-`` and ``max_propagate_nan`` in C++ kernel with ``ops.neg`` and ``ops.maximum`` in IR node respectively.
+#
+# Now we successfully find that the root cause is the implementation of ``ops.neg`` in ``cpp`` codegen, which silently changes the data type when doing ``neg``. 
+#
+#
+# Accuracy debugging
+# ^^^^^^^^^^^^^^^^^^^
+#
+# Otherwise, if the model runs with other errors or accuracy problem, you can use the PyTorch debugging tool called `Minifier <https://pytorch.org/functorch/stable/notebooks/minifier.html>`_. 
+#
+# The core idea of ``Minifier`` is to keep removing the nodes and inputs of graph until finding the minimal graph with problem.
+# It helps to automatically generate a minified problematic graph through 4 strategies: truncating suffix, delta debugging, eliminating dead code and removing unused inputs.
+#
+#
+# We will now show the debugging process for the accuracy problem with the help of ``Minifer``. 
+# The accuracy problem refers to the case where the outputs of backends eager and inductor are different. 
+#
+# For instance, we modify the example like this:
+
+from torch._dynamo.utils import same
+
+def foo2(x1, x2):
+    a = torch.neg(x1)
+    b = torch.maximum(x2, a)
+    y = torch.cat([b], dim=0)
+    return y
+
+x1 = torch.randn((1, 8), dtype=torch.float32)
+x2 = torch.randn((8390, 8), dtype=torch.float32)
+
+expected_result = foo2(x1, x2)
+
+compiled_foo2 = torch.compile(foo2)
+actual_result = compiled_foo2(x1, x2)
+
+assert same(expected_result, actual_result) == True
+
+######################################################################
+# And also modify the ``neg`` function:
+
+def neg3(x):
+    return f"decltype({x})(2 * {x})"
+
+######################################################################
+# An accuracy problem would be raised as follows:
+#
+# .. code-block:: sh
+#
+# 	torch._dynamo.utils: [ERROR] Accuracy failed: allclose not within tol=0.0001
+# 	Traceback (most recent call last):
+# 	  File "test_script.py", line 18, in <module>
+# 	    assert same(expected_result, actual_result) == True
+# 	AssertionError
+#
+# To debug an accuracy problem with Minifier, two environment variables are needed:
+#
+# .. code-block:: sh
+#
+#    TORCHDYNAMO_REPRO_AFTER="aot" TORCHDYNAMO_REPRO_LEVEL=4 python xx.py
+#
+# Which gives us logging information that demonstrates the steps of minifying:
+#
+# .. code-block:: sh
+#
+#     Started off with 6 nodes
+#
+#     Trying granularity 2
+#     Strategy: Truncate suffix (G: 2) (6 nodes, 2 inputs)
+#     SUCCESS: Went from 6 to 4 nodes
+#
+#     Trying granularity 4
+#     Strategy: Remove unused inputs (G: 4) (4 nodes, 2 inputs)
+#     SUCCESS: Went from 4 to 3 nodes
+#
+# After running, we get the final minified graph with the target node ``neg``:
+
+def forward2(self, arg0_1):
+    neg = torch.ops.aten.neg.default(arg0_1);  arg0_1 = None
+    return (neg,)
+
+######################################################################
+# For more usage details about Minifier, please refer to `Troubleshooting <https://pytorch.org/docs/stable/torch.compiler_troubleshooting.html>`_.
+
+
+######################################################################
+# Performance profiling
+# ---------------------
+#
+# Within this section, we will demonstrate the process of conducting performance analysis for a model that has been compiled using the Inductor CPU backend.
+# In the example below, we benchmark a Hugging Face Transformer model ``MobileBertForQuestionAnswering`` with both the eager mode and the Inductor graph mode.
+# The execution time and the speedup ratio of Inductor are printed after the benchmark.
+# We use Intel(R) Xeon(R) Platinum 8358 CPU @ 2.60GHz and run benchmark on the first socket to demonstrate the optimization within this section.
+# We set following environment variable as a best practice to benchmark on Intel(R) CPU.
+
+#########################################################
+# .. code-block:: shell
+#
+#     export KMP_BLOCKTIME=1
+#     export KMP_SETTINGS=1
+#     export KMP_AFFINITY=granularity=fine,compact,1,0
+#     export LD_PRELOAD=${CONDA_PREFIX:-"$(dirname $(which conda))/../"}/lib/libiomp5.so:${CONDA_PREFIX:-"$(dirname $(which conda))/../"}/lib/libjemalloc.so
+#     export MALLOC_CONF="oversize_threshold:1,background_thread:true,metadata_thp:auto,dirty_decay_ms:-1,muzzy_decay_ms:-1"
+#     numactl -C 0-31 -m 0 python bench.py
+#
+
+# bench.py
+from transformers import MobileBertForQuestionAnswering
+# Initialize an eager model
+model = MobileBertForQuestionAnswering.from_pretrained("csarron/mobilebert-uncased-squad-v2")
+seq_length = 128
+bs = 128
+vocab_size = model.config.vocab_size
+input = torch.randint(0, vocab_size, (bs, seq_length), dtype=torch.int64)
+input_dict = {"input_ids": input}
+
+# Initialize the inductor model
+compiled_model = torch.compile(model)
+with torch.no_grad():
+    compiled_model(**input_dict)
+
+NUM_ITERS=50
+import timeit
+with torch.no_grad():
+    # warmup
+    for _ in range(10):
+        model(**input_dict)
+    eager_t = timeit.timeit("model(**input_dict)", number=NUM_ITERS, globals=globals())
+
+with torch.no_grad():
+    # warmup
+    for _ in range(10):
+        compiled_model(**input_dict)
+    inductor_t = timeit.timeit("compiled_model(**input_dict)", number=NUM_ITERS, globals=globals())
+# print(f"eager use: {eager_t * 1000 / NUM_ITERS} ms/iter")
+# print(f"inductor use: {inductor_t * 1000 / NUM_ITERS} ms/iter")
+# print(f"speed up ratio: {eager_t / inductor_t}")
+
+
+######################################################################
+# Output:
+#
+# .. code-block:: shell
+#
+#     eager use: 802.1023553796113 ms/iter
+#     inductor use: 339.95180135127157 ms/iter
+#     speed up ratio: 2.359459053287382
+#
+# In our own testing, we find the Inductor CPU backend speed up the model by around 2.355x.
+#
+#
+# Next, let's dive deep into the performance at the operation level to understand where the speed-up comes from.
+# `Pytorch Profiler <https://pytorch.org/tutorials/recipes/recipes/profiler_recipe.html>`_ is a good tool to help us. 
+# Inductor CPU backend has the support to report the time of the fusion kernels to the profiler with the ``enable_kernel_profile`` configuration option:
+
+from torch._inductor import config
+config.cpp.enable_kernel_profile = True
+
+######################################################################
+# Following the steps in `Pytorch Profiler <https://pytorch.org/tutorials/recipes/recipes/profiler_recipe.html>`_
+# We are able to get the profiling table and trace files.
+
+# bench.py
+from torch.profiler import profile, schedule, ProfilerActivity
+RESULT_DIR = "./prof_trace"
+my_schedule = schedule(
+    skip_first=10,
+    wait=5,
+    warmup=5,
+    active=1,
+    repeat=5)
+
+def trace_handler(p):
+    output = p.key_averages().table(sort_by="self_cpu_time_total", row_limit=20)
+    # print(output)
+    p.export_chrome_trace(f"{RESULT_DIR}/{p.step_num}.json")
+
+for _ in range(10):
+    model(**input_dict)  # compiled_model(**input_dict) to get inductor model profiling
+
+total = 0
+with profile(
+    activities=[ProfilerActivity.CPU],
+    schedule=my_schedule,
+    on_trace_ready=trace_handler
+) as p:
+    for _ in range(50):
+        model(**input_dict)  # compiled_model(**input_dict) to get inductor model profiling
+        p.step()
+
+######################################################################
+# We get the following performance profiling table for the eager-mode model (omitting some columns):
+#
+# .. code-block:: shell
+#
+#     -------------------------  ------------  ------------  ------------
+#                          Name   CPU total %     CPU total    # of Calls
+#     -------------------------  ------------  ------------  ------------
+#                   aten::addmm        45.73%     370.814ms           362
+#                     aten::add        19.89%     161.276ms           363
+#                   aten::copy_        14.97%     121.416ms           488
+#                     aten::mul         9.02%      73.154ms           194
+#               aten::clamp_min         8.81%      71.444ms            96
+#                     aten::bmm         5.46%      44.258ms            48
+#                 ProfilerStep*       100.00%     810.920ms             1
+#                     aten::div         2.89%      23.447ms            24
+#                aten::_softmax         1.00%       8.087ms            24
+#                  aten::linear        46.48%     376.888ms           362
+#                   aten::clone         2.77%      22.430ms            98
+#                       aten::t         0.31%       2.502ms           362
+#                    aten::view         0.14%       1.161ms           850
+#               aten::transpose         0.17%       1.377ms           386
+#            aten::index_select         0.12%     952.000us             3
+#                  aten::expand         0.12%     986.000us           458
+#                  aten::matmul         8.31%      67.420ms            48
+#                     aten::cat         0.09%     703.000us             1
+#              aten::as_strided         0.08%     656.000us           963
+#                    aten::relu         8.86%      71.864ms            96
+#     -------------------------  ------------  ------------  ------------
+#     Self CPU time total: 810.920ms
+#
+
+######################################################################
+#
+# Similarly, we also get the table for the compiled model with Inductor (omitting some columns):
+#
+# .. code-block:: shell
+#
+#     -----------------------------------------------  ------------  ------------  ------------
+#                                                Name   CPU total %     CPU total    # of Calls
+#     -----------------------------------------------  ------------  ------------  ------------
+#                                    mkl::_mkl_linear        68.79%     231.573ms           362
+#                                           aten::bmm         8.02%      26.992ms            48
+#                                       ProfilerStep*       100.00%     336.642ms             1
+#       graph_0_cpp_fused_constant_pad_nd_embedding_0         0.27%     915.000us             1
+#                                         aten::empty         0.27%     911.000us           362
+#      graph_0_cpp_fused__mkl_linear_add_mul_relu_151         0.27%     901.000us             1
+#      graph_0_cpp_fused__mkl_linear_add_mul_relu_226         0.27%     899.000us             1
+#      graph_0_cpp_fused__mkl_linear_add_mul_relu_361         0.27%     898.000us             1
+#      graph_0_cpp_fused__mkl_linear_add_mul_relu_121         0.27%     895.000us             1
+#       graph_0_cpp_fused__mkl_linear_add_mul_relu_31         0.27%     893.000us             1
+#       graph_0_cpp_fused__mkl_linear_add_mul_relu_76         0.26%     892.000us             1
+#      graph_0_cpp_fused__mkl_linear_add_mul_relu_256         0.26%     892.000us             1
+#      graph_0_cpp_fused__mkl_linear_add_mul_relu_346         0.26%     892.000us             1
+#      graph_0_cpp_fused__mkl_linear_add_mul_relu_241         0.26%     891.000us             1
+#      graph_0_cpp_fused__mkl_linear_add_mul_relu_316         0.26%     891.000us             1
+#       graph_0_cpp_fused__mkl_linear_add_mul_relu_91         0.26%     890.000us             1
+#      graph_0_cpp_fused__mkl_linear_add_mul_relu_106         0.26%     890.000us             1
+#      graph_0_cpp_fused__mkl_linear_add_mul_relu_211         0.26%     890.000us             1
+#       graph_0_cpp_fused__mkl_linear_add_mul_relu_61         0.26%     889.000us             1
+#      graph_0_cpp_fused__mkl_linear_add_mul_relu_286         0.26%     889.000us             1
+#     -----------------------------------------------  ------------  ------------  ------------
+#     Self CPU time total: 336.642ms 
+#
+# From the profiling table of the eager model, we can see the most time consumption ops are [``aten::addmm``, ``aten::add``, ``aten::copy_``, ``aten::mul``, ``aten::clamp_min``, ``aten::bmm``].
+# Comparing with the inductor model profiling table, we notice an ``mkl::_mkl_linear`` entry and multiple fused kernels in the form ``graph_0_cpp_fused_*``. They are the major
+# optimizations that the inductor model is doing. Let us discuss them separately.
+#
+# (1) Regarding ``mkl::_mkl_linear``: You may notice the number of calls to this kernel is 362, which is exactly the same as ``aten::linear`` in the eager model profiling table.
+# The CPU total of ``aten::linear`` is 376.888ms, while it is 231.573ms for ``mkl::_mkl_linear``. This suggests a ~1.63x for the "linear" part.
+# The speedup mainly comes from `packing the weight tensor to block memory format <https://www.intel.com/content/www/us/en/docs/onemkl/developer-reference-c/2023-1/cblas-gemm-pack-002.html>`_
+# and invoking `cblas_sgemm_compute <https://www.intel.com/content/www/us/en/docs/onemkl/developer-reference-c/2023-1/cblas-gemm-compute-002.html>`_ within the Inductor CPU backend
+# to have a better cache behavior during GEMM computation.
+#
+# (2) Regarding other memory-intensive ops: The end-to-end latency for the eager/inductor model is 802/339ms in our testing. So we can roughly infer that the speed up for the other memory-intensive ops is around 3.94x.
+# Let's read the generated code to understand how the inductor achieves this impressive optimization. You can find the generated code by 
+# searching ``cpp_fused__mkl_linear_add_mul_relu_151`` in ``output_code.py``
+# 
+
+
+cpp_fused__mkl_linear_add_mul_relu_151 = async_compile.cpp('''
+#include <ATen/record_function.h>
+#include "/tmp/torchinductor_root/lr/clrlgu27q4ggd472umdzwsu6qcpqxcuusjxqvx2hwitjbujiiz7z.h"
+extern "C" void kernel(float* in_out_ptr0,
+                       const float* in_ptr0,
+                       const float* in_ptr1,
+                       const float* in_ptr2,
+                       const float* in_ptr3)
+{
+    RECORD_FUNCTION("graph_0_cpp_fused__mkl_linear_add_mul_relu_151", c10::ArrayRef<c10::IValue>({}));
+    #pragma omp parallel num_threads(32)
+    {
+        {
+            #pragma omp for 
+            for(long i0=static_cast<long>(0L); i0<static_cast<long>(16384L); i0+=static_cast<long>(1L))
+            {
+                for(long i1=static_cast<long>(0L); i1<static_cast<long>(512L); i1+=static_cast<long>(8L))
+                {
+                    auto tmp0 = at::vec::Vectorized<float>::loadu(in_ptr0 + static_cast<long>(i1 + (512L*i0)));
+                    auto tmp1 = at::vec::Vectorized<float>::loadu(in_ptr1 + static_cast<long>(i1));
+                    auto tmp3 = at::vec::Vectorized<float>::loadu(in_out_ptr0 + static_cast<long>(i1 + (512L*i0)));
+                    auto tmp5 = at::vec::Vectorized<float>::loadu(in_ptr2 + static_cast<long>(i1));
+                    auto tmp7 = at::vec::Vectorized<float>::loadu(in_ptr3 + static_cast<long>(i1));
+                    auto tmp2 = tmp0 + tmp1;
+                    auto tmp4 = tmp2 + tmp3;
+                    auto tmp6 = tmp4 * tmp5;
+                    auto tmp8 = tmp6 + tmp7;
+                    tmp8.store(in_out_ptr0 + static_cast<long>(i1 + (512L*i0)));
+                }
+            }
+        }
+    }
+}''')
+
+######################################################################
+# From the generated code above, we can see this kernel has done a typical `Loop Fusion <https://en.wikipedia.org/wiki/Loop_fission_and_fusion>`_ on ``[add, add, mul, add]``.
+# This is a memory-bound bottle neck preventing good performance. To get a more intuitive feeling about this optimization, 
+# we can infer the sizes and stride of the inputs and further benchmark this ``[add, add, mul, add]`` pattern.
+
+# bench.py
+def func(arg_0, arg_1, arg_2, arg_3, arg_4):
+    add_0 = arg_0 + arg_1
+    add_1 = add_0 + arg_2
+    mul_1 = add_1 * arg_3
+    add_2 = mul_1 + arg_4
+    arg_2 = add_2
+    return arg_2
+
+arg_0 = torch.rand(16384, 512)
+arg_1 = torch.rand(1, 512)
+arg_2 = torch.zeros(16384, 512)
+arg_3 = torch.rand(1, 512)
+arg_4 = torch.rand(1, 512)
+
+input = (arg_0, arg_1, arg_2, arg_3, arg_4)
+inductor_func = torch.compile(func)
+with torch.no_grad():
+    inductor_func(*input)
+
+import timeit
+NUM_ITERS=100
+with torch.no_grad():
+    # warmup
+    for _ in range(10):
+        func(*input)
+    eager_t = timeit.timeit("func(*input)", number=NUM_ITERS, globals=globals())
+
+with torch.no_grad():
+    # warmup
+    for _ in range(10):
+        inductor_func(*input)
+    inductor_t = timeit.timeit("inductor_func(*input)", number=NUM_ITERS, globals=globals())
+# print(f"eager use: {eager_t * 1000 / NUM_ITERS} ms/iter")
+# print(f"inductor use: {inductor_t * 1000 / NUM_ITERS} ms/iter")
+# print(f"speed up ratio: {eager_t / inductor_t}")
+
+######################################################################
+# Output:
+#
+# .. code-block:: shell
+#
+#     eager use: 5.780875144992024 ms/iter
+#     inductor use: 0.9588955780491233 ms/iter
+#     speed up ratio: 6.0286805751604735
+#
+#
+# This is just an example. The profiling table shows all element-wise op are fused within the inductor automatically in this model. You can read more kernels in
+# `output_code.py`
+
+
+#########################################################################
+# Conclusion
+# ----------
+#
+# The document gives an in-depth tutorial for the Inductor CPU backend.
+#
+# With motivating examples, we walk through the process of debugging and profiling.
+# The main idea is to narrow down the problem.
+#
+# We demonstrate step by step the way to delve deeper the issue and find the root cause of failures, with the help of debugging logging and the tool Minifier.
+# Firstly determine which component the failure occurs in and then try to generate the smallest snippet of code that can reproduce the failure.
+#
+# When the performance with Inductor is better than that of eager mode, we provide a solid analytical method for performance profiling.
+# We show how to find the time-consuming hotspot with PyTorch Profiler and figure out the operator-level or kernel-level reason to explain the phenomenon.
diff --git a/intermediate_source/jacobians_hessians.py b/intermediate_source/jacobians_hessians.py
new file mode 100644
index 00000000000..b8b96c30a3e
--- /dev/null
+++ b/intermediate_source/jacobians_hessians.py
@@ -0,0 +1,349 @@
+# -*- coding: utf-8 -*-
+"""
+Jacobians, Hessians, hvp, vhp, and more: composing function transforms
+======================================================================
+
+Computing jacobians or hessians are useful in a number of non-traditional
+deep learning models. It is difficult (or annoying) to compute these quantities
+efficiently using PyTorch's regular autodiff APIs
+(``Tensor.backward()``, ``torch.autograd.grad``). PyTorch's 
+`JAX-inspired <https://github.com/google/jax>`_
+`function transforms API <https://pytorch.org/docs/master/func.html>`_
+provides ways of computing various higher-order autodiff quantities
+efficiently.
+
+.. note::
+
+   This tutorial requires PyTorch 2.0.0 or later.
+
+Computing the Jacobian
+----------------------
+"""
+
+import torch
+import torch.nn.functional as F
+from functools import partial
+_ = torch.manual_seed(0)
+
+######################################################################
+# Let's start with a function that we'd like to compute the jacobian of.
+# This is a simple linear function with non-linear activation.
+
+def predict(weight, bias, x):
+    return F.linear(x, weight, bias).tanh()
+
+######################################################################
+# Let's add some dummy data: a weight, a bias, and a feature vector x.
+
+D = 16
+weight = torch.randn(D, D)
+bias = torch.randn(D)
+x = torch.randn(D)  # feature vector
+
+######################################################################
+# Let's think of ``predict`` as a function that maps the input ``x`` from :math:`R^D \to R^D`.
+# PyTorch Autograd computes vector-Jacobian products. In order to compute the full
+# Jacobian of this :math:`R^D \to R^D` function, we would have to compute it row-by-row
+# by using a different unit vector each time.
+
+def compute_jac(xp):
+    jacobian_rows = [torch.autograd.grad(predict(weight, bias, xp), xp, vec)[0]
+                     for vec in unit_vectors]
+    return torch.stack(jacobian_rows)
+
+xp = x.clone().requires_grad_()
+unit_vectors = torch.eye(D)
+
+jacobian = compute_jac(xp)
+
+print(jacobian.shape)
+print(jacobian[0])  # show first row
+
+######################################################################
+# Instead of computing the jacobian row-by-row, we can use PyTorch's
+# ``torch.vmap`` function transform to get rid of the for-loop and vectorize the
+# computation. We can’t directly apply ``vmap`` to ``torch.autograd.grad``;
+# instead, PyTorch provides a ``torch.func.vjp`` transform that composes with
+# ``torch.vmap``:
+
+from torch.func import vmap, vjp
+
+_, vjp_fn = vjp(partial(predict, weight, bias), x)
+
+ft_jacobian, = vmap(vjp_fn)(unit_vectors)
+
+# let's confirm both methods compute the same result
+assert torch.allclose(ft_jacobian, jacobian)
+
+######################################################################
+# In a later tutorial a composition of reverse-mode AD and ``vmap`` will give us
+# per-sample-gradients.
+# In this tutorial, composing reverse-mode AD and ``vmap`` gives us Jacobian
+# computation!
+# Various compositions of ``vmap`` and autodiff transforms can give us different
+# interesting quantities.
+#
+# PyTorch provides ``torch.func.jacrev`` as a convenience function that performs
+# the ``vmap-vjp`` composition to compute jacobians. ``jacrev`` accepts an ``argnums``
+# argument that says which argument we would like to compute Jacobians with
+# respect to.
+
+from torch.func import jacrev
+
+ft_jacobian = jacrev(predict, argnums=2)(weight, bias, x)
+
+# Confirm by running the following:
+assert torch.allclose(ft_jacobian, jacobian)
+
+######################################################################
+# Let's compare the performance of the two ways to compute the jacobian.
+# The function transform version is much faster (and becomes even faster the
+# more outputs there are).
+#
+# In general, we expect that vectorization via ``vmap`` can help eliminate overhead
+# and give better utilization of your hardware.
+#
+# ``vmap`` does this magic by pushing the outer loop down into the function's
+# primitive operations in order to obtain better performance.
+#
+# Let's make a quick function to evaluate performance and deal with
+# microseconds and milliseconds measurements:
+
+def get_perf(first, first_descriptor, second, second_descriptor):
+    """takes torch.benchmark objects and compares delta of second vs first."""
+    faster = second.times[0]
+    slower = first.times[0]
+    gain = (slower-faster)/slower
+    if gain < 0: gain *=-1
+    final_gain = gain*100
+    print(f" Performance delta: {final_gain:.4f} percent improvement with {second_descriptor} ")
+
+######################################################################
+# And then run the performance comparison:
+
+from torch.utils.benchmark import Timer
+
+without_vmap = Timer(stmt="compute_jac(xp)", globals=globals())
+with_vmap = Timer(stmt="jacrev(predict, argnums=2)(weight, bias, x)", globals=globals())
+
+no_vmap_timer = without_vmap.timeit(500)
+with_vmap_timer = with_vmap.timeit(500)
+
+print(no_vmap_timer)
+print(with_vmap_timer)
+
+######################################################################
+# Let's do a relative performance comparison of the above with our ``get_perf`` function:
+
+get_perf(no_vmap_timer, "without vmap",  with_vmap_timer, "vmap")
+
+######################################################################
+# Furthermore, it’s pretty easy to flip the problem around and say we want to
+# compute Jacobians of the parameters to our model (weight, bias) instead of the input
+
+# note the change in input via ``argnums`` parameters of 0,1 to map to weight and bias
+ft_jac_weight, ft_jac_bias = jacrev(predict, argnums=(0, 1))(weight, bias, x)
+
+######################################################################
+# Reverse-mode Jacobian (``jacrev``) vs forward-mode Jacobian (``jacfwd``)
+# ------------------------------------------------------------------------
+#
+# We offer two APIs to compute jacobians: ``jacrev`` and ``jacfwd``:
+#
+# - ``jacrev`` uses reverse-mode AD. As you saw above it is a composition of our
+#   ``vjp`` and ``vmap`` transforms.
+# - ``jacfwd`` uses forward-mode AD. It is implemented as a composition of our
+#   ``jvp`` and ``vmap`` transforms.
+#
+# ``jacfwd`` and ``jacrev`` can be substituted for each other but they have different
+# performance characteristics.
+#
+# As a general rule of thumb, if you’re computing the jacobian of an :math:`R^N \to R^M`
+# function, and there are many more outputs than inputs (for example, :math:`M > N`) then
+# ``jacfwd`` is preferred, otherwise use ``jacrev``. There are exceptions to this rule,
+# but a non-rigorous argument for this follows:
+#
+# In reverse-mode AD, we are computing the jacobian row-by-row, while in
+# forward-mode AD (which computes Jacobian-vector products), we are computing
+# it column-by-column. The Jacobian matrix has M rows and N columns, so if it
+# is taller or wider one way we may prefer the method that deals with fewer
+# rows or columns.
+
+from torch.func import jacrev, jacfwd
+
+######################################################################
+# First, let's benchmark with more inputs than outputs:
+
+Din = 32
+Dout = 2048
+weight = torch.randn(Dout, Din)
+
+bias = torch.randn(Dout)
+x = torch.randn(Din)
+
+# remember the general rule about taller vs wider... here we have a taller matrix:
+print(weight.shape)
+
+using_fwd = Timer(stmt="jacfwd(predict, argnums=2)(weight, bias, x)", globals=globals())
+using_bwd = Timer(stmt="jacrev(predict, argnums=2)(weight, bias, x)", globals=globals())
+
+jacfwd_timing = using_fwd.timeit(500)
+jacrev_timing = using_bwd.timeit(500)
+
+print(f'jacfwd time: {jacfwd_timing}')
+print(f'jacrev time: {jacrev_timing}')
+
+######################################################################
+# and then do a relative benchmark:
+
+get_perf(jacfwd_timing, "jacfwd", jacrev_timing, "jacrev", );
+
+#######################################################################
+# and now the reverse - more outputs (M) than inputs (N):
+
+Din = 2048
+Dout = 32
+weight = torch.randn(Dout, Din)
+bias = torch.randn(Dout)
+x = torch.randn(Din)
+
+using_fwd = Timer(stmt="jacfwd(predict, argnums=2)(weight, bias, x)", globals=globals())
+using_bwd = Timer(stmt="jacrev(predict, argnums=2)(weight, bias, x)", globals=globals())
+
+jacfwd_timing = using_fwd.timeit(500)
+jacrev_timing = using_bwd.timeit(500)
+
+print(f'jacfwd time: {jacfwd_timing}')
+print(f'jacrev time: {jacrev_timing}')
+
+#######################################################################
+# and a relative performance comparison:
+
+get_perf(jacrev_timing, "jacrev", jacfwd_timing, "jacfwd")
+
+#######################################################################
+# Hessian computation with functorch.hessian
+# ------------------------------------------
+# We offer a convenience API to compute hessians: ``torch.func.hessiani``.
+# Hessians are the jacobian of the jacobian (or the partial derivative of
+# the partial derivative, aka second order).
+#
+# This suggests that one can just compose functorch jacobian transforms to
+# compute the Hessian.
+# Indeed, under the hood, ``hessian(f)`` is simply ``jacfwd(jacrev(f))``.
+#
+# Note: to boost performance: depending on your model, you may also want to
+# use ``jacfwd(jacfwd(f))`` or ``jacrev(jacrev(f))`` instead to compute hessians
+# leveraging the rule of thumb above regarding wider vs taller matrices.
+
+from torch.func import hessian
+
+# lets reduce the size in order not to overwhelm Colab. Hessians require
+# significant memory:
+Din = 512
+Dout = 32
+weight = torch.randn(Dout, Din)
+bias = torch.randn(Dout)
+x = torch.randn(Din)
+
+hess_api = hessian(predict, argnums=2)(weight, bias, x)
+hess_fwdfwd = jacfwd(jacfwd(predict, argnums=2), argnums=2)(weight, bias, x)
+hess_revrev = jacrev(jacrev(predict, argnums=2), argnums=2)(weight, bias, x)
+
+#######################################################################
+# Let's verify we have the same result regardless of using hessian API or
+# using ``jacfwd(jacfwd())``.
+
+torch.allclose(hess_api, hess_fwdfwd)
+
+#######################################################################
+# Batch Jacobian and Batch Hessian
+# --------------------------------
+# In the above examples we’ve been operating with a single feature vector.
+# In some cases you might want to take the Jacobian of a batch of outputs
+# with respect to a batch of inputs. That is, given a batch of inputs of
+# shape ``(B, N)`` and a function that goes from :math:`R^N \to R^M`, we would like
+# a Jacobian of shape ``(B, M, N)``.
+#
+# The easiest way to do this is to use ``vmap``:
+
+batch_size = 64
+Din = 31
+Dout = 33
+
+weight = torch.randn(Dout, Din)
+print(f"weight shape = {weight.shape}")
+
+bias = torch.randn(Dout)
+
+x = torch.randn(batch_size, Din)
+
+compute_batch_jacobian = vmap(jacrev(predict, argnums=2), in_dims=(None, None, 0))
+batch_jacobian0 = compute_batch_jacobian(weight, bias, x)
+
+#######################################################################
+# If you have a function that goes from (B, N) -> (B, M) instead and are
+# certain that each input produces an independent output, then it's also
+# sometimes possible to do this without using ``vmap`` by summing the outputs
+# and then computing the Jacobian of that function:
+
+def predict_with_output_summed(weight, bias, x):
+    return predict(weight, bias, x).sum(0)
+
+batch_jacobian1 = jacrev(predict_with_output_summed, argnums=2)(weight, bias, x).movedim(1, 0)
+assert torch.allclose(batch_jacobian0, batch_jacobian1)
+
+#######################################################################
+# If you instead have a function that goes from :math:`R^N \to R^M` but inputs that
+# are batched, you compose ``vmap`` with ``jacrev`` to compute batched jacobians:
+#
+# Finally, batch hessians can be computed similarly. It's easiest to think
+# about them by using ``vmap`` to batch over hessian computation, but in some
+# cases the sum trick also works.
+
+compute_batch_hessian = vmap(hessian(predict, argnums=2), in_dims=(None, None, 0))
+
+batch_hess = compute_batch_hessian(weight, bias, x)
+batch_hess.shape
+
+#######################################################################
+# Computing Hessian-vector products
+# ---------------------------------
+# The naive way to compute a Hessian-vector product (hvp) is to materialize
+# the full Hessian and perform a dot-product with a vector. We can do better:
+# it turns out we don't need to materialize the full Hessian to do this. We'll
+# go through two (of many) different strategies to compute Hessian-vector products:
+# - composing reverse-mode AD with reverse-mode AD
+# - composing reverse-mode AD with forward-mode AD
+#
+# Composing reverse-mode AD with forward-mode AD (as opposed to reverse-mode
+# with reverse-mode) is generally the more memory efficient way to compute a
+# hvp because forward-mode AD doesn't need to construct an Autograd graph and
+# save intermediates for backward:
+
+from torch.func import jvp, grad, vjp
+
+def hvp(f, primals, tangents):
+  return jvp(grad(f), primals, tangents)[1]
+
+#######################################################################
+# Here's some sample usage.
+
+def f(x):
+  return x.sin().sum()
+
+x = torch.randn(2048)
+tangent = torch.randn(2048)
+
+result = hvp(f, (x,), (tangent,))
+
+#######################################################################
+# If PyTorch forward-AD does not have coverage for your operations, then we can
+# instead compose reverse-mode AD with reverse-mode AD:
+
+def hvp_revrev(f, primals, tangents):
+  _, vjp_fn = vjp(grad(f), *primals)
+  return vjp_fn(*tangents)
+
+result_hvp_revrev = hvp_revrev(f, (x,), (tangent,))
+assert torch.allclose(result, result_hvp_revrev[0])
diff --git a/intermediate_source/mario_rl_tutorial.py b/intermediate_source/mario_rl_tutorial.py
new file mode 100755
index 00000000000..03d6396a47e
--- /dev/null
+++ b/intermediate_source/mario_rl_tutorial.py
@@ -0,0 +1,791 @@
+# -*- coding: utf-8 -*-
+"""
+Train a Mario-playing RL Agent
+===============================
+
+**Authors:** `Yuansong Feng <https://github.com/YuansongFeng>`__, `Suraj Subramanian <https://github.com/suraj813>`__, `Howard Wang <https://github.com/hw26>`__, `Steven Guo <https://github.com/GuoYuzhang>`__.
+
+
+This tutorial walks you through the fundamentals of Deep Reinforcement
+Learning. At the end, you will implement an AI-powered Mario (using
+`Double Deep Q-Networks <https://arxiv.org/pdf/1509.06461.pdf>`__) that
+can play the game by itself.
+
+Although no prior knowledge of RL is necessary for this tutorial, you
+can familiarize yourself with these RL
+`concepts <https://spinningup.openai.com/en/latest/spinningup/rl_intro.html>`__,
+and have this handy
+`cheatsheet <https://colab.research.google.com/drive/1eN33dPVtdPViiS1njTW_-r-IYCDTFU7N>`__
+as your companion. The full code is available
+`here <https://github.com/yuansongFeng/MadMario/>`__.
+
+.. figure:: /_static/img/mario.gif
+   :alt: mario
+
+"""
+
+
+######################################################################
+#
+#
+#  .. code-block:: bash
+#
+#      %%bash
+#      pip install gym-super-mario-bros==7.4.0
+#      pip install tensordict==0.3.0
+#      pip install torchrl==0.3.0
+#
+
+import torch
+from torch import nn
+from torchvision import transforms as T
+from PIL import Image
+import numpy as np
+from pathlib import Path
+from collections import deque
+import random, datetime, os
+
+# Gym is an OpenAI toolkit for RL
+import gym
+from gym.spaces import Box
+from gym.wrappers import FrameStack
+
+# NES Emulator for OpenAI Gym
+from nes_py.wrappers import JoypadSpace
+
+# Super Mario environment for OpenAI Gym
+import gym_super_mario_bros
+
+from tensordict import TensorDict
+from torchrl.data import TensorDictReplayBuffer, LazyMemmapStorage
+
+######################################################################
+# RL Definitions
+# """"""""""""""""""
+#
+# **Environment** The world that an agent interacts with and learns from.
+#
+# **Action** :math:`a` : How the Agent responds to the Environment. The
+# set of all possible Actions is called *action-space*.
+#
+# **State** :math:`s` : The current characteristic of the Environment. The
+# set of all possible States the Environment can be in is called
+# *state-space*.
+#
+# **Reward** :math:`r` : Reward is the key feedback from Environment to
+# Agent. It is what drives the Agent to learn and to change its future
+# action. An aggregation of rewards over multiple time steps is called
+# **Return**.
+#
+# **Optimal Action-Value function** :math:`Q^*(s,a)` : Gives the expected
+# return if you start in state :math:`s`, take an arbitrary action
+# :math:`a`, and then for each future time step take the action that
+# maximizes returns. :math:`Q` can be said to stand for the “quality” of
+# the action in a state. We try to approximate this function.
+#
+
+
+######################################################################
+# Environment
+# """"""""""""""""
+#
+# Initialize Environment
+# ------------------------
+#
+# In Mario, the environment consists of tubes, mushrooms and other
+# components.
+#
+# When Mario makes an action, the environment responds with the changed
+# (next) state, reward and other info.
+#
+
+# Initialize Super Mario environment (in v0.26 change render mode to 'human' to see results on the screen)
+if gym.__version__ < '0.26':
+    env = gym_super_mario_bros.make("SuperMarioBros-1-1-v0", new_step_api=True)
+else:
+    env = gym_super_mario_bros.make("SuperMarioBros-1-1-v0", render_mode='rgb', apply_api_compatibility=True)
+
+# Limit the action-space to
+#   0. walk right
+#   1. jump right
+env = JoypadSpace(env, [["right"], ["right", "A"]])
+
+env.reset()
+next_state, reward, done, trunc, info = env.step(action=0)
+print(f"{next_state.shape},\n {reward},\n {done},\n {info}")
+
+
+######################################################################
+# Preprocess Environment
+# ------------------------
+#
+# Environment data is returned to the agent in ``next_state``. As you saw
+# above, each state is represented by a ``[3, 240, 256]`` size array.
+# Often that is more information than our agent needs; for instance,
+# Mario’s actions do not depend on the color of the pipes or the sky!
+#
+# We use **Wrappers** to preprocess environment data before sending it to
+# the agent.
+#
+# ``GrayScaleObservation`` is a common wrapper to transform an RGB image
+# to grayscale; doing so reduces the size of the state representation
+# without losing useful information. Now the size of each state:
+# ``[1, 240, 256]``
+#
+# ``ResizeObservation`` downsamples each observation into a square image.
+# New size: ``[1, 84, 84]``
+#
+# ``SkipFrame`` is a custom wrapper that inherits from ``gym.Wrapper`` and
+# implements the ``step()`` function. Because consecutive frames don’t
+# vary much, we can skip n-intermediate frames without losing much
+# information. The n-th frame aggregates rewards accumulated over each
+# skipped frame.
+#
+# ``FrameStack`` is a wrapper that allows us to squash consecutive frames
+# of the environment into a single observation point to feed to our
+# learning model. This way, we can identify if Mario was landing or
+# jumping based on the direction of his movement in the previous several
+# frames.
+#
+
+
+class SkipFrame(gym.Wrapper):
+    def __init__(self, env, skip):
+        """Return only every `skip`-th frame"""
+        super().__init__(env)
+        self._skip = skip
+
+    def step(self, action):
+        """Repeat action, and sum reward"""
+        total_reward = 0.0
+        for i in range(self._skip):
+            # Accumulate reward and repeat the same action
+            obs, reward, done, trunk, info = self.env.step(action)
+            total_reward += reward
+            if done:
+                break
+        return obs, total_reward, done, trunk, info
+
+
+class GrayScaleObservation(gym.ObservationWrapper):
+    def __init__(self, env):
+        super().__init__(env)
+        obs_shape = self.observation_space.shape[:2]
+        self.observation_space = Box(low=0, high=255, shape=obs_shape, dtype=np.uint8)
+
+    def permute_orientation(self, observation):
+        # permute [H, W, C] array to [C, H, W] tensor
+        observation = np.transpose(observation, (2, 0, 1))
+        observation = torch.tensor(observation.copy(), dtype=torch.float)
+        return observation
+
+    def observation(self, observation):
+        observation = self.permute_orientation(observation)
+        transform = T.Grayscale()
+        observation = transform(observation)
+        return observation
+
+
+class ResizeObservation(gym.ObservationWrapper):
+    def __init__(self, env, shape):
+        super().__init__(env)
+        if isinstance(shape, int):
+            self.shape = (shape, shape)
+        else:
+            self.shape = tuple(shape)
+
+        obs_shape = self.shape + self.observation_space.shape[2:]
+        self.observation_space = Box(low=0, high=255, shape=obs_shape, dtype=np.uint8)
+
+    def observation(self, observation):
+        transforms = T.Compose(
+            [T.Resize(self.shape, antialias=True), T.Normalize(0, 255)]
+        )
+        observation = transforms(observation).squeeze(0)
+        return observation
+
+
+# Apply Wrappers to environment
+env = SkipFrame(env, skip=4)
+env = GrayScaleObservation(env)
+env = ResizeObservation(env, shape=84)
+if gym.__version__ < '0.26':
+    env = FrameStack(env, num_stack=4, new_step_api=True)
+else:
+    env = FrameStack(env, num_stack=4)
+
+
+######################################################################
+# After applying the above wrappers to the environment, the final wrapped
+# state consists of 4 gray-scaled consecutive frames stacked together, as
+# shown above in the image on the left. Each time Mario makes an action,
+# the environment responds with a state of this structure. The structure
+# is represented by a 3-D array of size ``[4, 84, 84]``.
+#
+# .. figure:: /_static/img/mario_env.png
+#    :alt: picture
+#
+#
+
+
+######################################################################
+# Agent
+# """""""""
+#
+# We create a class ``Mario`` to represent our agent in the game. Mario
+# should be able to:
+#
+# -  **Act** according to the optimal action policy based on the current
+#    state (of the environment).
+#
+# -  **Remember** experiences. Experience = (current state, current
+#    action, reward, next state). Mario *caches* and later *recalls* his
+#    experiences to update his action policy.
+#
+# -  **Learn** a better action policy over time
+#
+
+
+class Mario:
+    def __init__():
+        pass
+
+    def act(self, state):
+        """Given a state, choose an epsilon-greedy action"""
+        pass
+
+    def cache(self, experience):
+        """Add the experience to memory"""
+        pass
+
+    def recall(self):
+        """Sample experiences from memory"""
+        pass
+
+    def learn(self):
+        """Update online action value (Q) function with a batch of experiences"""
+        pass
+
+
+######################################################################
+# In the following sections, we will populate Mario’s parameters and
+# define his functions.
+#
+
+
+######################################################################
+# Act
+# --------------
+#
+# For any given state, an agent can choose to do the most optimal action
+# (**exploit**) or a random action (**explore**).
+#
+# Mario randomly explores with a chance of ``self.exploration_rate``; when
+# he chooses to exploit, he relies on ``MarioNet`` (implemented in
+# ``Learn`` section) to provide the most optimal action.
+#
+
+
+class Mario:
+    def __init__(self, state_dim, action_dim, save_dir):
+        self.state_dim = state_dim
+        self.action_dim = action_dim
+        self.save_dir = save_dir
+
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+
+        # Mario's DNN to predict the most optimal action - we implement this in the Learn section
+        self.net = MarioNet(self.state_dim, self.action_dim).float()
+        self.net = self.net.to(device=self.device)
+
+        self.exploration_rate = 1
+        self.exploration_rate_decay = 0.99999975
+        self.exploration_rate_min = 0.1
+        self.curr_step = 0
+
+        self.save_every = 5e5  # no. of experiences between saving Mario Net
+
+    def act(self, state):
+        """
+    Given a state, choose an epsilon-greedy action and update value of step.
+
+    Inputs:
+    state(``LazyFrame``): A single observation of the current state, dimension is (state_dim)
+    Outputs:
+    ``action_idx`` (``int``): An integer representing which action Mario will perform
+    """
+        # EXPLORE
+        if np.random.rand() < self.exploration_rate:
+            action_idx = np.random.randint(self.action_dim)
+
+        # EXPLOIT
+        else:
+            state = state[0].__array__() if isinstance(state, tuple) else state.__array__()
+            state = torch.tensor(state, device=self.device).unsqueeze(0)
+            action_values = self.net(state, model="online")
+            action_idx = torch.argmax(action_values, axis=1).item()
+
+        # decrease exploration_rate
+        self.exploration_rate *= self.exploration_rate_decay
+        self.exploration_rate = max(self.exploration_rate_min, self.exploration_rate)
+
+        # increment step
+        self.curr_step += 1
+        return action_idx
+
+
+######################################################################
+# Cache and Recall
+# ----------------------
+#
+# These two functions serve as Mario’s “memory” process.
+#
+# ``cache()``: Each time Mario performs an action, he stores the
+# ``experience`` to his memory. His experience includes the current
+# *state*, *action* performed, *reward* from the action, the *next state*,
+# and whether the game is *done*.
+#
+# ``recall()``: Mario randomly samples a batch of experiences from his
+# memory, and uses that to learn the game.
+#
+
+
+class Mario(Mario):  # subclassing for continuity
+    def __init__(self, state_dim, action_dim, save_dir):
+        super().__init__(state_dim, action_dim, save_dir)
+        self.memory = TensorDictReplayBuffer(storage=LazyMemmapStorage(100000, device=torch.device("cpu")))
+        self.batch_size = 32
+
+    def cache(self, state, next_state, action, reward, done):
+        """
+        Store the experience to self.memory (replay buffer)
+
+        Inputs:
+        state (``LazyFrame``),
+        next_state (``LazyFrame``),
+        action (``int``),
+        reward (``float``),
+        done(``bool``))
+        """
+        def first_if_tuple(x):
+            return x[0] if isinstance(x, tuple) else x
+        state = first_if_tuple(state).__array__()
+        next_state = first_if_tuple(next_state).__array__()
+
+        state = torch.tensor(state)
+        next_state = torch.tensor(next_state)
+        action = torch.tensor([action])
+        reward = torch.tensor([reward])
+        done = torch.tensor([done])
+
+        # self.memory.append((state, next_state, action, reward, done,))
+        self.memory.add(TensorDict({"state": state, "next_state": next_state, "action": action, "reward": reward, "done": done}, batch_size=[]))
+
+    def recall(self):
+        """
+        Retrieve a batch of experiences from memory
+        """
+        batch = self.memory.sample(self.batch_size).to(self.device)
+        state, next_state, action, reward, done = (batch.get(key) for key in ("state", "next_state", "action", "reward", "done"))
+        return state, next_state, action.squeeze(), reward.squeeze(), done.squeeze()
+
+
+######################################################################
+# Learn
+# --------------
+#
+# Mario uses the `DDQN algorithm <https://arxiv.org/pdf/1509.06461>`__
+# under the hood. DDQN uses two ConvNets - :math:`Q_{online}` and
+# :math:`Q_{target}` - that independently approximate the optimal
+# action-value function.
+#
+# In our implementation, we share feature generator ``features`` across
+# :math:`Q_{online}` and :math:`Q_{target}`, but maintain separate FC
+# classifiers for each. :math:`\theta_{target}` (the parameters of
+# :math:`Q_{target}`) is frozen to prevent updating by backprop. Instead,
+# it is periodically synced with :math:`\theta_{online}` (more on this
+# later).
+#
+# Neural Network
+# ~~~~~~~~~~~~~~~~~~
+
+
+class MarioNet(nn.Module):
+    """mini CNN structure
+  input -> (conv2d + relu) x 3 -> flatten -> (dense + relu) x 2 -> output
+  """
+
+    def __init__(self, input_dim, output_dim):
+        super().__init__()
+        c, h, w = input_dim
+
+        if h != 84:
+            raise ValueError(f"Expecting input height: 84, got: {h}")
+        if w != 84:
+            raise ValueError(f"Expecting input width: 84, got: {w}")
+
+        self.online = self.__build_cnn(c, output_dim)
+
+        self.target = self.__build_cnn(c, output_dim)
+        self.target.load_state_dict(self.online.state_dict())
+
+        # Q_target parameters are frozen.
+        for p in self.target.parameters():
+            p.requires_grad = False
+
+    def forward(self, input, model):
+        if model == "online":
+            return self.online(input)
+        elif model == "target":
+            return self.target(input)
+
+    def __build_cnn(self, c, output_dim):
+        return nn.Sequential(
+            nn.Conv2d(in_channels=c, out_channels=32, kernel_size=8, stride=4),
+            nn.ReLU(),
+            nn.Conv2d(in_channels=32, out_channels=64, kernel_size=4, stride=2),
+            nn.ReLU(),
+            nn.Conv2d(in_channels=64, out_channels=64, kernel_size=3, stride=1),
+            nn.ReLU(),
+            nn.Flatten(),
+            nn.Linear(3136, 512),
+            nn.ReLU(),
+            nn.Linear(512, output_dim),
+        )
+
+
+######################################################################
+# TD Estimate & TD Target
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# Two values are involved in learning:
+#
+# **TD Estimate** - the predicted optimal :math:`Q^*` for a given state
+# :math:`s`
+#
+# .. math::
+#
+#
+#    {TD}_e = Q_{online}^*(s,a)
+#
+# **TD Target** - aggregation of current reward and the estimated
+# :math:`Q^*` in the next state :math:`s'`
+#
+# .. math::
+#
+#
+#    a' = argmax_{a} Q_{online}(s', a)
+#
+# .. math::
+#
+#
+#    {TD}_t = r + \gamma Q_{target}^*(s',a')
+#
+# Because we don’t know what next action :math:`a'` will be, we use the
+# action :math:`a'` maximizes :math:`Q_{online}` in the next state
+# :math:`s'`.
+#
+# Notice we use the
+# `@torch.no_grad() <https://pytorch.org/docs/stable/generated/torch.no_grad.html#no-grad>`__
+# decorator on ``td_target()`` to disable gradient calculations here
+# (because we don’t need to backpropagate on :math:`\theta_{target}`).
+#
+
+
+class Mario(Mario):
+    def __init__(self, state_dim, action_dim, save_dir):
+        super().__init__(state_dim, action_dim, save_dir)
+        self.gamma = 0.9
+
+    def td_estimate(self, state, action):
+        current_Q = self.net(state, model="online")[
+            np.arange(0, self.batch_size), action
+        ]  # Q_online(s,a)
+        return current_Q
+
+    @torch.no_grad()
+    def td_target(self, reward, next_state, done):
+        next_state_Q = self.net(next_state, model="online")
+        best_action = torch.argmax(next_state_Q, axis=1)
+        next_Q = self.net(next_state, model="target")[
+            np.arange(0, self.batch_size), best_action
+        ]
+        return (reward + (1 - done.float()) * self.gamma * next_Q).float()
+
+
+######################################################################
+# Updating the model
+# ~~~~~~~~~~~~~~~~~~~~~~
+#
+# As Mario samples inputs from his replay buffer, we compute :math:`TD_t`
+# and :math:`TD_e` and backpropagate this loss down :math:`Q_{online}` to
+# update its parameters :math:`\theta_{online}` (:math:`\alpha` is the
+# learning rate ``lr`` passed to the ``optimizer``)
+#
+# .. math::
+#
+#
+#    \theta_{online} \leftarrow \theta_{online} + \alpha \nabla(TD_e - TD_t)
+#
+# :math:`\theta_{target}` does not update through backpropagation.
+# Instead, we periodically copy :math:`\theta_{online}` to
+# :math:`\theta_{target}`
+#
+# .. math::
+#
+#
+#    \theta_{target} \leftarrow \theta_{online}
+#
+#
+
+
+class Mario(Mario):
+    def __init__(self, state_dim, action_dim, save_dir):
+        super().__init__(state_dim, action_dim, save_dir)
+        self.optimizer = torch.optim.Adam(self.net.parameters(), lr=0.00025)
+        self.loss_fn = torch.nn.SmoothL1Loss()
+
+    def update_Q_online(self, td_estimate, td_target):
+        loss = self.loss_fn(td_estimate, td_target)
+        self.optimizer.zero_grad()
+        loss.backward()
+        self.optimizer.step()
+        return loss.item()
+
+    def sync_Q_target(self):
+        self.net.target.load_state_dict(self.net.online.state_dict())
+
+
+######################################################################
+# Save checkpoint
+# ~~~~~~~~~~~~~~~~~~
+#
+
+
+class Mario(Mario):
+    def save(self):
+        save_path = (
+            self.save_dir / f"mario_net_{int(self.curr_step // self.save_every)}.chkpt"
+        )
+        torch.save(
+            dict(model=self.net.state_dict(), exploration_rate=self.exploration_rate),
+            save_path,
+        )
+        print(f"MarioNet saved to {save_path} at step {self.curr_step}")
+
+
+######################################################################
+# Putting it all together
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+
+
+class Mario(Mario):
+    def __init__(self, state_dim, action_dim, save_dir):
+        super().__init__(state_dim, action_dim, save_dir)
+        self.burnin = 1e4  # min. experiences before training
+        self.learn_every = 3  # no. of experiences between updates to Q_online
+        self.sync_every = 1e4  # no. of experiences between Q_target & Q_online sync
+
+    def learn(self):
+        if self.curr_step % self.sync_every == 0:
+            self.sync_Q_target()
+
+        if self.curr_step % self.save_every == 0:
+            self.save()
+
+        if self.curr_step < self.burnin:
+            return None, None
+
+        if self.curr_step % self.learn_every != 0:
+            return None, None
+
+        # Sample from memory
+        state, next_state, action, reward, done = self.recall()
+
+        # Get TD Estimate
+        td_est = self.td_estimate(state, action)
+
+        # Get TD Target
+        td_tgt = self.td_target(reward, next_state, done)
+
+        # Backpropagate loss through Q_online
+        loss = self.update_Q_online(td_est, td_tgt)
+
+        return (td_est.mean().item(), loss)
+
+
+######################################################################
+# Logging
+# --------------
+#
+
+import numpy as np
+import time, datetime
+import matplotlib.pyplot as plt
+
+
+class MetricLogger:
+    def __init__(self, save_dir):
+        self.save_log = save_dir / "log"
+        with open(self.save_log, "w") as f:
+            f.write(
+                f"{'Episode':>8}{'Step':>8}{'Epsilon':>10}{'MeanReward':>15}"
+                f"{'MeanLength':>15}{'MeanLoss':>15}{'MeanQValue':>15}"
+                f"{'TimeDelta':>15}{'Time':>20}\n"
+            )
+        self.ep_rewards_plot = save_dir / "reward_plot.jpg"
+        self.ep_lengths_plot = save_dir / "length_plot.jpg"
+        self.ep_avg_losses_plot = save_dir / "loss_plot.jpg"
+        self.ep_avg_qs_plot = save_dir / "q_plot.jpg"
+
+        # History metrics
+        self.ep_rewards = []
+        self.ep_lengths = []
+        self.ep_avg_losses = []
+        self.ep_avg_qs = []
+
+        # Moving averages, added for every call to record()
+        self.moving_avg_ep_rewards = []
+        self.moving_avg_ep_lengths = []
+        self.moving_avg_ep_avg_losses = []
+        self.moving_avg_ep_avg_qs = []
+
+        # Current episode metric
+        self.init_episode()
+
+        # Timing
+        self.record_time = time.time()
+
+    def log_step(self, reward, loss, q):
+        self.curr_ep_reward += reward
+        self.curr_ep_length += 1
+        if loss:
+            self.curr_ep_loss += loss
+            self.curr_ep_q += q
+            self.curr_ep_loss_length += 1
+
+    def log_episode(self):
+        "Mark end of episode"
+        self.ep_rewards.append(self.curr_ep_reward)
+        self.ep_lengths.append(self.curr_ep_length)
+        if self.curr_ep_loss_length == 0:
+            ep_avg_loss = 0
+            ep_avg_q = 0
+        else:
+            ep_avg_loss = np.round(self.curr_ep_loss / self.curr_ep_loss_length, 5)
+            ep_avg_q = np.round(self.curr_ep_q / self.curr_ep_loss_length, 5)
+        self.ep_avg_losses.append(ep_avg_loss)
+        self.ep_avg_qs.append(ep_avg_q)
+
+        self.init_episode()
+
+    def init_episode(self):
+        self.curr_ep_reward = 0.0
+        self.curr_ep_length = 0
+        self.curr_ep_loss = 0.0
+        self.curr_ep_q = 0.0
+        self.curr_ep_loss_length = 0
+
+    def record(self, episode, epsilon, step):
+        mean_ep_reward = np.round(np.mean(self.ep_rewards[-100:]), 3)
+        mean_ep_length = np.round(np.mean(self.ep_lengths[-100:]), 3)
+        mean_ep_loss = np.round(np.mean(self.ep_avg_losses[-100:]), 3)
+        mean_ep_q = np.round(np.mean(self.ep_avg_qs[-100:]), 3)
+        self.moving_avg_ep_rewards.append(mean_ep_reward)
+        self.moving_avg_ep_lengths.append(mean_ep_length)
+        self.moving_avg_ep_avg_losses.append(mean_ep_loss)
+        self.moving_avg_ep_avg_qs.append(mean_ep_q)
+
+        last_record_time = self.record_time
+        self.record_time = time.time()
+        time_since_last_record = np.round(self.record_time - last_record_time, 3)
+
+        print(
+            f"Episode {episode} - "
+            f"Step {step} - "
+            f"Epsilon {epsilon} - "
+            f"Mean Reward {mean_ep_reward} - "
+            f"Mean Length {mean_ep_length} - "
+            f"Mean Loss {mean_ep_loss} - "
+            f"Mean Q Value {mean_ep_q} - "
+            f"Time Delta {time_since_last_record} - "
+            f"Time {datetime.datetime.now().strftime('%Y-%m-%dT%H:%M:%S')}"
+        )
+
+        with open(self.save_log, "a") as f:
+            f.write(
+                f"{episode:8d}{step:8d}{epsilon:10.3f}"
+                f"{mean_ep_reward:15.3f}{mean_ep_length:15.3f}{mean_ep_loss:15.3f}{mean_ep_q:15.3f}"
+                f"{time_since_last_record:15.3f}"
+                f"{datetime.datetime.now().strftime('%Y-%m-%dT%H:%M:%S'):>20}\n"
+            )
+
+        for metric in ["ep_lengths", "ep_avg_losses", "ep_avg_qs", "ep_rewards"]:
+            plt.clf()
+            plt.plot(getattr(self, f"moving_avg_{metric}"), label=f"moving_avg_{metric}")
+            plt.legend()
+            plt.savefig(getattr(self, f"{metric}_plot"))
+
+
+######################################################################
+# Let’s play!
+# """""""""""""""
+#
+# In this example we run the training loop for 40 episodes, but for Mario to truly learn the ways of
+# his world, we suggest running the loop for at least 40,000 episodes!
+#
+use_cuda = torch.cuda.is_available()
+print(f"Using CUDA: {use_cuda}")
+print()
+
+save_dir = Path("checkpoints") / datetime.datetime.now().strftime("%Y-%m-%dT%H-%M-%S")
+save_dir.mkdir(parents=True)
+
+mario = Mario(state_dim=(4, 84, 84), action_dim=env.action_space.n, save_dir=save_dir)
+
+logger = MetricLogger(save_dir)
+
+episodes = 40
+for e in range(episodes):
+
+    state = env.reset()
+
+    # Play the game!
+    while True:
+
+        # Run agent on the state
+        action = mario.act(state)
+
+        # Agent performs action
+        next_state, reward, done, trunc, info = env.step(action)
+
+        # Remember
+        mario.cache(state, next_state, action, reward, done)
+
+        # Learn
+        q, loss = mario.learn()
+
+        # Logging
+        logger.log_step(reward, loss, q)
+
+        # Update state
+        state = next_state
+
+        # Check if end of game
+        if done or info["flag_get"]:
+            break
+
+    logger.log_episode()
+
+    if (e % 20 == 0) or (e == episodes - 1):
+        logger.record(episode=e, epsilon=mario.exploration_rate, step=mario.curr_step)
+
+
+######################################################################
+# Conclusion
+# """""""""""""""
+#
+# In this tutorial, we saw how we can use PyTorch to train a game-playing AI. You can use the same methods
+# to train an AI to play any of the games at the `OpenAI gym <https://gym.openai.com/>`__. Hope you enjoyed this tutorial, feel free to reach us at
+# `our github <https://github.com/yuansongFeng/MadMario/>`__!
diff --git a/intermediate_source/memory_format_tutorial.py b/intermediate_source/memory_format_tutorial.py
new file mode 100644
index 00000000000..b3e3c04cfe2
--- /dev/null
+++ b/intermediate_source/memory_format_tutorial.py
@@ -0,0 +1,413 @@
+# -*- coding: utf-8 -*-
+"""
+Channels Last Memory Format in PyTorch
+*******************************************************
+**Author**: `Vitaly Fedyunin <https://github.com/VitalyFedyunin>`_
+
+.. grid:: 2
+
+    .. grid-item-card:: :octicon:`mortar-board;1em;` What you will learn
+       :class-card: card-prerequisites
+
+       * What is the channels last memory format in PyTorch?
+       * How can it be used to improve performance on certain operators?
+
+    .. grid-item-card:: :octicon:`list-unordered;1em;` Prerequisites
+       :class-card: card-prerequisites
+
+       * PyTorch v1.5.0
+       * A CUDA-capable GPU
+
+#########################################################################
+# Overview - What is channels last?
+# ---------------------------------
+
+The channels last memory format is an alternative way of ordering NCHW tensors in memory preserving dimensions ordering. Channels last tensors ordered in such a way that channels become the densest dimension (aka storing images pixel-per-pixel).
+
+For example, classic (contiguous) storage of NCHW tensor (in our case it is two 4x4 images with 3 color channels) look like this:
+
+.. figure:: /_static/img/classic_memory_format.png
+   :alt: classic_memory_format
+
+Channels last memory format orders data differently:
+
+.. figure:: /_static/img/channels_last_memory_format.png
+   :alt: channels_last_memory_format
+
+Pytorch supports memory formats by utilizing the existing strides structure.
+For example, 10x3x16x16 batch in Channels last format will have strides equal to (768, 1, 48, 3).
+"""
+
+######################################################################
+# Channels last memory format is implemented for 4D NCHW Tensors only.
+#
+
+######################################################################
+# Memory Format API
+# -----------------------
+#
+# Here is how to convert tensors between contiguous and channels
+# last memory formats.
+
+######################################################################
+# Classic PyTorch contiguous tensor
+import torch
+
+N, C, H, W = 10, 3, 32, 32
+x = torch.empty(N, C, H, W)
+print(x.stride())  # Outputs: (3072, 1024, 32, 1)
+
+######################################################################
+# Conversion operator
+x = x.to(memory_format=torch.channels_last)
+print(x.shape)  # Outputs: (10, 3, 32, 32) as dimensions order preserved
+print(x.stride())  # Outputs: (3072, 1, 96, 3)
+
+######################################################################
+# Back to contiguous
+x = x.to(memory_format=torch.contiguous_format)
+print(x.stride())  # Outputs: (3072, 1024, 32, 1)
+
+######################################################################
+# Alternative option
+x = x.contiguous(memory_format=torch.channels_last)
+print(x.stride())  # Outputs: (3072, 1, 96, 3)
+
+######################################################################
+# Format checks
+print(x.is_contiguous(memory_format=torch.channels_last))  # Outputs: True
+
+######################################################################
+# There are minor difference between the two APIs ``to`` and
+# ``contiguous``. We suggest to stick with ``to`` when explicitly
+# converting memory format of tensor.
+#
+# For general cases the two APIs behave the same. However in special
+# cases for a 4D tensor with size ``NCHW`` when either: ``C==1`` or
+# ``H==1 && W==1``, only ``to`` would generate a proper stride to
+# represent channels last memory format.
+#
+# This is because in either of the two cases above, the memory format
+# of a tensor is ambiguous, i.e. a contiguous tensor with size
+# ``N1HW`` is both ``contiguous`` and channels last in memory storage.
+# Therefore, they are already considered as ``is_contiguous``
+# for the given memory format and hence ``contiguous`` call becomes a
+# no-op and would not update the stride. On the contrary, ``to``
+# would restride tensor with a meaningful stride on dimensions whose
+# sizes are 1 in order to properly represent the intended memory
+# format
+special_x = torch.empty(4, 1, 4, 4)
+print(special_x.is_contiguous(memory_format=torch.channels_last))  # Outputs: True
+print(special_x.is_contiguous(memory_format=torch.contiguous_format))  # Outputs: True
+
+######################################################################
+# Same thing applies to explicit permutation API ``permute``. In
+# special case where ambiguity could occur, ``permute`` does not
+# guarantee to produce a stride that properly carry the intended
+# memory format. We suggest to use ``to`` with explicit memory format
+# to avoid unintended behavior.
+#
+# And a side note that in the extreme case, where three non-batch
+# dimensions are all equal to ``1`` (``C==1 && H==1 && W==1``),
+# current implementation cannot mark a tensor as channels last memory
+# format.
+
+######################################################################
+# Create as channels last
+x = torch.empty(N, C, H, W, memory_format=torch.channels_last)
+print(x.stride())  # Outputs: (3072, 1, 96, 3)
+
+######################################################################
+# ``clone`` preserves memory format
+y = x.clone()
+print(y.stride())  # Outputs: (3072, 1, 96, 3)
+
+######################################################################
+# ``to``, ``cuda``, ``float`` ... preserves memory format
+if torch.cuda.is_available():
+    y = x.cuda()
+    print(y.stride())  # Outputs: (3072, 1, 96, 3)
+
+######################################################################
+# ``empty_like``, ``*_like`` operators preserves memory format
+y = torch.empty_like(x)
+print(y.stride())  # Outputs: (3072, 1, 96, 3)
+
+######################################################################
+# Pointwise operators preserves memory format
+z = x + y
+print(z.stride())  # Outputs: (3072, 1, 96, 3)
+
+######################################################################
+# ``Conv``, ``Batchnorm`` modules using ``cudnn`` backends support channels last
+# (only works for cuDNN >= 7.6). Convolution modules, unlike binary
+# p-wise operator, have channels last as the dominating memory format.
+# If all inputs are in contiguous memory format, the operator
+# produces output in contiguous memory format. Otherwise, output will
+# be in channels last memory format.
+
+if torch.backends.cudnn.is_available() and torch.backends.cudnn.version() >= 7603:
+    model = torch.nn.Conv2d(8, 4, 3).cuda().half()
+    model = model.to(memory_format=torch.channels_last)  # Module parameters need to be channels last
+
+    input = torch.randint(1, 10, (2, 8, 4, 4), dtype=torch.float32, requires_grad=True)
+    input = input.to(device="cuda", memory_format=torch.channels_last, dtype=torch.float16)
+
+    out = model(input)
+    print(out.is_contiguous(memory_format=torch.channels_last))  # Outputs: True
+
+######################################################################
+# When input tensor reaches a operator without channels last support,
+# a permutation should automatically apply in the kernel to restore
+# contiguous on input tensor. This introduces overhead and stops the
+# channels last memory format propagation. Nevertheless, it guarantees
+# correct output.
+
+######################################################################
+# Performance Gains
+# --------------------------------------------------------------------
+# Channels last memory format optimizations are available on both GPU and CPU.
+# On GPU, the most significant performance gains are observed on NVIDIA's
+# hardware with Tensor Cores support running on reduced precision
+# (``torch.float16``).
+# We were able to archive over 22% performance gains with channels last
+# comparing to contiguous format, both while utilizing
+# 'AMP (Automated Mixed Precision)' training scripts.
+# Our scripts uses AMP supplied by NVIDIA
+# https://github.com/NVIDIA/apex.
+#
+# ``python main_amp.py -a resnet50 --b 200 --workers 16 --opt-level O2  ./data``
+
+# opt_level = O2
+# keep_batchnorm_fp32 = None <class 'NoneType'>
+# loss_scale = None <class 'NoneType'>
+# CUDNN VERSION: 7603
+# => creating model 'resnet50'
+# Selected optimization level O2:  FP16 training with FP32 batchnorm and FP32 master weights.
+# Defaults for this optimization level are:
+# enabled                : True
+# opt_level              : O2
+# cast_model_type        : torch.float16
+# patch_torch_functions  : False
+# keep_batchnorm_fp32    : True
+# master_weights         : True
+# loss_scale             : dynamic
+# Processing user overrides (additional kwargs that are not None)...
+# After processing overrides, optimization options are:
+# enabled                : True
+# opt_level              : O2
+# cast_model_type        : torch.float16
+# patch_torch_functions  : False
+# keep_batchnorm_fp32    : True
+# master_weights         : True
+# loss_scale             : dynamic
+# Epoch: [0][10/125] Time 0.866 (0.866) Speed 230.949 (230.949) Loss 0.6735125184 (0.6735) Prec@1 61.000 (61.000) Prec@5 100.000 (100.000)
+# Epoch: [0][20/125] Time 0.259 (0.562) Speed 773.481 (355.693) Loss 0.6968704462 (0.6852) Prec@1 55.000 (58.000) Prec@5 100.000 (100.000)
+# Epoch: [0][30/125] Time 0.258 (0.461) Speed 775.089 (433.965) Loss 0.7877287269 (0.7194) Prec@1 51.500 (55.833) Prec@5 100.000 (100.000)
+# Epoch: [0][40/125] Time 0.259 (0.410) Speed 771.710 (487.281) Loss 0.8285319805 (0.7467) Prec@1 48.500 (54.000) Prec@5 100.000 (100.000)
+# Epoch: [0][50/125] Time 0.260 (0.380) Speed 770.090 (525.908) Loss 0.7370464802 (0.7447) Prec@1 56.500 (54.500) Prec@5 100.000 (100.000)
+# Epoch: [0][60/125] Time 0.258 (0.360) Speed 775.623 (555.728) Loss 0.7592862844 (0.7472) Prec@1 51.000 (53.917) Prec@5 100.000 (100.000)
+# Epoch: [0][70/125] Time 0.258 (0.345) Speed 774.746 (579.115) Loss 1.9698858261 (0.9218) Prec@1 49.500 (53.286) Prec@5 100.000 (100.000)
+# Epoch: [0][80/125] Time 0.260 (0.335) Speed 770.324 (597.659) Loss 2.2505953312 (1.0879) Prec@1 50.500 (52.938) Prec@5 100.000 (100.000)
+
+######################################################################
+# Passing ``--channels-last true`` allows running a model in Channels last format with observed 22% performance gain.
+#
+# ``python main_amp.py -a resnet50 --b 200 --workers 16 --opt-level O2 --channels-last true ./data``
+
+# opt_level = O2
+# keep_batchnorm_fp32 = None <class 'NoneType'>
+# loss_scale = None <class 'NoneType'>
+#
+# CUDNN VERSION: 7603
+#
+# => creating model 'resnet50'
+# Selected optimization level O2:  FP16 training with FP32 batchnorm and FP32 master weights.
+#
+# Defaults for this optimization level are:
+# enabled                : True
+# opt_level              : O2
+# cast_model_type        : torch.float16
+# patch_torch_functions  : False
+# keep_batchnorm_fp32    : True
+# master_weights         : True
+# loss_scale             : dynamic
+# Processing user overrides (additional kwargs that are not None)...
+# After processing overrides, optimization options are:
+# enabled                : True
+# opt_level              : O2
+# cast_model_type        : torch.float16
+# patch_torch_functions  : False
+# keep_batchnorm_fp32    : True
+# master_weights         : True
+# loss_scale             : dynamic
+#
+# Epoch: [0][10/125] Time 0.767 (0.767) Speed 260.785 (260.785) Loss 0.7579724789 (0.7580) Prec@1 53.500 (53.500) Prec@5 100.000 (100.000)
+# Epoch: [0][20/125] Time 0.198 (0.482) Speed 1012.135 (414.716) Loss 0.7007197738 (0.7293) Prec@1 49.000 (51.250) Prec@5 100.000 (100.000)
+# Epoch: [0][30/125] Time 0.198 (0.387) Speed 1010.977 (516.198) Loss 0.7113101482 (0.7233) Prec@1 55.500 (52.667) Prec@5 100.000 (100.000)
+# Epoch: [0][40/125] Time 0.197 (0.340) Speed 1013.023 (588.333) Loss 0.8943189979 (0.7661) Prec@1 54.000 (53.000) Prec@5 100.000 (100.000)
+# Epoch: [0][50/125] Time 0.198 (0.312) Speed 1010.541 (641.977) Loss 1.7113249302 (0.9551) Prec@1 51.000 (52.600) Prec@5 100.000 (100.000)
+# Epoch: [0][60/125] Time 0.198 (0.293) Speed 1011.163 (683.574) Loss 5.8537774086 (1.7716) Prec@1 50.500 (52.250) Prec@5 100.000 (100.000)
+# Epoch: [0][70/125] Time 0.198 (0.279) Speed 1011.453 (716.767) Loss 5.7595844269 (2.3413) Prec@1 46.500 (51.429) Prec@5 100.000 (100.000)
+# Epoch: [0][80/125] Time 0.198 (0.269) Speed 1011.827 (743.883) Loss 2.8196096420 (2.4011) Prec@1 47.500 (50.938) Prec@5 100.000 (100.000)
+
+######################################################################
+# The following list of models has the full support of Channels last and showing 8%-35% performance gains on Volta devices:
+# ``alexnet``, ``mnasnet0_5``, ``mnasnet0_75``, ``mnasnet1_0``, ``mnasnet1_3``, ``mobilenet_v2``, ``resnet101``, ``resnet152``, ``resnet18``, ``resnet34``, ``resnet50``, ``resnext50_32x4d``, ``shufflenet_v2_x0_5``, ``shufflenet_v2_x1_0``, ``shufflenet_v2_x1_5``, ``shufflenet_v2_x2_0``, ``squeezenet1_0``, ``squeezenet1_1``, ``vgg11``, ``vgg11_bn``, ``vgg13``, ``vgg13_bn``, ``vgg16``, ``vgg16_bn``, ``vgg19``, ``vgg19_bn``, ``wide_resnet101_2``, ``wide_resnet50_2``
+#
+
+######################################################################
+# The following list of models has the full support of Channels last and showing 26%-76% performance gains on Intel(R) Xeon(R) Ice Lake (or newer) CPUs:
+# ``alexnet``, ``densenet121``, ``densenet161``, ``densenet169``, ``googlenet``, ``inception_v3``, ``mnasnet0_5``, ``mnasnet1_0``, ``resnet101``, ``resnet152``, ``resnet18``, ``resnet34``, ``resnet50``, ``resnext101_32x8d``, ``resnext50_32x4d``, ``shufflenet_v2_x0_5``, ``shufflenet_v2_x1_0``, ``squeezenet1_0``, ``squeezenet1_1``, ``vgg11``, ``vgg11_bn``, ``vgg13``, ``vgg13_bn``, ``vgg16``, ``vgg16_bn``, ``vgg19``, ``vgg19_bn``, ``wide_resnet101_2``, ``wide_resnet50_2``
+#
+
+######################################################################
+# Converting existing models
+# --------------------------
+#
+# Channels last support is not limited by existing models, as any
+# model can be converted to channels last and propagate format through
+# the graph as soon as input (or certain weight) is formatted
+# correctly.
+#
+
+# Need to be done once, after model initialization (or load)
+model = model.to(memory_format=torch.channels_last)  # Replace with your model
+
+# Need to be done for every input
+input = input.to(memory_format=torch.channels_last)  # Replace with your input
+output = model(input)
+
+#######################################################################
+# However, not all operators fully converted to support channels last
+# (usually returning contiguous output instead). In the example posted
+# above, layers that does not support channels last will stop the
+# memory format propagation. In spite of that, as we have converted the
+# model to channels last format, that means each convolution layer,
+# which has its 4 dimensional weight in channels last memory format,
+# will restore channels last memory format and benefit from faster
+# kernels.
+#
+# But operators that does not support channels last does introduce
+# overhead by permutation. Optionally, you can investigate and identify
+# operators in your model that does not support channels last, if you
+# want to improve the performance of converted model.
+#
+# That means you need to verify the list of used operators
+# against supported operators list https://github.com/pytorch/pytorch/wiki/Operators-with-Channels-Last-support,
+# or introduce memory format checks into eager execution mode and run your model.
+#
+# After running the code below, operators will raise an exception if the output of the
+# operator doesn't match the memory format of the input.
+#
+#
+def contains_cl(args):
+    for t in args:
+        if isinstance(t, torch.Tensor):
+            if t.is_contiguous(memory_format=torch.channels_last) and not t.is_contiguous():
+                return True
+        elif isinstance(t, list) or isinstance(t, tuple):
+            if contains_cl(list(t)):
+                return True
+    return False
+
+
+def print_inputs(args, indent=""):
+    for t in args:
+        if isinstance(t, torch.Tensor):
+            print(indent, t.stride(), t.shape, t.device, t.dtype)
+        elif isinstance(t, list) or isinstance(t, tuple):
+            print(indent, type(t))
+            print_inputs(list(t), indent=indent + "    ")
+        else:
+            print(indent, t)
+
+
+def check_wrapper(fn):
+    name = fn.__name__
+
+    def check_cl(*args, **kwargs):
+        was_cl = contains_cl(args)
+        try:
+            result = fn(*args, **kwargs)
+        except Exception as e:
+            print("`{}` inputs are:".format(name))
+            print_inputs(args)
+            print("-------------------")
+            raise e
+        failed = False
+        if was_cl:
+            if isinstance(result, torch.Tensor):
+                if result.dim() == 4 and not result.is_contiguous(memory_format=torch.channels_last):
+                    print(
+                        "`{}` got channels_last input, but output is not channels_last:".format(name),
+                        result.shape,
+                        result.stride(),
+                        result.device,
+                        result.dtype,
+                    )
+                    failed = True
+        if failed and True:
+            print("`{}` inputs are:".format(name))
+            print_inputs(args)
+            raise Exception("Operator `{}` lost channels_last property".format(name))
+        return result
+
+    return check_cl
+
+
+old_attrs = dict()
+
+
+def attribute(m):
+    old_attrs[m] = dict()
+    for i in dir(m):
+        e = getattr(m, i)
+        exclude_functions = ["is_cuda", "has_names", "numel", "stride", "Tensor", "is_contiguous", "__class__"]
+        if i not in exclude_functions and not i.startswith("_") and "__call__" in dir(e):
+            try:
+                old_attrs[m][i] = e
+                setattr(m, i, check_wrapper(e))
+            except Exception as e:
+                print(i)
+                print(e)
+
+
+attribute(torch.Tensor)
+attribute(torch.nn.functional)
+attribute(torch)
+
+
+######################################################################
+# If you found an operator that doesn't support channels last tensors
+# and you want to contribute, feel free to use following developers
+# guide https://github.com/pytorch/pytorch/wiki/Writing-memory-format-aware-operators.
+#
+
+######################################################################
+# Code below is to recover the attributes of torch.
+
+for (m, attrs) in old_attrs.items():
+    for (k, v) in attrs.items():
+        setattr(m, k, v)
+
+######################################################################
+# Work to do
+# ----------
+# There are still many things to do, such as:
+#
+# - Resolving ambiguity of ``N1HW`` and ``NC11`` Tensors;
+# - Testing of Distributed Training support;
+# - Improving operators coverage.
+#
+# If you have feedback and/or suggestions for improvement, please let us
+# know by creating `an issue <https://github.com/pytorch/pytorch/issues>`_.
+
+######################################################################
+# Conclusion
+# ----------
+#
+# This tutorial introduced the "channels last" memory format and demonstrated
+# how to use it for performance gains. For a practical example of accelerating
+# vision models using channels last, see the post
+# `here <https://pytorch.org/blog/accelerating-pytorch-vision-models-with-channels-last-on-cpu/>`_.
diff --git a/intermediate_source/mnist_train_nas.py b/intermediate_source/mnist_train_nas.py
new file mode 100644
index 00000000000..4ae6d894fce
--- /dev/null
+++ b/intermediate_source/mnist_train_nas.py
@@ -0,0 +1,171 @@
+"""
+Example training code for ``ax_multiobjective_nas_tutorial.py``
+"""
+
+import argparse
+import logging
+import os
+import sys
+import time
+import warnings
+
+import torch
+from IPython.utils import io
+from pytorch_lightning import LightningModule, Trainer
+from pytorch_lightning import loggers as pl_loggers
+from torch import nn
+from torch.nn import functional as F
+from torch.utils.data import DataLoader
+from torchmetrics.functional.classification.accuracy import multiclass_accuracy
+from torchvision import transforms
+from torchvision.datasets import MNIST
+
+warnings.filterwarnings("ignore")  # Disable data logger warnings
+logging.getLogger("pytorch_lightning").setLevel(logging.ERROR)  # Disable GPU/TPU prints
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="train mnist")
+    parser.add_argument(
+        "--log_path", type=str, required=True, help="dir to place tensorboard logs from all trials"
+    )
+    parser.add_argument(
+        "--hidden_size_1", type=int, required=True, help="hidden size layer 1"
+    )
+    parser.add_argument(
+        "--hidden_size_2", type=int, required=True, help="hidden size layer 2"
+    )
+    parser.add_argument("--learning_rate", type=float, required=True, help="learning rate")
+    parser.add_argument("--epochs", type=int, required=True, help="number of epochs")
+    parser.add_argument("--dropout", type=float, required=True, help="dropout probability")
+    parser.add_argument("--batch_size", type=int, required=True, help="batch size")
+    return parser.parse_args()
+
+args = parse_args()
+
+PATH_DATASETS = os.environ.get("PATH_DATASETS", ".")
+
+
+class MnistModel(LightningModule):
+    def __init__(self):
+        super().__init__()
+
+        # Tunable parameters
+        self.hidden_size_1 = args.hidden_size_1
+        self.hidden_size_2 = args.hidden_size_2
+        self.learning_rate = args.learning_rate
+        self.dropout = args.dropout
+        self.batch_size = args.batch_size
+
+        # Set class attributes
+        self.data_dir = PATH_DATASETS
+
+        # Hardcode some dataset specific attributes
+        self.num_classes = 10
+        self.dims = (1, 28, 28)
+        channels, width, height = self.dims
+        self.transform = transforms.Compose(
+            [
+                transforms.ToTensor(),
+                transforms.Normalize((0.1307,), (0.3081,)),
+            ]
+        )
+
+        # Create a PyTorch model
+        layers = [nn.Flatten()]
+        width = channels * width * height
+        hidden_layers = [self.hidden_size_1, self.hidden_size_2]
+        num_params = 0
+        for hidden_size in hidden_layers:
+            if hidden_size > 0:
+                layers.append(nn.Linear(width, hidden_size))
+                layers.append(nn.ReLU())
+                layers.append(nn.Dropout(self.dropout))
+                num_params += width * hidden_size
+                width = hidden_size
+        layers.append(nn.Linear(width, self.num_classes))
+        num_params += width * self.num_classes
+
+        # Save the model and parameter counts
+        self.num_params = num_params
+        self.model = nn.Sequential(*layers)  # No need to use Relu for the last layer
+
+    def forward(self, x):
+        x = self.model(x)
+        return F.log_softmax(x, dim=1)
+
+    def training_step(self, batch, batch_idx):
+        x, y = batch
+        logits = self(x)
+        loss = F.nll_loss(logits, y)
+        return loss
+
+    def validation_step(self, batch, batch_idx):
+        x, y = batch
+        logits = self(x)
+        loss = F.nll_loss(logits, y)
+        preds = torch.argmax(logits, dim=1)
+        acc = multiclass_accuracy(preds, y, num_classes=self.num_classes)
+        self.log("val_acc", acc, prog_bar=False)
+        return loss
+
+    def configure_optimizers(self):
+        optimizer = torch.optim.Adam(self.parameters(), lr=self.learning_rate)
+        return optimizer
+
+    def prepare_data(self):
+        MNIST(self.data_dir, train=True, download=True)
+        MNIST(self.data_dir, train=False, download=True)
+
+    def setup(self, stage=None):
+        self.mnist_train = MNIST(self.data_dir, train=True, transform=self.transform)
+        self.mnist_val = MNIST(self.data_dir, train=False, transform=self.transform)
+
+    def train_dataloader(self):
+        return DataLoader(self.mnist_train, batch_size=self.batch_size)
+
+    def val_dataloader(self):
+        return DataLoader(self.mnist_val, batch_size=self.batch_size)
+
+
+def run_training_job():
+
+    mnist_model = MnistModel()
+
+    # Initialize a trainer (don't log anything since things get so slow...)
+    trainer = Trainer(
+        logger=False,
+        max_epochs=args.epochs,
+        enable_progress_bar=False,
+        deterministic=True,  # Do we want a bit of noise?
+        default_root_dir=args.log_path,
+    )
+
+    logger = pl_loggers.TensorBoardLogger(args.log_path)
+
+    print(f"Logging to path: {args.log_path}.")
+
+    # Train the model and log time ⚡
+    start = time.time()
+    trainer.fit(model=mnist_model)
+    end = time.time()
+    train_time = end - start
+    logger.log_metrics({"train_time": end - start})
+
+    # Compute the validation accuracy once and log the score
+    with io.capture_output() as captured:
+        val_accuracy = trainer.validate()[0]["val_acc"]
+    logger.log_metrics({"val_acc": val_accuracy})
+
+    # Log the number of model parameters
+    num_params = trainer.model.num_params
+    logger.log_metrics({"num_params": num_params})
+
+    logger.save()
+
+    # Print outputs
+    print(f"train time: {train_time}, val acc: {val_accuracy}, num_params: {num_params}")
+
+
+if __name__ == "__main__":
+    run_training_job()
diff --git a/intermediate_source/model_parallel_tutorial.py b/intermediate_source/model_parallel_tutorial.py
deleted file mode 100644
index aea2906844a..00000000000
--- a/intermediate_source/model_parallel_tutorial.py
+++ /dev/null
@@ -1,353 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-Model Parallel Best Practices
-*************************************************************
-**Author**: `Shen Li <https://mrshenli.github.io/>`_
-
-Data parallel and model parallel are 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. ``DataParallel`` 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
-and also shares some insights on how to speed up model parallel training.
-
-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.
-
-**Recommended Reading:**
-
--  https://pytorch.org/ For installation instructions
--  :doc:`/beginner/blitz/data_parallel_tutorial` Single-Machine Data Parallel
--  :doc:`/intermediate/ddp_tutorial` Combine Distributed Data Parallel and Model Parallel
-"""
-
-######################################################################
-# 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 five ``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.reset50()`` 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.reset50()`` 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()"
-# globals arg is only available in Python 3. In Python 2, use the following
-# import __builtin__
-# __builtin__.__dict__.update(locals())
-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 asynchronizely, 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 00000000000..d687caf4634
--- /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/neural_tangent_kernels.py b/intermediate_source/neural_tangent_kernels.py
new file mode 100644
index 00000000000..d70d5c5dca3
--- /dev/null
+++ b/intermediate_source/neural_tangent_kernels.py
@@ -0,0 +1,256 @@
+# -*- coding: utf-8 -*-
+"""
+Neural Tangent Kernels
+======================
+
+The neural tangent kernel (NTK) is a kernel that describes
+`how a neural network evolves during training <https://en.wikipedia.org/wiki/Neural_tangent_kernel>`_.
+There has been a lot of research around it `in recent years <https://arxiv.org/abs/1806.07572>`_.
+This tutorial, inspired by the implementation of `NTKs in JAX <https://github.com/google/neural-tangents>`_
+(see `Fast Finite Width Neural Tangent Kernel <https://arxiv.org/abs/2206.08720>`_ for details),
+demonstrates how to easily compute this quantity using ``torch.func``,
+composable function transforms for PyTorch.
+
+.. note::
+
+   This tutorial requires PyTorch 2.6.0 or later.
+
+Setup
+-----
+
+First, some setup. Let's define a simple CNN that we wish to compute the NTK of.
+"""
+
+import torch
+import torch.nn as nn
+from torch.func import functional_call, vmap, vjp, jvp, jacrev
+
+if torch.accelerator.is_available() and torch.accelerator.device_count() > 0:
+    device = torch.accelerator.current_accelerator()
+else:
+    device = torch.device("cpu")
+
+
+class CNN(nn.Module):
+    def __init__(self):
+        super(CNN, self).__init__()
+        self.conv1 = nn.Conv2d(3, 32, (3, 3))
+        self.conv2 = nn.Conv2d(32, 32, (3, 3))
+        self.conv3 = nn.Conv2d(32, 32, (3, 3))
+        self.fc = nn.Linear(21632, 10)
+
+    def forward(self, x):
+        x = self.conv1(x)
+        x = x.relu()
+        x = self.conv2(x)
+        x = x.relu()
+        x = self.conv3(x)
+        x = x.flatten(1)
+        x = self.fc(x)
+        return x
+
+######################################################################
+# And let's generate some random data
+
+x_train = torch.randn(20, 3, 32, 32, device=device)
+x_test = torch.randn(5, 3, 32, 32, device=device)
+
+######################################################################
+# Create a function version of the model
+# --------------------------------------
+#
+# ``torch.func`` transforms operate on functions. In particular, to compute the NTK,
+# we will need a function that accepts the parameters of the model and a single
+# input (as opposed to a batch of inputs!) and returns a single output.
+#
+# We'll use ``torch.func.functional_call``, which allows us to call an ``nn.Module``
+# using different parameters/buffers, to help accomplish the first step.
+#
+# Keep in mind that the model was originally written to accept a batch of input
+# data points. In our CNN example, there are no inter-batch operations. That
+# is, each data point in the batch is independent of other data points. With
+# this assumption in mind, we can easily generate a function that evaluates the
+# model on a single data point:
+
+
+net = CNN().to(device)
+
+# Detaching the parameters because we won't be calling Tensor.backward().
+params = {k: v.detach() for k, v in net.named_parameters()}
+
+def fnet_single(params, x):
+    return functional_call(net, params, (x.unsqueeze(0),)).squeeze(0)
+
+######################################################################
+# Compute the NTK: method 1 (Jacobian contraction)
+# ------------------------------------------------
+# We're ready to compute the empirical NTK. The empirical NTK for two data
+# points :math:`x_1` and :math:`x_2` is defined as the matrix product between the Jacobian
+# of the model evaluated at :math:`x_1` and the Jacobian of the model evaluated at
+# :math:`x_2`:
+#
+# .. math::
+#
+#    J_{net}(x_1) J_{net}^T(x_2)
+#
+# In the batched case where :math:`x_1` is a batch of data points and :math:`x_2` is a
+# batch of data points, then we want the matrix product between the Jacobians
+# of all combinations of data points from :math:`x_1` and :math:`x_2`.
+#
+# The first method consists of doing just that - computing the two Jacobians,
+# and contracting them. Here's how to compute the NTK in the batched case:
+
+def empirical_ntk_jacobian_contraction(fnet_single, params, x1, x2):
+    # Compute J(x1)
+    jac1 = vmap(jacrev(fnet_single), (None, 0))(params, x1)
+    jac1 = jac1.values()
+    jac1 = [j.flatten(2) for j in jac1]
+
+    # Compute J(x2)
+    jac2 = vmap(jacrev(fnet_single), (None, 0))(params, x2)
+    jac2 = jac2.values()
+    jac2 = [j.flatten(2) for j in jac2]
+
+    # Compute J(x1) @ J(x2).T
+    result = torch.stack([torch.einsum('Naf,Mbf->NMab', j1, j2) for j1, j2 in zip(jac1, jac2)])
+    result = result.sum(0)
+    return result
+
+result = empirical_ntk_jacobian_contraction(fnet_single, params, x_train, x_test)
+print(result.shape)
+
+######################################################################
+# In some cases, you may only want the diagonal or the trace of this quantity,
+# especially if you know beforehand that the network architecture results in an
+# NTK where the non-diagonal elements can be approximated by zero. It's easy to
+# adjust the above function to do that:
+
+def empirical_ntk_jacobian_contraction(fnet_single, params, x1, x2, compute='full'):
+    # Compute J(x1)
+    jac1 = vmap(jacrev(fnet_single), (None, 0))(params, x1)
+    jac1 = jac1.values()
+    jac1 = [j.flatten(2) for j in jac1]
+
+    # Compute J(x2)
+    jac2 = vmap(jacrev(fnet_single), (None, 0))(params, x2)
+    jac2 = jac2.values()
+    jac2 = [j.flatten(2) for j in jac2]
+
+    # Compute J(x1) @ J(x2).T
+    einsum_expr = None
+    if compute == 'full':
+        einsum_expr = 'Naf,Mbf->NMab'
+    elif compute == 'trace':
+        einsum_expr = 'Naf,Maf->NM'
+    elif compute == 'diagonal':
+        einsum_expr = 'Naf,Maf->NMa'
+    else:
+        assert False
+
+    result = torch.stack([torch.einsum(einsum_expr, j1, j2) for j1, j2 in zip(jac1, jac2)])
+    result = result.sum(0)
+    return result
+
+result = empirical_ntk_jacobian_contraction(fnet_single, params, x_train, x_test, 'trace')
+print(result.shape)
+
+######################################################################
+# The asymptotic time complexity of this method is :math:`N O [FP]` (time to
+# compute the Jacobians) + :math:`N^2 O^2 P` (time to contract the Jacobians),
+# where :math:`N` is the batch size of :math:`x_1` and :math:`x_2`, :math:`O`
+# is the model's output size, :math:`P` is the total number of parameters, and
+# :math:`[FP]` is the cost of a single forward pass through the model. See
+# section 3.2 in
+# `Fast Finite Width Neural Tangent Kernel <https://arxiv.org/abs/2206.08720>`_
+# for details.
+#
+# Compute the NTK: method 2 (NTK-vector products)
+# -----------------------------------------------
+#
+# The next method we will discuss is a way to compute the NTK using NTK-vector
+# products.
+#
+# This method reformulates NTK as a stack of NTK-vector products applied to
+# columns of an identity matrix :math:`I_O` of size :math:`O\times O`
+# (where :math:`O` is the output size of the model):
+#
+# .. math::
+#
+#    J_{net}(x_1) J_{net}^T(x_2) = J_{net}(x_1) J_{net}^T(x_2) I_{O} = \left[J_{net}(x_1) \left[J_{net}^T(x_2) e_o\right]\right]_{o=1}^{O},
+#
+# where :math:`e_o\in \mathbb{R}^O` are column vectors of the identity matrix
+# :math:`I_O`.
+#
+# - Let :math:`\textrm{vjp}_o = J_{net}^T(x_2) e_o`. We can use
+#   a vector-Jacobian product to compute this.
+# - Now, consider :math:`J_{net}(x_1) \textrm{vjp}_o`. This is a
+#   Jacobian-vector product!
+# - Finally, we can run the above computation in parallel over all
+#   columns :math:`e_o` of :math:`I_O` using ``vmap``.
+#
+# This suggests that we can use a combination of reverse-mode AD (to compute
+# the vector-Jacobian product) and forward-mode AD (to compute the
+# Jacobian-vector product) to compute the NTK.
+#
+# Let's code that up:
+
+def empirical_ntk_ntk_vps(func, params, x1, x2, compute='full'):
+    def get_ntk(x1, x2):
+        def func_x1(params):
+            return func(params, x1)
+
+        def func_x2(params):
+            return func(params, x2)
+
+        output, vjp_fn = vjp(func_x1, params)
+
+        def get_ntk_slice(vec):
+            # This computes ``vec @ J(x2).T``
+            # `vec` is some unit vector (a single slice of the Identity matrix)
+            vjps = vjp_fn(vec)
+            # This computes ``J(X1) @ vjps``
+            _, jvps = jvp(func_x2, (params,), vjps)
+            return jvps
+
+        # Here's our identity matrix
+        basis = torch.eye(output.numel(), dtype=output.dtype, device=output.device).view(output.numel(), -1)
+        return vmap(get_ntk_slice)(basis)
+
+    # ``get_ntk(x1, x2)`` computes the NTK for a single data point x1, x2
+    # Since the x1, x2 inputs to ``empirical_ntk_ntk_vps`` are batched,
+    # we actually wish to compute the NTK between every pair of data points
+    # between {x1} and {x2}. That's what the ``vmaps`` here do.
+    result = vmap(vmap(get_ntk, (None, 0)), (0, None))(x1, x2)
+
+    if compute == 'full':
+        return result
+    if compute == 'trace':
+        return torch.einsum('NMKK->NM', result)
+    if compute == 'diagonal':
+        return torch.einsum('NMKK->NMK', result)
+
+# Disable TensorFloat-32 for convolutions on Ampere+ GPUs to sacrifice performance in favor of accuracy
+with torch.backends.cudnn.flags(allow_tf32=False):
+    result_from_jacobian_contraction = empirical_ntk_jacobian_contraction(fnet_single, params, x_test, x_train)
+    result_from_ntk_vps = empirical_ntk_ntk_vps(fnet_single, params, x_test, x_train)
+
+assert torch.allclose(result_from_jacobian_contraction, result_from_ntk_vps, atol=1e-5)
+
+######################################################################
+# Our code for ``empirical_ntk_ntk_vps`` looks like a direct translation from
+# the math above! This showcases the power of function transforms: good luck
+# trying to write an efficient version of the above by only using
+# ``torch.autograd.grad``.
+#
+# The asymptotic time complexity of this method is :math:`N^2 O [FP]`, where
+# :math:`N` is the batch size of :math:`x_1` and :math:`x_2`, :math:`O` is the
+# model's output size, and :math:`[FP]` is the cost of a single forward pass
+# through the model. Hence this method performs more forward passes through the
+# network than method 1, Jacobian contraction (:math:`N^2 O` instead of
+# :math:`N O`), but avoids the contraction cost altogether (no :math:`N^2 O^2 P`
+# term, where :math:`P` is the total number of model's parameters). Therefore,
+# this method is preferable when :math:`O P` is large relative to :math:`[FP]`,
+# such as fully-connected (not convolutional) models with many outputs :math:`O`.
+# Memory-wise, both methods should be comparable. See section 3.3 in
+# `Fast Finite Width Neural Tangent Kernel <https://arxiv.org/abs/2206.08720>`_
+# for details.
diff --git a/intermediate_source/nlp_from_scratch_index.rst b/intermediate_source/nlp_from_scratch_index.rst
new file mode 100644
index 00000000000..95f70746cbc
--- /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/nvfuser_intro_tutorial.rst b/intermediate_source/nvfuser_intro_tutorial.rst
new file mode 100644
index 00000000000..965500d71ee
--- /dev/null
+++ b/intermediate_source/nvfuser_intro_tutorial.rst
@@ -0,0 +1,8 @@
+Getting Started - Accelerate Your Scripts with nvFuser
+======================================================
+
+This tutorial has been deprecated. Redirecting to homepage in 3 seconds...
+
+.. raw:: html
+
+   <meta http-equiv="Refresh" content="3; url='https://pytorch.org/tutorials/'" />
diff --git a/intermediate_source/optimizer_step_in_backward_tutorial.py b/intermediate_source/optimizer_step_in_backward_tutorial.py
new file mode 100644
index 00000000000..fd72f733c50
--- /dev/null
+++ b/intermediate_source/optimizer_step_in_backward_tutorial.py
@@ -0,0 +1,268 @@
+"""
+
+How to save memory by fusing the optimizer step into the backward pass
+======================================================================
+
+Hello there! This tutorial aims to showcase one way of reducing the
+memory footprint of a training loop by reducing the memory taken by
+the *gradients*. Say you have a model and you're interested in ways to
+optimize memory to avoid ``Out of Memory`` (OOM) errors or simply to ooze
+more out of your GPU. Well, you _might_ be in luck (if gradients take up
+a portion of your memory and you do not need to do gradient accumulation).
+We will explore the following:
+
+1. What takes up memory during your training or finetuning loop,
+2. How to capture and visualize memory snapshots to determine the bottleneck,
+3. The new ``Tensor.register_post_accumulate_grad_hook(hook)`` API, and finally,
+4. How everything fits together in 10 lines to achieve memory savings.
+
+To run this tutorial, you will need:
+
+*  PyTorch 2.1.0 or newer with ``torchvision``
+*  1 CUDA GPU if you'd like to run the memory visualizations locally.
+   Otherwise, this technique would benefit similarly on any device.
+
+Let us start by importing the required modules and models. We will use a
+vision transformer model from torchvision, but feel free to substitute
+with your own model. We will also use ``torch.optim.Adam`` as our optimizer,
+but, again, feel free to substitute with your own optimizer.
+
+"""
+
+import torch
+from torchvision import models
+from pickle import dump
+
+model = models.vit_l_16(weights='DEFAULT').cuda()
+optimizer = torch.optim.Adam(model.parameters())
+
+###############################################################################
+# Now let's define our typical training loop. You should use real images when
+# training, but for the purposes of this tutorial, we are passing in fake
+# inputs and not worrying about loading any actual data.
+
+IMAGE_SIZE = 224
+
+def train(model, optimizer):
+  # create our fake image input: tensor shape is batch_size, channels, height, width
+  fake_image = torch.rand(1, 3, IMAGE_SIZE, IMAGE_SIZE).cuda()
+
+  # call our forward and backward
+  loss = model.forward(fake_image)
+  loss.sum().backward()
+
+  # optimizer update
+  optimizer.step()
+  optimizer.zero_grad()
+
+###############################################################################
+# Memory usage during training
+# """"""""""""""""""""""""""""
+# We are about to look at some memory snapshots, so we should be prepared to
+# analyze them properly. Typically, training memory consists of:
+#
+#  * Model parameters (size P)
+#  * Activations that are saved for the backward pass (size A)
+#  * Gradients, which are the same size as the model parameters, so size G = P.
+#  * Optimizer state, which is proportional to the size of the parameters. In
+#    this case, the state for Adam requires 2x the model parameters, so size O = 2P.
+#  * Intermediate tensors, which are allocated throughout the compute. We will
+#    not worry about them for now as they are usually small and ephemeral.
+#
+# Capturing and visualizing memory snapshots
+# """"""""""""""""""""""""""""""""""""""""""
+# Let's get us a memory snapshot! As your code runs, consider what you may expect
+# the CUDA memory timeline to look like.
+
+# tell CUDA to start recording memory allocations
+torch.cuda.memory._record_memory_history(enabled='all')
+
+# train 3 steps
+for _ in range(3):
+  train(model, optimizer)
+
+# save a snapshot of the memory allocations
+s = torch.cuda.memory._snapshot()
+with open(f"snapshot.pickle", "wb") as f:
+    dump(s, f)
+
+# tell CUDA to stop recording memory allocations now
+torch.cuda.memory._record_memory_history(enabled=None)
+
+###############################################################################
+# Now open up the snapshot in the CUDA Memory Visualizer at
+# https://pytorch.org/memory_viz by dragging and dropping the
+# ``snapshot.pickle`` file. Does the memory timeline match your expectations?
+# 
+# .. figure:: /_static/img/optim_step_in_bwd/snapshot.jpg
+#    :alt: snapshot.png loaded into CUDA Memory Visualizer
+# 
+# The model parameters have already been loaded in memory before the training
+# step, so we see a chunk of memory devoted to the weights right off the bat.
+# As we start our forward pass, memory is allocated gradually for the activations,
+# or the tensors we are saving to be able to compute gradients in the backward pass.
+# Once we start the backward pass, the activations are gradually freed while memory
+# of the gradients starts building up.
+# 
+# Lastly, as the optimizer kicks in, its state will be lazily initialized, so we 
+# should see the optimizer state memory gradually increase during the optimizer
+# step of the first training loop only. In future loops, the optimizer memory
+# will remain and be updated in-place. The memory for the gradients is then
+# freed accordingly at the end of every training loop when ``zero_grad`` is called.
+# 
+# Where is the memory bottleneck in this training loop? Or, in other words,
+# where is the peak memory?
+# 
+# The peak memory usage is during the optimizer step! Note the memory then
+# consists of ~1.2GB of parameters, ~1.2GB of gradients, and ~2.4GB=2*1.2GB of
+# the optimizer state as expected. The last ~1.2GB comes from Adam optimizer
+# requiring memory for intermediates, totaling to ~6GB of peak memory.
+# Technically, you can remove the need for the last 1.2GB for optimizer
+# intermediates if you set ``Adam(model.parameters(), foreach=False)`` which
+# would trade off runtime for memory. If switching off the ``foreach`` runtime
+# optimization is sufficient in memory savings for you, nice, but please
+# read on if you're curious how this tutorial can help you do better!
+# With the technique we will soon introduce, we will reduce peak memory by
+# removing the need for the ~1.2GB of **gradients memory** as well as **optimizer
+# intermediates memory**. Now, what would you expect the new peak memory to be?
+# The answer will be revealed in the `next` snapshot.
+#
+# DISCLAIMER: This technique is **not** for all
+# """""""""""""""""""""""""""""""""""""""""""""
+# Before we get too excited, we have to consider whether this technique is applicable
+# for `your` use case. This is NOT a silver bullet! The technique of fusing the 
+# optimizer step into the backward only targets reducing *gradient* memory (and as a side effect also optimizer intermediates
+# memory). Thus, the more sizable the memory taken up by the gradients, the more
+# tantamount the memory reduction. In our example above, the gradients eat up 20% 
+# of the memory pie, which is quite sizable!
+#
+# This may not be the case for you, for example, if your weights are already tiny,
+# (say, due to applying LoRa,) then the gradients do not take much space in your
+# training loop and the wins are way less exciting. In that case, you should
+# first try other techniques like activations checkpointing, distributed
+# training, quantization, or reducing the batch size. Then, when the gradients
+# are part of the bottleneck again, come back to this tutorial!
+# 
+# Still here? Cool, let's introduce our new ``register_post_accumulate_grad_hook(hook)``
+# API on Tensor.
+#
+# ``Tensor.register_post_accumulate_grad_hook(hook)`` API and our technique
+# """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
+# Our technique relies on not having to save the gradients during ``backward()``. Instead,
+# once a gradient has been accumulated, we will immediately apply the optimizer to
+# the corresponding parameter and drop that gradient entirely! This removes the need
+# for holding onto a big buffer of gradients until the optimizer step.
+#
+# So how can we unlock the behavior of applying the optimizer more eagerly? In our 2.1
+# release, we've added a new API :func:`torch.Tensor.register_post_accumulate_grad_hook`
+# that would allow us to add a hook onto a Tensor once its ``.grad`` field has been
+# accumulated. We will encapsulate the optimizer step into this hook. How?
+# 
+# How everything fits together in 10 lines
+# """"""""""""""""""""""""""""""""""""""""
+# Remember our model and optimizer setup from the beginning? I'll leave them commented
+# out below so we don't spend resources rerunning the code.
+#
+# .. code-block:: python
+#
+#    model = models.vit_l_16(weights='DEFAULT').cuda()
+#    optimizer = torch.optim.Adam(model.parameters())
+
+# Instead of having just *one* optimizer, we will have a ``dict`` of optimizers
+# for every parameter so we could reference them in our hook.
+optimizer_dict = {p: torch.optim.Adam([p], foreach=False) for p in model.parameters()}
+
+# Define our hook, which will call the optimizer ``step()`` and ``zero_grad()``
+def optimizer_hook(parameter) -> None:
+  optimizer_dict[parameter].step()
+  optimizer_dict[parameter].zero_grad()
+
+# Register the hook onto every parameter
+for p in model.parameters():
+   p.register_post_accumulate_grad_hook(optimizer_hook)
+
+# Now remember our previous ``train()`` function? Since the optimizer has been
+# fused into the backward, we can remove the optimizer step and zero_grad calls.
+def train(model):
+  # create our fake image input: tensor shape is batch_size, channels, height, width
+  fake_image = torch.rand(1, 3, IMAGE_SIZE, IMAGE_SIZE).cuda()
+
+  # call our forward and backward
+  loss = model.forward(fake_image)
+  loss.sum().backward()
+
+  # optimizer update --> no longer needed!
+  # optimizer.step()
+  # optimizer.zero_grad()
+
+########################################################################
+# That took about 10 lines of changes in our sample model, which is neat.
+# However, for real models, it could be a fairly intrusive change to switch
+# out the optimizer for an optimizer dictionary, especially for those who use
+# ``LRScheduler``s or manipulate optimizer configuration throughout the
+# training epochs. Working out this API with those changes will be more
+# involved and will likely require moving more configuration into global
+# state but should not be impossible. That said, a next step for PyTorch
+# is to make this API easier to adopt with LRSchedulers and other features
+# you are already used to.
+# 
+# But let me get back to convincing you that this technique is worth it.
+# We will consult our friend, the memory snapshot.
+
+# delete optimizer memory from before to get a clean slate for the next
+# memory snapshot
+del optimizer
+
+# tell CUDA to start recording memory allocations
+torch.cuda.memory._record_memory_history(enabled='all')
+
+# train 3 steps. note that we no longer pass the optimizer into train()
+for _ in range(3):
+  train(model)
+
+# save a snapshot of the memory allocations
+s = torch.cuda.memory._snapshot()
+with open(f"snapshot-opt-in-bwd.pickle", "wb") as f:
+    dump(s, f)
+
+# tell CUDA to stop recording memory allocations now
+torch.cuda.memory._record_memory_history(enabled=None)
+
+###############################################################################
+# Yes, take some time to drag your snapshot into the CUDA Memory Visualizer.
+# 
+# .. figure:: /_static/img/optim_step_in_bwd/snapshot_opt_in_bwd.jpg
+#    :alt: snapshot.png loaded into CUDA Memory Visualizer
+#
+# Several major observations:
+#  1. There is no more optimizer step! Right...we fused that into the backward.
+#  2. Likewise, the backward drags longer and there are more random allocations
+#     for intermediates. This is expected, as the optimizer step requires 
+#     intermediates.
+#  3. Most importantly! The peak memory is lower! It is now ~4GB (which I
+#     hope maps closely to your earlier expectation). 
+# 
+# Note that there is no longer any big chunk of memory allocated for the gradients
+# compared to before, accounting for ~1.2GB of memory savings. Instead, we've freed
+# each gradient very quickly after they've been computed by moving the optimizer 
+# step as far ahead as we can. Woohoo! By the way, the other ~1.2GB of memory savings
+# comes from breaking apart the optimizer into per-parameter optimizers, so the
+# intermediates have proportionally shrunk. This detail is `less important` than
+# the gradient memory savings, as you can get optimizer intermediates savings
+# from just turning ``foreach=False`` without this technique.
+# 
+# You may be correctly wondering: if we saved 2.4GB of memory, why is the peak memory
+# NOT 6GB - 2.4GB = 3.6GB? Well, the peak has moved! The peak is now near the start
+# of the backward step, when we still have activations in memory, where before, the peak
+# was during the optimizer step when the activations had been freed. The ~0.4GB difference
+# accounting for ~4.0GB - ~3.6GB is thus due to the activations memory. One can then
+# imagine that this technique can be coupled with activations checkpointing for more
+# memory wins.
+#
+# Conclusion
+# """"""""""
+# In this tutorial, we learned about the memory saving technique of
+# fusing the optimizer into the backward step through the new
+# ``Tensor.register_post_accumulate_grad_hook()`` API and *when* to apply this
+# technique (when gradients memory is significant). Along the way, we also learned
+# about memory snapshots, which are generally useful in memory optimization.
diff --git a/intermediate_source/parametrizations.py b/intermediate_source/parametrizations.py
new file mode 100644
index 00000000000..59cff1d241c
--- /dev/null
+++ b/intermediate_source/parametrizations.py
@@ -0,0 +1,393 @@
+# -*- coding: utf-8 -*-
+"""
+Parametrizations Tutorial
+=========================
+**Author**: `Mario Lezcano <https://github.com/lezcano>`_
+
+Regularizing deep-learning models is a surprisingly challenging task.
+Classical techniques such as penalty methods often fall short when applied
+on deep models due to the complexity of the function being optimized.
+This is particularly problematic when working with ill-conditioned models.
+Examples of these are RNNs trained on long sequences and GANs. A number
+of techniques have been proposed in recent years to regularize these
+models and improve their convergence. On recurrent models, it has been
+proposed to control the singular values of the recurrent kernel for the
+RNN to be well-conditioned. This can be achieved, for example, by making
+the recurrent kernel `orthogonal <https://en.wikipedia.org/wiki/Orthogonal_matrix>`_.
+Another way to regularize recurrent models is via
+"`weight normalization <https://pytorch.org/docs/stable/generated/torch.nn.utils.weight_norm.html>`_".
+This approach proposes to decouple the learning of the parameters from the
+learning of their norms.  To do so, the parameter is divided by its
+`Frobenius norm <https://en.wikipedia.org/wiki/Matrix_norm#Frobenius_norm>`_
+and a separate parameter encoding its norm is learned.
+A similar regularization was proposed for GANs under the name of
+"`spectral normalization <https://pytorch.org/docs/stable/generated/torch.nn.utils.spectral_norm.html>`_". This method
+controls the Lipschitz constant of the network by dividing its parameters by
+their `spectral norm <https://en.wikipedia.org/wiki/Matrix_norm#Special_cases>`_,
+rather than their Frobenius norm.
+
+All these methods have a common pattern: they all transform a parameter
+in an appropriate way before using it. In the first case, they make it orthogonal by
+using a function that maps matrices to orthogonal matrices. In the case of weight
+and spectral normalization, they divide the original parameter by its norm.
+
+More generally, all these examples use a function to put extra structure on the parameters.
+In other words, they use a function to constrain the parameters.
+
+In this tutorial, you will learn how to implement and use this pattern to put
+constraints on your model. Doing so is as easy as writing your own ``nn.Module``.
+
+Requirements: ``torch>=1.9.0``
+
+Implementing parametrizations by hand
+-------------------------------------
+
+Assume that we want to have a square linear layer with symmetric weights, that is,
+with weights ``X`` such that ``X = Xᵀ``. One way to do so is
+to copy the upper-triangular part of the matrix into its lower-triangular part
+"""
+
+import torch
+import torch.nn as nn
+import torch.nn.utils.parametrize as parametrize
+
+def symmetric(X):
+    return X.triu() + X.triu(1).transpose(-1, -2)
+
+X = torch.rand(3, 3)
+A = symmetric(X)
+assert torch.allclose(A, A.T)  # A is symmetric
+print(A)                       # Quick visual check
+
+###############################################################################
+# We can then use this idea to implement a linear layer with symmetric weights
+class LinearSymmetric(nn.Module):
+    def __init__(self, n_features):
+        super().__init__()
+        self.weight = nn.Parameter(torch.rand(n_features, n_features))
+
+    def forward(self, x):
+        A = symmetric(self.weight)
+        return x @ A
+
+###############################################################################
+# The layer can be then used as a regular linear layer
+layer = LinearSymmetric(3)
+out = layer(torch.rand(8, 3))
+
+###############################################################################
+# This implementation, although correct and self-contained, presents a number of problems:
+#
+# 1) It reimplements the layer. We had to implement the linear layer as ``x @ A``. This is
+#    not very problematic for a linear layer, but imagine having to reimplement a CNN or a
+#    Transformer...
+# 2) It does not separate the layer and the parametrization.  If the parametrization were
+#    more difficult, we would have to rewrite its code for each layer that we want to use it
+#    in.
+# 3) It recomputes the parametrization every time we use the layer. If we use the layer
+#    several times during the forward pass, (imagine the recurrent kernel of an RNN), it
+#    would compute the same ``A`` every time that the layer is called.
+#
+# Introduction to parametrizations
+# --------------------------------
+#
+# Parametrizations can solve all these problems as well as others.
+#
+# Let's start by reimplementing the code above using ``torch.nn.utils.parametrize``.
+# The only thing that we have to do is to write the parametrization as a regular ``nn.Module``
+class Symmetric(nn.Module):
+    def forward(self, X):
+        return X.triu() + X.triu(1).transpose(-1, -2)
+
+###############################################################################
+# This is all we need to do. Once we have this, we can transform any regular layer into a
+# symmetric layer by doing
+layer = nn.Linear(3, 3)
+parametrize.register_parametrization(layer, "weight", Symmetric())
+
+###############################################################################
+# Now, the matrix of the linear layer is symmetric
+A = layer.weight
+assert torch.allclose(A, A.T)  # A is symmetric
+print(A)                       # Quick visual check
+
+###############################################################################
+# We can do the same thing with any other layer. For example, we can create a CNN with
+# `skew-symmetric <https://en.wikipedia.org/wiki/Skew-symmetric_matrix>`_ kernels.
+# We use a similar parametrization, copying the upper-triangular part with signs
+# reversed into the lower-triangular part
+class Skew(nn.Module):
+    def forward(self, X):
+        A = X.triu(1)
+        return A - A.transpose(-1, -2)
+
+
+cnn = nn.Conv2d(in_channels=5, out_channels=8, kernel_size=3)
+parametrize.register_parametrization(cnn, "weight", Skew())
+# Print a few kernels
+print(cnn.weight[0, 1])
+print(cnn.weight[2, 2])
+
+###############################################################################
+# Inspecting a parametrized module
+# --------------------------------
+#
+# When a module is parametrized, we find that the module has changed in three ways:
+#
+# 1) ``model.weight`` is now a property
+#
+# 2) It has a new ``module.parametrizations`` attribute
+#
+# 3) The unparametrized weight has been moved to ``module.parametrizations.weight.original``
+#
+# |
+# After parametrizing ``weight``, ``layer.weight`` is turned into a
+# `Python property <https://docs.python.org/3/library/functions.html#property>`_.
+# This property computes ``parametrization(weight)`` every time we request ``layer.weight``
+# just as we did in our implementation of ``LinearSymmetric`` above.
+#
+# Registered parametrizations are stored under a ``parametrizations`` attribute within the module.
+layer = nn.Linear(3, 3)
+print(f"Unparametrized:\n{layer}")
+parametrize.register_parametrization(layer, "weight", Symmetric())
+print(f"\nParametrized:\n{layer}")
+
+###############################################################################
+# This ``parametrizations`` attribute is an ``nn.ModuleDict``, and it can be accessed as such
+print(layer.parametrizations)
+print(layer.parametrizations.weight)
+
+###############################################################################
+# Each element of this ``nn.ModuleDict`` is a ``ParametrizationList``, which behaves like an
+# ``nn.Sequential``. This list will allow us to concatenate parametrizations on one weight.
+# Since this is a list, we can access the parametrizations indexing it. Here's
+# where our ``Symmetric`` parametrization sits
+print(layer.parametrizations.weight[0])
+
+###############################################################################
+# The other thing that we notice is that, if we print the parameters, we see that the
+# parameter ``weight`` has been moved
+print(dict(layer.named_parameters()))
+
+###############################################################################
+# It now sits under ``layer.parametrizations.weight.original``
+print(layer.parametrizations.weight.original)
+
+###############################################################################
+# Besides these three small differences, the parametrization is doing exactly the same
+# as our manual implementation
+symmetric = Symmetric()
+weight_orig = layer.parametrizations.weight.original
+print(torch.dist(layer.weight, symmetric(weight_orig)))
+
+###############################################################################
+# Parametrizations are first-class citizens
+# -----------------------------------------
+#
+# Since ``layer.parametrizations`` is an ``nn.ModuleList``, it means that the parametrizations
+# are properly registered as submodules of the original module. As such, the same rules
+# for registering parameters in a module apply to register a parametrization.
+# For example, if a parametrization has parameters, these will be moved from CPU
+# to CUDA when calling ``model = model.cuda()``.
+#
+# Caching the value of a parametrization
+# --------------------------------------
+#
+# Parametrizations come with an inbuilt caching system via the context manager
+# ``parametrize.cached()``
+class NoisyParametrization(nn.Module):
+    def forward(self, X):
+        print("Computing the Parametrization")
+        return X
+
+layer = nn.Linear(4, 4)
+parametrize.register_parametrization(layer, "weight", NoisyParametrization())
+print("Here, layer.weight is recomputed every time we call it")
+foo = layer.weight + layer.weight.T
+bar = layer.weight.sum()
+with parametrize.cached():
+    print("Here, it is computed just the first time layer.weight is called")
+    foo = layer.weight + layer.weight.T
+    bar = layer.weight.sum()
+
+###############################################################################
+# Concatenating parametrizations
+# ------------------------------
+#
+# Concatenating two parametrizations is as easy as registering them on the same tensor.
+# We may use this to create more complex parametrizations from simpler ones. For example, the
+# `Cayley map <https://en.wikipedia.org/wiki/Cayley_transform#Matrix_map>`_
+# maps the skew-symmetric matrices to the orthogonal matrices of positive determinant. We can
+# concatenate ``Skew`` and a parametrization that implements the Cayley map to get a layer with
+# orthogonal weights
+class CayleyMap(nn.Module):
+    def __init__(self, n):
+        super().__init__()
+        self.register_buffer("Id", torch.eye(n))
+
+    def forward(self, X):
+        # (I + X)(I - X)^{-1}
+        return torch.linalg.solve(self.Id - X, self.Id + X)
+
+layer = nn.Linear(3, 3)
+parametrize.register_parametrization(layer, "weight", Skew())
+parametrize.register_parametrization(layer, "weight", CayleyMap(3))
+X = layer.weight
+print(torch.dist(X.T @ X, torch.eye(3)))  # X is orthogonal
+
+###############################################################################
+# This may also be used to prune a parametrized module, or to reuse parametrizations. For example,
+# the matrix exponential maps the symmetric matrices to the Symmetric Positive Definite (SPD) matrices
+# But the matrix exponential also maps the skew-symmetric matrices to the orthogonal matrices.
+# Using these two facts, we may reuse the parametrizations before to our advantage
+class MatrixExponential(nn.Module):
+    def forward(self, X):
+        return torch.matrix_exp(X)
+
+layer_orthogonal = nn.Linear(3, 3)
+parametrize.register_parametrization(layer_orthogonal, "weight", Skew())
+parametrize.register_parametrization(layer_orthogonal, "weight", MatrixExponential())
+X = layer_orthogonal.weight
+print(torch.dist(X.T @ X, torch.eye(3)))         # X is orthogonal
+
+layer_spd = nn.Linear(3, 3)
+parametrize.register_parametrization(layer_spd, "weight", Symmetric())
+parametrize.register_parametrization(layer_spd, "weight", MatrixExponential())
+X = layer_spd.weight
+print(torch.dist(X, X.T))                        # X is symmetric
+print((torch.linalg.eigvalsh(X) > 0.).all())  # X is positive definite
+
+###############################################################################
+# Initializing parametrizations
+# -----------------------------
+#
+# Parametrizations come with a mechanism to initialize them. If we implement a method
+# ``right_inverse`` with signature
+#
+# .. code-block:: python
+#
+#     def right_inverse(self, X: Tensor) -> Tensor
+#
+# it will be used when assigning to the parametrized tensor.
+#
+# Let's upgrade our implementation of the ``Skew`` class to support this
+class Skew(nn.Module):
+    def forward(self, X):
+        A = X.triu(1)
+        return A - A.transpose(-1, -2)
+
+    def right_inverse(self, A):
+        # We assume that A is skew-symmetric
+        # We take the upper-triangular elements, as these are those used in the forward
+        return A.triu(1)
+
+###############################################################################
+# We may now initialize a layer that is parametrized with ``Skew``
+layer = nn.Linear(3, 3)
+parametrize.register_parametrization(layer, "weight", Skew())
+X = torch.rand(3, 3)
+X = X - X.T                             # X is now skew-symmetric
+layer.weight = X                        # Initialize layer.weight to be X
+print(torch.dist(layer.weight, X))      # layer.weight == X
+
+###############################################################################
+# This ``right_inverse`` works as expected when we concatenate parametrizations.
+# To see this, let's upgrade the Cayley parametrization to also support being initialized
+class CayleyMap(nn.Module):
+    def __init__(self, n):
+        super().__init__()
+        self.register_buffer("Id", torch.eye(n))
+
+    def forward(self, X):
+        # Assume X skew-symmetric
+        # (I + X)(I - X)^{-1}
+        return torch.linalg.solve(self.Id - X, self.Id + X)
+
+    def right_inverse(self, A):
+        # Assume A orthogonal
+        # See https://en.wikipedia.org/wiki/Cayley_transform#Matrix_map
+        # (A - I)(A + I)^{-1}
+        return torch.linalg.solve(A + self.Id, self.Id - A)
+
+layer_orthogonal = nn.Linear(3, 3)
+parametrize.register_parametrization(layer_orthogonal, "weight", Skew())
+parametrize.register_parametrization(layer_orthogonal, "weight", CayleyMap(3))
+# Sample an orthogonal matrix with positive determinant
+X = torch.empty(3, 3)
+nn.init.orthogonal_(X)
+if X.det() < 0.:
+    X[0].neg_()
+layer_orthogonal.weight = X
+print(torch.dist(layer_orthogonal.weight, X))  # layer_orthogonal.weight == X
+
+###############################################################################
+# This initialization step can be written more succinctly as
+layer_orthogonal.weight = nn.init.orthogonal_(layer_orthogonal.weight)
+
+###############################################################################
+# The name of this method comes from the fact that we would often expect
+# that ``forward(right_inverse(X)) == X``. This is a direct way of rewriting that
+# the forward after the initialization with value ``X`` should return the value ``X``.
+# This constraint is not strongly enforced in practice. In fact, at times, it might be of
+# interest to relax this relation. For example, consider the following implementation
+# of a randomized pruning method:
+class PruningParametrization(nn.Module):
+    def __init__(self, X, p_drop=0.2):
+        super().__init__()
+        # sample zeros with probability p_drop
+        mask = torch.full_like(X, 1.0 - p_drop)
+        self.mask = torch.bernoulli(mask)
+
+    def forward(self, X):
+        return X * self.mask
+
+    def right_inverse(self, A):
+        return A
+
+###############################################################################
+# In this case, it is not true that for every matrix A ``forward(right_inverse(A)) == A``.
+# This is only true when the matrix ``A`` has zeros in the same positions as the mask.
+# Even then, if we assign a tensor to a pruned parameter, it will comes as no surprise
+# that tensor will be, in fact, pruned
+layer = nn.Linear(3, 4)
+X = torch.rand_like(layer.weight)
+print(f"Initialization matrix:\n{X}")
+parametrize.register_parametrization(layer, "weight", PruningParametrization(layer.weight))
+layer.weight = X
+print(f"\nInitialized weight:\n{layer.weight}")
+
+###############################################################################
+# Removing parametrizations
+# -------------------------
+#
+# We may remove all the parametrizations from a parameter or a buffer in a module
+# by using ``parametrize.remove_parametrizations()``
+layer = nn.Linear(3, 3)
+print("Before:")
+print(layer)
+print(layer.weight)
+parametrize.register_parametrization(layer, "weight", Skew())
+print("\nParametrized:")
+print(layer)
+print(layer.weight)
+parametrize.remove_parametrizations(layer, "weight")
+print("\nAfter. Weight has skew-symmetric values but it is unconstrained:")
+print(layer)
+print(layer.weight)
+
+###############################################################################
+# When removing a parametrization, we may choose to leave the original parameter (i.e. that in
+# ``layer.parametriations.weight.original``) rather than its parametrized version by setting
+# the flag ``leave_parametrized=False``
+layer = nn.Linear(3, 3)
+print("Before:")
+print(layer)
+print(layer.weight)
+parametrize.register_parametrization(layer, "weight", Skew())
+print("\nParametrized:")
+print(layer)
+print(layer.weight)
+parametrize.remove_parametrizations(layer, "weight", leave_parametrized=False)
+print("\nAfter. Same as Before:")
+print(layer)
+print(layer.weight)
diff --git a/intermediate_source/per_sample_grads.py b/intermediate_source/per_sample_grads.py
new file mode 100644
index 00000000000..a5ece9303fc
--- /dev/null
+++ b/intermediate_source/per_sample_grads.py
@@ -0,0 +1,225 @@
+# -*- coding: utf-8 -*-
+"""
+Per-sample-gradients
+====================
+
+What is it?
+-----------
+
+Per-sample-gradient computation is computing the gradient for each and every
+sample in a batch of data. It is a useful quantity in differential privacy,
+meta-learning, and optimization research.
+
+.. note::
+
+   This tutorial requires PyTorch 2.0.0 or later.
+
+"""
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+torch.manual_seed(0)
+
+# Here's a simple CNN and loss function:
+
+class SimpleCNN(nn.Module):
+    def __init__(self):
+        super(SimpleCNN, self).__init__()
+        self.conv1 = nn.Conv2d(1, 32, 3, 1)
+        self.conv2 = nn.Conv2d(32, 64, 3, 1)
+        self.fc1 = nn.Linear(9216, 128)
+        self.fc2 = nn.Linear(128, 10)
+
+    def forward(self, x):
+        x = self.conv1(x)
+        x = F.relu(x)
+        x = self.conv2(x)
+        x = F.relu(x)
+        x = F.max_pool2d(x, 2)
+        x = torch.flatten(x, 1)
+        x = self.fc1(x)
+        x = F.relu(x)
+        x = self.fc2(x)
+        output = F.log_softmax(x, dim=1)
+        return output
+
+def loss_fn(predictions, targets):
+    return F.nll_loss(predictions, targets)
+
+
+######################################################################
+# Let’s generate a batch of dummy data and pretend that we’re working with an MNIST dataset.
+# The dummy images are 28 by 28 and we use a minibatch of size 64.
+
+device = 'cuda'
+
+num_models = 10
+batch_size = 64
+data = torch.randn(batch_size, 1, 28, 28, device=device)
+
+targets = torch.randint(10, (64,), device=device)
+
+######################################################################
+# In regular model training, one would forward the minibatch through the model,
+# and then call .backward() to compute gradients.  This would generate an
+# 'average' gradient of the entire mini-batch:
+
+model = SimpleCNN().to(device=device)
+predictions = model(data)  # move the entire mini-batch through the model
+
+loss = loss_fn(predictions, targets)
+loss.backward()  # back propagate the 'average' gradient of this mini-batch
+
+######################################################################
+# In contrast to the above approach, per-sample-gradient computation is
+# equivalent to:
+#
+# - for each individual sample of the data, perform a forward and a backward
+#   pass to get an individual (per-sample) gradient.
+
+def compute_grad(sample, target):
+    sample = sample.unsqueeze(0)  # prepend batch dimension for processing
+    target = target.unsqueeze(0)
+
+    prediction = model(sample)
+    loss = loss_fn(prediction, target)
+
+    return torch.autograd.grad(loss, list(model.parameters()))
+
+
+def compute_sample_grads(data, targets):
+    """ manually process each sample with per sample gradient """
+    sample_grads = [compute_grad(data[i], targets[i]) for i in range(batch_size)]
+    sample_grads = zip(*sample_grads)
+    sample_grads = [torch.stack(shards) for shards in sample_grads]
+    return sample_grads
+
+per_sample_grads = compute_sample_grads(data, targets)
+
+######################################################################
+# ``sample_grads[0]`` is the per-sample-grad for model.conv1.weight.
+# ``model.conv1.weight.shape`` is ``[32, 1, 3, 3]``; notice how there is one
+# gradient, per sample, in the batch for a total of 64.
+
+print(per_sample_grads[0].shape)
+
+######################################################################
+# Per-sample-grads, *the efficient way*, using function transforms
+# ----------------------------------------------------------------
+# We can compute per-sample-gradients efficiently by using function transforms.
+#
+# The ``torch.func`` function transform API transforms over functions.
+# Our strategy is to define a function that computes the loss and then apply
+# transforms to construct a function that computes per-sample-gradients.
+#
+# We'll use the ``torch.func.functional_call`` function to treat an ``nn.Module``
+# like a function.
+#
+# First, let’s extract the state from ``model`` into two dictionaries,
+# parameters and buffers. We'll be detaching them because we won't use
+# regular PyTorch autograd (e.g. Tensor.backward(), torch.autograd.grad).
+
+from torch.func import functional_call, vmap, grad
+
+params = {k: v.detach() for k, v in model.named_parameters()}
+buffers = {k: v.detach() for k, v in model.named_buffers()}
+
+######################################################################
+# Next, let's define a function to compute the loss of the model given a
+# single input rather than a batch of inputs. It is important that this
+# function accepts the parameters, the input, and the target, because we will
+# be transforming over them.
+#
+# Note - because the model was originally written to handle batches, we’ll
+# use ``torch.unsqueeze`` to add a batch dimension.
+
+def compute_loss(params, buffers, sample, target):
+    batch = sample.unsqueeze(0)
+    targets = target.unsqueeze(0)
+
+    predictions = functional_call(model, (params, buffers), (batch,))
+    loss = loss_fn(predictions, targets)
+    return loss
+
+######################################################################
+# Now, let’s use the ``grad`` transform to create a new function that computes
+# the gradient with respect to the first argument of ``compute_loss``
+# (i.e. the ``params``).
+
+ft_compute_grad = grad(compute_loss)
+
+######################################################################
+# The ``ft_compute_grad`` function computes the gradient for a single
+# (sample, target) pair. We can use ``vmap`` to get it to compute the gradient
+# over an entire batch of samples and targets. Note that
+# ``in_dims=(None, None, 0, 0)`` because we wish to map ``ft_compute_grad`` over
+# the 0th dimension of the data and targets, and use the same ``params`` and
+# buffers for each.
+
+ft_compute_sample_grad = vmap(ft_compute_grad, in_dims=(None, None, 0, 0))
+
+######################################################################
+# Finally, let's used our transformed function to compute per-sample-gradients:
+
+ft_per_sample_grads = ft_compute_sample_grad(params, buffers, data, targets)
+
+######################################################################
+# we can double check that the results using ``grad`` and ``vmap`` match the
+# results of hand processing each one individually:
+
+for per_sample_grad, ft_per_sample_grad in zip(per_sample_grads, ft_per_sample_grads.values()):
+    assert torch.allclose(per_sample_grad, ft_per_sample_grad, atol=1.2e-1, rtol=1e-5)
+
+######################################################################
+# A quick note: there are limitations around what types of functions can be
+# transformed by ``vmap``. The best functions to transform are ones that are pure
+# functions: a function where the outputs are only determined by the inputs,
+# and that have no side effects (e.g. mutation). ``vmap`` is unable to handle
+# mutation of arbitrary Python data structures, but it is able to handle many
+# in-place PyTorch operations.
+#
+# Performance comparison
+# ----------------------
+#
+# Curious about how the performance of ``vmap`` compares?
+#
+# Currently the best results are obtained on newer GPU's such as the A100
+# (Ampere) where we've seen up to 25x speedups on this example, but here are
+# some results on our build machines:
+
+def get_perf(first, first_descriptor, second, second_descriptor):
+    """takes torch.benchmark objects and compares delta of second vs first."""
+    second_res = second.times[0]
+    first_res = first.times[0]
+
+    gain = (first_res-second_res)/first_res
+    if gain < 0: gain *=-1 
+    final_gain = gain*100
+
+    print(f"Performance delta: {final_gain:.4f} percent improvement with {first_descriptor} ")
+
+from torch.utils.benchmark import Timer
+
+without_vmap = Timer(stmt="compute_sample_grads(data, targets)", globals=globals())
+with_vmap = Timer(stmt="ft_compute_sample_grad(params, buffers, data, targets)",globals=globals())
+no_vmap_timing = without_vmap.timeit(100)
+with_vmap_timing = with_vmap.timeit(100)
+
+print(f'Per-sample-grads without vmap {no_vmap_timing}')
+print(f'Per-sample-grads with vmap {with_vmap_timing}')
+
+get_perf(with_vmap_timing, "vmap", no_vmap_timing, "no vmap")
+
+######################################################################
+# There are other optimized solutions (like in https://github.com/pytorch/opacus)
+# to computing per-sample-gradients in PyTorch that also perform better than
+# the naive method. But it’s cool that composing ``vmap`` and ``grad`` give us a
+# nice speedup.
+#
+# In general, vectorization with ``vmap`` should be faster than running a function
+# in a for-loop and competitive with manual batching. There are some exceptions
+# though, like if we haven’t implemented the ``vmap`` rule for a particular
+# operation or if the underlying kernels weren’t optimized for older hardware
+# (GPUs). If you see any of these cases, please let us know by opening an issue
+# at on GitHub.
diff --git a/intermediate_source/pinmem_nonblock.py b/intermediate_source/pinmem_nonblock.py
new file mode 100644
index 00000000000..4d82a06a989
--- /dev/null
+++ b/intermediate_source/pinmem_nonblock.py
@@ -0,0 +1,769 @@
+# -*- coding: utf-8 -*-
+"""
+A guide on good usage of ``non_blocking`` and ``pin_memory()`` in PyTorch
+=========================================================================
+
+**Author**: `Vincent Moens <https://github.com/vmoens>`_
+
+Introduction
+------------
+
+Transferring data from the CPU to the GPU is fundamental in many PyTorch applications.
+It's crucial for users to understand the most effective tools and options available for moving data between devices.
+This tutorial examines two key methods for device-to-device data transfer in PyTorch:
+:meth:`~torch.Tensor.pin_memory` and :meth:`~torch.Tensor.to` with the ``non_blocking=True`` option.
+
+What you will learn
+~~~~~~~~~~~~~~~~~~~
+
+Optimizing the transfer of tensors from the CPU to the GPU can be achieved through asynchronous transfers and memory
+pinning. However, there are important considerations:
+
+- Using ``tensor.pin_memory().to(device, non_blocking=True)`` can be up to twice as slow as a straightforward ``tensor.to(device)``.
+- Generally, ``tensor.to(device, non_blocking=True)`` is an effective choice for enhancing transfer speed.
+- While ``cpu_tensor.to("cuda", non_blocking=True).mean()`` executes correctly, attempting
+  ``cuda_tensor.to("cpu", non_blocking=True).mean()`` will result in erroneous outputs.
+
+Preamble
+~~~~~~~~
+
+The performance reported in this tutorial are conditioned on the system used to build the tutorial.
+Although the conclusions are applicable across different systems, the specific observations may vary slightly
+depending on the hardware available, especially on older hardware.
+The primary objective of this tutorial is to offer a theoretical framework for understanding CPU to GPU data transfers.
+However, any design decisions should be tailored to individual cases and guided by benchmarked throughput measurements,
+as well as the specific requirements of the task at hand.
+
+"""
+
+import torch
+
+assert torch.cuda.is_available(), "A cuda device is required to run this tutorial"
+
+
+######################################################################
+#
+# This tutorial requires tensordict to be installed. If you don't have tensordict in your environment yet, install it
+# by running the following command in a separate cell:
+#
+# .. code-block:: bash
+#
+#    # Install tensordict with the following command
+#    !pip3 install tensordict
+#
+# We start by outlining the theory surrounding these concepts, and then move to concrete test examples of the features.
+#
+#
+# Background
+# ----------
+#
+#   .. _pinned_memory_background:
+#
+# Memory management basics
+# ~~~~~~~~~~~~~~~~~~~~~~~~
+#
+#   .. _pinned_memory_memory:
+#
+# When one creates a CPU tensor in PyTorch, the content of this tensor needs to be placed
+# in memory. The memory we talk about here is a rather complex concept worth looking at carefully.
+# We distinguish two types of memory that are handled by the Memory Management Unit: the RAM (for simplicity)
+# and the swap space on disk (which may or may not be the hard drive). Together, the available space in disk and RAM (physical memory)
+# make up the virtual memory, which is an abstraction of the total resources available.
+# In short, the virtual memory makes it so that the available space is larger than what can be found on RAM in isolation
+# and creates the illusion that the main memory is larger than it actually is.
+#
+# In normal circumstances, a regular CPU tensor is pageable which means that it is divided in blocks called pages that
+# can live anywhere in the virtual memory (both in RAM or on disk). As mentioned earlier, this has the advantage that
+# the memory seems larger than what the main memory actually is.
+#
+# Typically, when a program accesses a page that is not in RAM, a "page fault" occurs and the operating system (OS) then brings
+# back this page into RAM ("swap in" or "page in").
+# In turn, the OS may have to swap out (or "page out") another page to make room for the new page.
+#
+# In contrast to pageable memory, a pinned (or page-locked or non-pageable) memory is a type of memory that cannot
+# be swapped out to disk.
+# It allows for faster and more predictable access times, but has the downside that it is more limited than the
+# pageable memory (aka the main memory).
+#
+# .. figure:: /_static/img/pinmem/pinmem.png
+#    :alt:
+#
+# CUDA and (non-)pageable memory
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+#   .. _pinned_memory_cuda_pageable_memory:
+#
+# To understand how CUDA copies a tensor from CPU to CUDA, let's consider the two scenarios above:
+#
+# - If the memory is page-locked, the device can access the memory directly in the main memory. The memory addresses are well
+#   defined and functions that need to read these data can be significantly accelerated.
+# - If the memory is pageable, all the pages will have to be brought to the main memory before being sent to the GPU.
+#   This operation may take time and is less predictable than when executed on page-locked tensors.
+#
+# More precisely, when CUDA sends pageable data from CPU to GPU, it must first create a page-locked copy of that data
+# before making the transfer.
+#
+# Asynchronous vs. Synchronous Operations with ``non_blocking=True`` (CUDA ``cudaMemcpyAsync``)
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+#   .. _pinned_memory_async_sync:
+#
+# When executing a copy from a host (such as, CPU) to a device (such as, GPU), the CUDA toolkit offers modalities to do these
+# operations synchronously or asynchronously with respect to the host.
+#
+# In practice, when calling :meth:`~torch.Tensor.to`, PyTorch always makes a call to
+# `cudaMemcpyAsync <https://docs.nvidia.com/cuda/cuda-runtime-api/group__CUDART__MEMORY.html#group__CUDART__MEMORY_1g85073372f776b4c4d5f89f7124b7bf79>`_.
+# If ``non_blocking=False`` (default), a ``cudaStreamSynchronize`` will be called after each and every ``cudaMemcpyAsync``, making
+# the call to :meth:`~torch.Tensor.to` blocking in the main thread.
+# If ``non_blocking=True``, no synchronization is triggered, and the main thread on the host is not blocked.
+# Therefore, from the host perspective, multiple tensors can be sent to the device simultaneously,
+# as the thread does not need to wait for one transfer to be completed to initiate the other.
+#
+# .. note:: In general, the transfer is blocking on the device side (even if it isn't on the host side):
+#   the copy on the device cannot occur while another operation is being executed.
+#   However, in some advanced scenarios, a copy and a kernel execution can be done simultaneously on the GPU side.
+#   As the following example will show, three requirements must be met to enable this:
+#
+#   1. The device must have at least one free DMA (Direct Memory Access) engine. Modern GPU architectures such as Volterra,
+#      Tesla, or H100 devices have more than one DMA engine.
+#
+#   2. The transfer must be done on a separate, non-default cuda stream. In PyTorch, cuda streams can be handles using
+#      :class:`~torch.cuda.Stream`.
+#
+#   3. The source data must be in pinned memory.
+#
+#   We demonstrate this by running profiles on the following script.
+#
+
+import contextlib
+
+from torch.cuda import Stream
+
+
+s = Stream()
+
+torch.manual_seed(42)
+t1_cpu_pinned = torch.randn(1024**2 * 5, pin_memory=True)
+t2_cpu_paged = torch.randn(1024**2 * 5, pin_memory=False)
+t3_cuda = torch.randn(1024**2 * 5, device="cuda:0")
+
+assert torch.cuda.is_available()
+device = torch.device("cuda", torch.cuda.current_device())
+
+
+# The function we want to profile
+def inner(pinned: bool, streamed: bool):
+    with torch.cuda.stream(s) if streamed else contextlib.nullcontext():
+        if pinned:
+            t1_cuda = t1_cpu_pinned.to(device, non_blocking=True)
+        else:
+            t2_cuda = t2_cpu_paged.to(device, non_blocking=True)
+        t_star_cuda_h2d_event = s.record_event()
+    # This operation can be executed during the CPU to GPU copy if and only if the tensor is pinned and the copy is
+    #  done in the other stream
+    t3_cuda_mul = t3_cuda * t3_cuda * t3_cuda
+    t3_cuda_h2d_event = torch.cuda.current_stream().record_event()
+    t_star_cuda_h2d_event.synchronize()
+    t3_cuda_h2d_event.synchronize()
+
+
+# Our profiler: profiles the `inner` function and stores the results in a .json file
+def benchmark_with_profiler(
+    pinned,
+    streamed,
+) -> None:
+    torch._C._profiler._set_cuda_sync_enabled_val(True)
+    wait, warmup, active = 1, 1, 2
+    num_steps = wait + warmup + active
+    rank = 0
+    with torch.profiler.profile(
+        activities=[
+            torch.profiler.ProfilerActivity.CPU,
+            torch.profiler.ProfilerActivity.CUDA,
+        ],
+        schedule=torch.profiler.schedule(
+            wait=wait, warmup=warmup, active=active, repeat=1, skip_first=1
+        ),
+    ) as prof:
+        for step_idx in range(1, num_steps + 1):
+            inner(streamed=streamed, pinned=pinned)
+            if rank is None or rank == 0:
+                prof.step()
+    prof.export_chrome_trace(f"trace_streamed{int(streamed)}_pinned{int(pinned)}.json")
+
+
+######################################################################
+# Loading these profile traces in chrome (``chrome://tracing``) shows the following results: first, let's see
+# what happens if both the arithmetic operation on ``t3_cuda`` is executed after the pageable tensor is sent to GPU
+# in the main stream:
+#
+
+benchmark_with_profiler(streamed=False, pinned=False)
+
+######################################################################
+# .. figure:: /_static/img/pinmem/trace_streamed0_pinned0.png
+#    :alt:
+#
+# Using a pinned tensor doesn't change the trace much, both operations are still executed consecutively:
+
+benchmark_with_profiler(streamed=False, pinned=True)
+
+######################################################################
+#
+# .. figure:: /_static/img/pinmem/trace_streamed0_pinned1.png
+#    :alt:
+#
+# Sending a pageable tensor to GPU on a separate stream is also a blocking operation:
+
+benchmark_with_profiler(streamed=True, pinned=False)
+
+######################################################################
+#
+# .. figure:: /_static/img/pinmem/trace_streamed1_pinned0.png
+#    :alt:
+#
+# Only pinned tensors copies to GPU on a separate stream overlap with another cuda kernel executed on
+# the main stream:
+
+benchmark_with_profiler(streamed=True, pinned=True)
+
+######################################################################
+#
+# .. figure:: /_static/img/pinmem/trace_streamed1_pinned1.png
+#    :alt:
+#
+# A PyTorch perspective
+# ---------------------
+#
+#   .. _pinned_memory_pt_perspective:
+#
+# ``pin_memory()``
+# ~~~~~~~~~~~~~~~~
+#
+#   .. _pinned_memory_pinned:
+#
+# PyTorch offers the possibility to create and send tensors to page-locked memory through the
+# :meth:`~torch.Tensor.pin_memory` method and constructor arguments.
+# CPU tensors on a machine where CUDA is initialized can be cast to pinned memory through the :meth:`~torch.Tensor.pin_memory`
+# method. Importantly, ``pin_memory`` is blocking on the main thread of the host: it will wait for the tensor to be copied to
+# page-locked memory before executing the next operation.
+# New tensors can be directly created in pinned memory with functions like :func:`~torch.zeros`, :func:`~torch.ones` and other
+# constructors.
+#
+# Let us check the speed of pinning memory and sending tensors to CUDA:
+
+
+import torch
+import gc
+from torch.utils.benchmark import Timer
+import matplotlib.pyplot as plt
+
+
+def timer(cmd):
+    median = (
+        Timer(cmd, globals=globals())
+        .adaptive_autorange(min_run_time=1.0, max_run_time=20.0)
+        .median
+        * 1000
+    )
+    print(f"{cmd}: {median: 4.4f} ms")
+    return median
+
+
+# A tensor in pageable memory
+pageable_tensor = torch.randn(1_000_000)
+
+# A tensor in page-locked (pinned) memory
+pinned_tensor = torch.randn(1_000_000, pin_memory=True)
+
+# Runtimes:
+pageable_to_device = timer("pageable_tensor.to('cuda:0')")
+pinned_to_device = timer("pinned_tensor.to('cuda:0')")
+pin_mem = timer("pageable_tensor.pin_memory()")
+pin_mem_to_device = timer("pageable_tensor.pin_memory().to('cuda:0')")
+
+# Ratios:
+r1 = pinned_to_device / pageable_to_device
+r2 = pin_mem_to_device / pageable_to_device
+
+# Create a figure with the results
+fig, ax = plt.subplots()
+
+xlabels = [0, 1, 2]
+bar_labels = [
+    "pageable_tensor.to(device) (1x)",
+    f"pinned_tensor.to(device) ({r1:4.2f}x)",
+    f"pageable_tensor.pin_memory().to(device) ({r2:4.2f}x)"
+    f"\npin_memory()={100*pin_mem/pin_mem_to_device:.2f}% of runtime.",
+]
+values = [pageable_to_device, pinned_to_device, pin_mem_to_device]
+colors = ["tab:blue", "tab:red", "tab:orange"]
+ax.bar(xlabels, values, label=bar_labels, color=colors)
+
+ax.set_ylabel("Runtime (ms)")
+ax.set_title("Device casting runtime (pin-memory)")
+ax.set_xticks([])
+ax.legend()
+
+plt.show()
+
+# Clear tensors
+del pageable_tensor, pinned_tensor
+_ = gc.collect()
+
+######################################################################
+#
+# We can observe that casting a pinned-memory tensor to GPU is indeed much faster than a pageable tensor, because under
+# the hood, a pageable tensor must be copied to pinned memory before being sent to GPU.
+#
+# However, contrary to a somewhat common belief, calling :meth:`~torch.Tensor.pin_memory()` on a pageable tensor before
+# casting it to GPU should not bring any significant speed-up, on the contrary this call is usually slower than just
+# executing the transfer. This makes sense, since we're actually asking Python to execute an operation that CUDA will
+# perform anyway before copying the data from host to device.
+#
+# .. note:: The PyTorch implementation of
+#   `pin_memory <https://github.com/pytorch/pytorch/blob/5298acb5c76855bc5a99ae10016efc86b27949bd/aten/src/ATen/native/Memory.cpp#L58>`_
+#   which relies on creating a brand new storage in pinned memory through `cudaHostAlloc <https://docs.nvidia.com/cuda/cuda-runtime-api/group__CUDART__MEMORY.html#group__CUDART__MEMORY_1gb65da58f444e7230d3322b6126bb4902>`_
+#   could be, in rare cases, faster than transitioning data in chunks as ``cudaMemcpy`` does.
+#   Here too, the observation may vary depending on the available hardware, the size of the tensors being sent or
+#   the amount of available RAM.
+#
+# ``non_blocking=True``
+# ~~~~~~~~~~~~~~~~~~~~~
+#
+#   .. _pinned_memory_non_blocking:
+#
+# As mentioned earlier, many PyTorch operations have the option of being executed asynchronously with respect to the host
+# through the ``non_blocking`` argument.
+#
+# Here, to account accurately of the benefits of using ``non_blocking``, we will design a slightly more complex
+# experiment since we want to assess how fast it is to send multiple tensors to GPU with and without calling
+# ``non_blocking``.
+#
+
+
+# A simple loop that copies all tensors to cuda
+def copy_to_device(*tensors):
+    result = []
+    for tensor in tensors:
+        result.append(tensor.to("cuda:0"))
+    return result
+
+
+# A loop that copies all tensors to cuda asynchronously
+def copy_to_device_nonblocking(*tensors):
+    result = []
+    for tensor in tensors:
+        result.append(tensor.to("cuda:0", non_blocking=True))
+    # We need to synchronize
+    torch.cuda.synchronize()
+    return result
+
+
+# Create a list of tensors
+tensors = [torch.randn(1000) for _ in range(1000)]
+to_device = timer("copy_to_device(*tensors)")
+to_device_nonblocking = timer("copy_to_device_nonblocking(*tensors)")
+
+# Ratio
+r1 = to_device_nonblocking / to_device
+
+# Plot the results
+fig, ax = plt.subplots()
+
+xlabels = [0, 1]
+bar_labels = [f"to(device) (1x)", f"to(device, non_blocking=True) ({r1:4.2f}x)"]
+colors = ["tab:blue", "tab:red"]
+values = [to_device, to_device_nonblocking]
+
+ax.bar(xlabels, values, label=bar_labels, color=colors)
+
+ax.set_ylabel("Runtime (ms)")
+ax.set_title("Device casting runtime (non-blocking)")
+ax.set_xticks([])
+ax.legend()
+
+plt.show()
+
+
+######################################################################
+# To get a better sense of what is happening here, let us profile these two functions:
+
+
+from torch.profiler import profile, ProfilerActivity
+
+
+def profile_mem(cmd):
+    with profile(activities=[ProfilerActivity.CPU]) as prof:
+        exec(cmd)
+    print(cmd)
+    print(prof.key_averages().table(row_limit=10))
+
+
+######################################################################
+# Let's see the call stack with a regular ``to(device)`` first:
+#
+
+print("Call to `to(device)`", profile_mem("copy_to_device(*tensors)"))
+
+######################################################################
+# and now the ``non_blocking`` version:
+#
+
+print(
+    "Call to `to(device, non_blocking=True)`",
+    profile_mem("copy_to_device_nonblocking(*tensors)"),
+)
+
+
+######################################################################
+# The results are without any doubt better when using ``non_blocking=True``, as all transfers are initiated simultaneously
+# on the host side and only one synchronization is done.
+#
+# The benefit will vary depending on the number and the size of the tensors as well as depending on the hardware being
+# used.
+#
+# .. note:: Interestingly, the blocking ``to("cuda")`` actually performs the same asynchronous device casting operation
+#   (``cudaMemcpyAsync``) as the one with ``non_blocking=True`` with a synchronization point after each copy.
+#
+# Synergies
+# ~~~~~~~~~
+#
+#   .. _pinned_memory_synergies:
+#
+# Now that we have made the point that data transfer of tensors already in pinned memory to GPU is faster than from
+# pageable memory, and that we know that doing these transfers asynchronously is also faster than synchronously, we can
+# benchmark combinations of these approaches. First, let's write a couple of new functions that will call ``pin_memory``
+# and ``to(device)`` on each tensor:
+#
+
+
+def pin_copy_to_device(*tensors):
+    result = []
+    for tensor in tensors:
+        result.append(tensor.pin_memory().to("cuda:0"))
+    return result
+
+
+def pin_copy_to_device_nonblocking(*tensors):
+    result = []
+    for tensor in tensors:
+        result.append(tensor.pin_memory().to("cuda:0", non_blocking=True))
+    # We need to synchronize
+    torch.cuda.synchronize()
+    return result
+
+
+######################################################################
+# The benefits of using :meth:`~torch.Tensor.pin_memory` are more pronounced for
+# somewhat large batches of large tensors:
+#
+
+tensors = [torch.randn(1_000_000) for _ in range(1000)]
+page_copy = timer("copy_to_device(*tensors)")
+page_copy_nb = timer("copy_to_device_nonblocking(*tensors)")
+
+tensors_pinned = [torch.randn(1_000_000, pin_memory=True) for _ in range(1000)]
+pinned_copy = timer("copy_to_device(*tensors_pinned)")
+pinned_copy_nb = timer("copy_to_device_nonblocking(*tensors_pinned)")
+
+pin_and_copy = timer("pin_copy_to_device(*tensors)")
+pin_and_copy_nb = timer("pin_copy_to_device_nonblocking(*tensors)")
+
+# Plot
+strategies = ("pageable copy", "pinned copy", "pin and copy")
+blocking = {
+    "blocking": [page_copy, pinned_copy, pin_and_copy],
+    "non-blocking": [page_copy_nb, pinned_copy_nb, pin_and_copy_nb],
+}
+
+x = torch.arange(3)
+width = 0.25
+multiplier = 0
+
+
+fig, ax = plt.subplots(layout="constrained")
+
+for attribute, runtimes in blocking.items():
+    offset = width * multiplier
+    rects = ax.bar(x + offset, runtimes, width, label=attribute)
+    ax.bar_label(rects, padding=3, fmt="%.2f")
+    multiplier += 1
+
+# Add some text for labels, title and custom x-axis tick labels, etc.
+ax.set_ylabel("Runtime (ms)")
+ax.set_title("Runtime (pin-mem and non-blocking)")
+ax.set_xticks([0, 1, 2])
+ax.set_xticklabels(strategies)
+plt.setp(ax.get_xticklabels(), rotation=45, ha="right", rotation_mode="anchor")
+ax.legend(loc="upper left", ncols=3)
+
+plt.show()
+
+del tensors, tensors_pinned
+_ = gc.collect()
+
+
+######################################################################
+# Other copy directions (GPU -> CPU, CPU -> MPS)
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+#   .. _pinned_memory_other_direction:
+#
+# Until now, we have operated under the assumption that asynchronous copies from the CPU to the GPU are safe.
+# This is generally true because CUDA automatically handles synchronization to ensure that the data being accessed is
+# valid at read time __whenever the tensor is in pageable memory__.
+#
+# However, in other cases we cannot make the same assumption: when a tensor is placed in pinned memory, mutating the
+# original copy after calling the host-to-device transfer may corrupt the data received on GPU.
+# Similarly, when a transfer is achieved in the opposite direction, from GPU to CPU, or from any device that is not CPU
+# or GPU to any device that is not a CUDA-handled GPU (such as, MPS), there is no guarantee that the data read on GPU is
+# valid without explicit synchronization.
+#
+# In these scenarios, these transfers offer no assurance that the copy will be complete at the time of
+# data access. Consequently, the data on the host might be incomplete or incorrect, effectively rendering it garbage.
+#
+# Let's first demonstrate this with a pinned-memory tensor:
+DELAY = 100000000
+try:
+    i = -1
+    for i in range(100):
+        # Create a tensor in pin-memory
+        cpu_tensor = torch.ones(1024, 1024, pin_memory=True)
+        torch.cuda.synchronize()
+        # Send the tensor to CUDA
+        cuda_tensor = cpu_tensor.to("cuda", non_blocking=True)
+        torch.cuda._sleep(DELAY)
+        # Corrupt the original tensor
+        cpu_tensor.zero_()
+        assert (cuda_tensor == 1).all()
+    print("No test failed with non_blocking and pinned tensor")
+except AssertionError:
+    print(f"{i}th test failed with non_blocking and pinned tensor. Skipping remaining tests")
+
+######################################################################
+# Using a pageable tensor always works:
+#
+
+i = -1
+for i in range(100):
+    # Create a tensor in pageable memory
+    cpu_tensor = torch.ones(1024, 1024)
+    torch.cuda.synchronize()
+    # Send the tensor to CUDA
+    cuda_tensor = cpu_tensor.to("cuda", non_blocking=True)
+    torch.cuda._sleep(DELAY)
+    # Corrupt the original tensor
+    cpu_tensor.zero_()
+    assert (cuda_tensor == 1).all()
+print("No test failed with non_blocking and pageable tensor")
+
+######################################################################
+# Now let's demonstrate that CUDA to CPU also fails to produce reliable outputs without synchronization:
+
+tensor = (
+    torch.arange(1, 1_000_000, dtype=torch.double, device="cuda")
+    .expand(100, 999999)
+    .clone()
+)
+torch.testing.assert_close(
+    tensor.mean(), torch.tensor(500_000, dtype=torch.double, device="cuda")
+), tensor.mean()
+try:
+    i = -1
+    for i in range(100):
+        cpu_tensor = tensor.to("cpu", non_blocking=True)
+        torch.testing.assert_close(
+            cpu_tensor.mean(), torch.tensor(500_000, dtype=torch.double)
+        )
+    print("No test failed with non_blocking")
+except AssertionError:
+    print(f"{i}th test failed with non_blocking. Skipping remaining tests")
+try:
+    i = -1
+    for i in range(100):
+        cpu_tensor = tensor.to("cpu", non_blocking=True)
+        torch.cuda.synchronize()
+        torch.testing.assert_close(
+            cpu_tensor.mean(), torch.tensor(500_000, dtype=torch.double)
+        )
+    print("No test failed with synchronize")
+except AssertionError:
+    print(f"One test failed with synchronize: {i}th assertion!")
+
+
+######################################################################
+# Generally, asynchronous copies to a device are safe without explicit synchronization only when the target is a
+# CUDA-enabled device and the original tensor is in pageable memory.
+#
+# In summary, copying data from CPU to GPU is safe when using ``non_blocking=True``, but for any other direction,
+# ``non_blocking=True`` can still be used but the user must make sure that a device synchronization is executed before
+# the data is accessed.
+#
+# Practical recommendations
+# -------------------------
+#
+#   .. _pinned_memory_recommendations:
+#
+# We can now wrap up some early recommendations based on our observations:
+#
+# In general, ``non_blocking=True`` will provide good throughput, regardless of whether the original tensor is or
+# isn't in pinned memory.
+# If the tensor is already in pinned memory, the transfer can be accelerated, but sending it to
+# pin memory manually from python main thread is a blocking operation on the host, and hence will annihilate much of
+# the benefit of using ``non_blocking=True`` (as CUDA does the `pin_memory` transfer anyway).
+#
+# One might now legitimately ask what use there is for the :meth:`~torch.Tensor.pin_memory` method.
+# In the following section, we will explore further how this can be used to accelerate the data transfer even more.
+#
+# Additional considerations
+# -------------------------
+#
+#   .. _pinned_memory_considerations:
+#
+# PyTorch notoriously provides a :class:`~torch.utils.data.DataLoader` class whose constructor accepts a
+# ``pin_memory`` argument.
+# Considering our previous discussion on ``pin_memory``, you might wonder how the ``DataLoader`` manages to
+# accelerate data transfers if memory pinning is inherently blocking.
+#
+# The key lies in the DataLoader's use of a separate thread to handle the transfer of data from pageable to pinned
+# memory, thus preventing any blockage in the main thread.
+#
+# To illustrate this, we will use the TensorDict primitive from the homonymous library.
+# When invoking :meth:`~tensordict.TensorDict.to`, the default behavior is to send tensors to the device asynchronously,
+# followed by a single call to ``torch.device.synchronize()`` afterwards.
+#
+# Additionally, ``TensorDict.to()`` includes a ``non_blocking_pin`` option  which initiates multiple threads to execute
+# ``pin_memory()`` before proceeding with to ``to(device)``.
+# This approach can further accelerate data transfers, as demonstrated in the following example.
+#
+#
+
+from tensordict import TensorDict
+import torch
+from torch.utils.benchmark import Timer
+import matplotlib.pyplot as plt
+
+# Create the dataset
+td = TensorDict({str(i): torch.randn(1_000_000) for i in range(1000)})
+
+# Runtimes
+copy_blocking = timer("td.to('cuda:0', non_blocking=False)")
+copy_non_blocking = timer("td.to('cuda:0')")
+copy_pin_nb = timer("td.to('cuda:0', non_blocking_pin=True, num_threads=0)")
+copy_pin_multithread_nb = timer("td.to('cuda:0', non_blocking_pin=True, num_threads=4)")
+
+# Rations
+r1 = copy_non_blocking / copy_blocking
+r2 = copy_pin_nb / copy_blocking
+r3 = copy_pin_multithread_nb / copy_blocking
+
+# Figure
+fig, ax = plt.subplots()
+
+xlabels = [0, 1, 2, 3]
+bar_labels = [
+    "Blocking copy (1x)",
+    f"Non-blocking copy ({r1:4.2f}x)",
+    f"Blocking pin, non-blocking copy ({r2:4.2f}x)",
+    f"Non-blocking pin, non-blocking copy ({r3:4.2f}x)",
+]
+values = [copy_blocking, copy_non_blocking, copy_pin_nb, copy_pin_multithread_nb]
+colors = ["tab:blue", "tab:red", "tab:orange", "tab:green"]
+
+ax.bar(xlabels, values, label=bar_labels, color=colors)
+
+ax.set_ylabel("Runtime (ms)")
+ax.set_title("Device casting runtime")
+ax.set_xticks([])
+ax.legend()
+
+plt.show()
+
+######################################################################
+# In this example, we are transferring many large tensors from the CPU to the GPU.
+# This scenario is ideal for utilizing multithreaded ``pin_memory()``, which can significantly enhance performance.
+# However, if the tensors are small, the overhead associated with multithreading may outweigh the benefits.
+# Similarly, if there are only a few tensors, the advantages of pinning tensors on separate threads become limited.
+#
+# As an additional note, while it might seem advantageous to create permanent buffers in pinned memory to shuttle
+# tensors from pageable memory before transferring them to the GPU, this strategy does not necessarily expedite
+# computation. The inherent bottleneck caused by copying data into pinned memory remains a limiting factor.
+#
+# Moreover, transferring data that resides on disk (whether in shared memory or files) to the GPU typically requires an
+# intermediate step of copying the data into pinned memory (located in RAM).
+# Utilizing non_blocking for large data transfers in this context can significantly increase RAM consumption,
+# potentially leading to adverse effects.
+#
+# In practice, there is no one-size-fits-all solution.
+# The effectiveness of using multithreaded ``pin_memory`` combined with ``non_blocking`` transfers depends on a
+# variety of  factors, including the specific system, operating system, hardware, and the nature of the tasks
+# being executed.
+# Here is a list of factors to check when trying to speed-up data transfers between CPU and GPU, or comparing
+# throughput's across scenarios:
+#
+# - **Number of available cores**
+#
+#   How many CPU cores are available? Is the system shared with other users or processes that might compete for
+#   resources?
+#
+# - **Core utilization**
+#
+#   Are the CPU cores heavily utilized by other processes? Does the application perform other CPU-intensive tasks
+#   concurrently with data transfers?
+#
+# - **Memory utilization**
+#
+#   How much pageable and page-locked memory is currently being used? Is there sufficient free memory to allocate
+#   additional pinned memory without affecting system performance? Remember that nothing comes for free, for instance
+#   ``pin_memory`` will consume RAM and may impact other tasks.
+#
+# - **CUDA Device Capabilities**
+#
+#   Does the GPU support multiple DMA engines for concurrent data transfers? What are the specific capabilities and
+#   limitations of the CUDA device being used?
+#
+# - **Number of tensors to be sent**
+#
+#   How many tensors are transferred in a typical operation?
+#
+# - **Size of the tensors to be sent**
+#
+#   What is the size of the tensors being transferred? A few large tensors or many small tensors may not benefit from
+#   the same transfer program.
+#
+# - **System Architecture**
+#
+#   How is the system's architecture influencing data transfer speeds (for example, bus speeds, network latency)?
+#
+# Additionally, allocating a large number of tensors or sizable tensors in pinned memory can monopolize a substantial
+# portion of RAM.
+# This reduces the available memory for other critical operations, such as paging, which can negatively impact the
+# overall performance of an algorithm.
+#
+# Conclusion
+# ----------
+#
+#   .. _pinned_memory_conclusion:
+#
+# Throughout this tutorial, we have explored several critical factors that influence transfer speeds and memory
+# management when sending tensors from the host to the device. We've learned that using ``non_blocking=True`` generally
+# accelerates data transfers, and that :meth:`~torch.Tensor.pin_memory` can also enhance performance if implemented
+# correctly. However, these techniques require careful design and calibration to be effective.
+#
+# Remember that profiling your code and keeping an eye on the memory consumption are essential to optimize resource
+# usage and achieve the best possible performance.
+#
+# Additional resources
+# --------------------
+#
+#   .. _pinned_memory_resources:
+#
+# If you are dealing with issues with memory copies when using CUDA devices or want to learn more about
+# what was discussed in this tutorial, check the following references:
+#
+# - `CUDA toolkit memory management doc <https://docs.nvidia.com/cuda/cuda-runtime-api/group__CUDART__MEMORY.html>`_;
+# - `CUDA pin-memory note <https://forums.developer.nvidia.com/t/pinned-memory/268474>`_;
+# - `How to Optimize Data Transfers in CUDA C/C++ <https://developer.nvidia.com/blog/how-optimize-data-transfers-cuda-cc/>`_;
+# - `tensordict doc <https://pytorch.org/tensordict/stable/index.html>`_ and `repo <https://github.com/pytorch/tensordict>`_.
+#
diff --git a/intermediate_source/pipeline_tutorial.rst b/intermediate_source/pipeline_tutorial.rst
new file mode 100644
index 00000000000..06f10a4a884
--- /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/pipelining_tutorial.rst b/intermediate_source/pipelining_tutorial.rst
new file mode 100644
index 00000000000..36738011a40
--- /dev/null
+++ b/intermediate_source/pipelining_tutorial.rst
@@ -0,0 +1,240 @@
+Introduction to Distributed Pipeline Parallelism
+================================================
+**Authors**: `Howard Huang <https://github.com/H-Huang>`_
+
+.. note::
+   |edit| View and edit this tutorial in `github <https://github.com/pytorch/tutorials/blob/main/intermediate_source/pipelining_tutorial.rst>`__.
+
+This tutorial uses a gpt-style transformer model to demonstrate implementing distributed
+pipeline parallelism with `torch.distributed.pipelining <https://pytorch.org/docs/main/distributed.pipelining.html>`__
+APIs.
+
+.. grid:: 2
+
+   .. grid-item-card:: :octicon:`mortar-board;1em;` What you will learn
+      :class-card: card-prerequisites
+
+      *  How to use ``torch.distributed.pipelining`` APIs
+      *  How to apply pipeline parallelism to a transformer model
+      *  How to utilize different schedules on a set of microbatches
+
+
+   .. grid-item-card:: :octicon:`list-unordered;1em;` Prerequisites
+      :class-card: card-prerequisites
+
+      * Familiarity with `basic distributed training  <https://pytorch.org/tutorials/beginner/dist_overview.html>`__ in PyTorch
+
+Setup
+-----
+
+With ``torch.distributed.pipelining`` we will be partitioning the execution of a model and scheduling computation on micro-batches. We will be using a simplified version
+of a transformer decoder model. The model architecture is for educational purposes and has multiple transformer decoder layers as we want to demonstrate how to split the model into different
+chunks. First, let us define the model:
+
+.. code:: python
+
+   import torch
+   import torch.nn as nn
+   from dataclasses import dataclass
+
+   @dataclass
+   class ModelArgs:
+      dim: int = 512
+      n_layers: int = 8
+      n_heads: int = 8
+      vocab_size: int = 10000
+
+   class Transformer(nn.Module):
+      def __init__(self, model_args: ModelArgs):
+         super().__init__()
+
+         self.tok_embeddings = nn.Embedding(model_args.vocab_size, model_args.dim)
+
+         # Using a ModuleDict lets us delete layers witout affecting names,
+         # ensuring checkpoints will correctly save and load.
+         self.layers = torch.nn.ModuleDict()
+         for layer_id in range(model_args.n_layers):
+               self.layers[str(layer_id)] = nn.TransformerDecoderLayer(model_args.dim, model_args.n_heads)
+
+         self.norm = nn.LayerNorm(model_args.dim)
+         self.output = nn.Linear(model_args.dim, model_args.vocab_size)
+
+      def forward(self, tokens: torch.Tensor):
+         # Handling layers being 'None' at runtime enables easy pipeline splitting
+         h = self.tok_embeddings(tokens) if self.tok_embeddings else tokens
+
+         for layer in self.layers.values():
+               h = layer(h, h)
+
+         h = self.norm(h) if self.norm else h
+         output = self.output(h).clone() if self.output else h
+         return output
+
+Then, we need to import the necessary libraries in our script and initialize the distributed training process. In this case, we are defining some global variables to use
+later in the script:
+
+.. code:: python
+
+   import os
+   import torch.distributed as dist
+   from torch.distributed.pipelining import pipeline, SplitPoint, PipelineStage, ScheduleGPipe
+
+   global rank, device, pp_group, stage_index, num_stages
+   def init_distributed():
+      global rank, device, pp_group, stage_index, num_stages
+      rank = int(os.environ["LOCAL_RANK"])
+      world_size = int(os.environ["WORLD_SIZE"])
+      device = torch.device(f"cuda:{rank}") if torch.cuda.is_available() else torch.device("cpu")
+      dist.init_process_group()
+
+      # This group can be a sub-group in the N-D parallel case
+      pp_group = dist.new_group()
+      stage_index = rank
+      num_stages = world_size
+
+The ``rank``, ``world_size``, and ``init_process_group()`` code should seem familiar to you as those are commonly used in
+all distributed programs. The globals specific to pipeline parallelism include ``pp_group`` which is the process
+group that will be used for send/recv communications, ``stage_index`` which, in this example, is a single rank
+per stage so the index is equivalent to the rank, and ``num_stages`` which is equivalent to world_size.
+
+The ``num_stages`` is used to set the number of stages that will be used in the pipeline parallelism schedule. For example,
+for ``num_stages=4``, a microbatch will need to go through 4 forwards and 4 backwards before it is completed. The ``stage_index``
+is necessary for the framework to know how to communicate between stages. For example, for the first stage (``stage_index=0``), it will
+use data from the dataloader and does not need to receive data from any previous peers to perform its computation.
+
+
+Step 1: Partition the Transformer Model
+---------------------------------------
+
+There are two different ways of partitioning the model:
+
+First is the manual mode in which we can manually create two instances of the model by deleting portions of
+attributes of the model. In this example for two stages (2 ranks), the model is cut in half.
+
+.. code:: python
+
+   def manual_model_split(model) -> PipelineStage:
+      if stage_index == 0:
+         # prepare the first stage model
+         for i in range(4, 8):
+               del model.layers[str(i)]
+         model.norm = None
+         model.output = None
+
+      elif stage_index == 1:
+         # prepare the second stage model
+         for i in range(4):
+               del model.layers[str(i)]
+         model.tok_embeddings = None
+
+      stage = PipelineStage(
+         model,
+         stage_index,
+         num_stages,
+         device,
+      )
+      return stage
+
+As we can see the first stage does not have the layer norm or the output layer, and it only includes the first four transformer blocks.
+The second stage does not have the input embedding layers, but includes the output layers and the final four transformer blocks. The function
+then returns the ``PipelineStage`` for the current rank.
+
+The second method is the tracer-based mode which automatically splits the model based on a ``split_spec`` argument. Using the pipeline specification, we can instruct
+``torch.distributed.pipelining`` where to split the model. In the following code block,
+we are splitting before the before 4th transformer decoder layer, mirroring the manual split described above. Similarly,
+we can retrieve a ``PipelineStage`` by calling ``build_stage`` after this splitting is done.
+
+.. code:: python
+   def tracer_model_split(model, example_input_microbatch) -> PipelineStage:
+      pipe = pipeline(
+         module=model,
+         mb_args=(example_input_microbatch,),
+         split_spec={
+            "layers.4": SplitPoint.BEGINNING,
+         }
+      )
+      stage = pipe.build_stage(stage_index, device, pp_group)
+      return stage
+
+
+Step 2: Define The Main Execution
+---------------------------------
+
+In the main function we will create a particular pipeline schedule that the stages should follow. ``torch.distributed.pipelining``
+supports multiple schedules including supports multiple schedules, including single-stage-per-rank schedules ``GPipe`` and ``1F1B``,
+as well as multiple-stage-per-rank schedules such as ``Interleaved1F1B`` and ``LoopedBFS``.
+
+.. code:: python
+
+   if __name__ == "__main__":
+      init_distributed()
+      num_microbatches = 4
+      model_args = ModelArgs()
+      model = Transformer(model_args)
+
+      # Dummy data
+      x = torch.ones(32, 500, dtype=torch.long)
+      y = torch.randint(0, model_args.vocab_size, (32, 500), dtype=torch.long)
+      example_input_microbatch = x.chunk(num_microbatches)[0]
+
+      # Option 1: Manual model splitting
+      stage = manual_model_split(model)
+
+      # Option 2: Tracer model splitting
+      # stage = tracer_model_split(model, example_input_microbatch)
+
+      model.to(device)
+      x = x.to(device)
+      y = y.to(device)
+
+      def tokenwise_loss_fn(outputs, targets):
+         loss_fn = nn.CrossEntropyLoss()
+         outputs = outputs.reshape(-1, model_args.vocab_size)
+         targets = targets.reshape(-1)
+         return loss_fn(outputs, targets)
+
+      schedule = ScheduleGPipe(stage, n_microbatches=num_microbatches, loss_fn=tokenwise_loss_fn)
+
+      if rank == 0:
+         schedule.step(x)
+      elif rank == 1:
+         losses = []
+         output = schedule.step(target=y, losses=losses)
+         print(f"losses: {losses}")
+      dist.destroy_process_group()
+
+In the example above, we are using the manual method to split the model, but the code can be uncommented to also try the
+tracer-based model splitting function. In our schedule, we need to pass in the number of microbatches and
+the loss function used to evaluate the targets.
+
+The ``.step()`` function processes the entire minibatch and automatically splits it into microbatches based
+on the ``n_microbatches`` passed previously. The microbatches are then operated on according to the schedule class.
+In the example above, we are using GPipe, which follows a simple all-forwards and then all-backwards schedule. The output
+returned from rank 1 will be the same as if the model was on a single GPU and run with the entire batch. Similarly,
+we can pass in a ``losses`` container to store the corresponding losses for each microbatch.
+
+Step 3: Launch the Distributed Processes
+----------------------------------------
+
+Finally, we are ready to run the script. We will use ``torchrun`` to create a single host, 2-process job.
+Our script is already written in a way rank 0 that performs the required logic for pipeline stage 0, and rank 1
+performs the logic for pipeline stage 1.
+
+``torchrun --nnodes 1 --nproc_per_node 2 pipelining_tutorial.py``
+
+Conclusion
+----------
+
+In this tutorial, we have learned how to implement distributed pipeline parallelism using PyTorch's ``torch.distributed.pipelining`` APIs.
+We explored setting up the environment, defining a transformer model, and partitioning it for distributed training.
+We discussed two methods of model partitioning, manual and tracer-based, and demonstrated how to schedule computations on
+micro-batches across different stages. Finally, we covered the execution of the pipeline schedule and the launch of distributed
+processes using ``torchrun``.
+
+Additional Resources
+--------------------
+
+We have successfully integrated ``torch.distributed.pipelining`` into the `torchtitan repository <https://github.com/pytorch/torchtitan>`__. TorchTitan is a clean, minimal code base for
+large-scale LLM training using native PyTorch. For a production ready usage of pipeline
+parallelism as well as composition with other distributed techniques, see
+`TorchTitan end to end example of 3D parallelism <https://github.com/pytorch/torchtitan>`__.
diff --git a/intermediate_source/process_group_cpp_extension_tutorial.rst b/intermediate_source/process_group_cpp_extension_tutorial.rst
new file mode 100644
index 00000000000..3c72a9e319b
--- /dev/null
+++ b/intermediate_source/process_group_cpp_extension_tutorial.rst
@@ -0,0 +1,306 @@
+Customize Process Group Backends Using Cpp Extensions
+=====================================================
+
+**Author**: `Howard Huang <https://github.com/H-Huang>`__, `Feng Tian <https://github.com/ftian1>`__, `Shen Li <https://mrshenli.github.io/>`__, `Min Si <https://minsii.github.io/>`__
+
+.. note::
+   |edit| View and edit this tutorial in `github <https://github.com/pytorch/tutorials/blob/main/intermediate_source/process_group_cpp_extension_tutorial.rst>`__.
+
+Prerequisites:
+
+-  `PyTorch Distributed Overview <../beginner/dist_overview.html>`__
+-  `PyTorch Collective Communication Package <https://pytorch.org/docs/stable/distributed.html>`__
+-  `PyTorch Cpp Extension <https://pytorch.org/docs/stable/cpp_extension.html>`__
+-  `Writing Distributed Applications with PyTorch <https://pytorch.org/tutorials/intermediate/dist_tuto.html>`__
+
+This tutorial demonstrates how to implement a custom ``Backend`` and plug that into
+`PyTorch distributed package <https://pytorch.org/docs/stable/distributed.html>`__ using
+`cpp extensions <https://pytorch.org/docs/stable/cpp_extension.html>`__. This is helpful when you need a specialized software
+stack for your hardware, or when you would like to experiment with new
+collective communication algorithms.
+
+
+Basics
+------
+
+PyTorch collective communications power several widely adopted distributed
+training features, including
+`DistributedDataParallel <https://pytorch.org/docs/stable/generated/torch.nn.parallel.DistributedDataParallel.html>`__ and
+`ZeroRedundancyOptimizer <https://pytorch.org/docs/stable/distributed.optim.html#torch.distributed.optim.ZeroRedundancyOptimizer>`__.
+In order to make the same collective communication API work with
+different communication backends, the distributed package abstracts collective
+communication operations into a
+`Backend <https://github.com/pytorch/pytorch/blob/main/torch/csrc/distributed/c10d/Backend.hpp>`__
+class. Different backends can
+then be implemented as subclasses of ``Backend`` using preferred
+third-party libraries. PyTorch distributed comes with three default backends,
+``ProcessGroupNCCL``, ``ProcessGroupGloo``, and ``ProcessGroupMPI``. However,
+beyond these three backends, there are also other communication libraries
+(e.g., `UCC <https://github.com/openucx/ucc>`__,
+`OneCCL <https://github.com/oneapi-src/oneCCL>`__), different types of hardware
+(e.g., `TPU <https://cloud.google.com/tpu>`__,
+`Trainum <https://aws.amazon.com/machine-learning/trainium/>`__), and emerging
+communication algorithms (e.g.,
+`Herring <https://www.amazon.science/publications/herring-rethinking-the-parameter-server-at-scale-for-the-cloud>`__,
+`Reduction Server <https://cloud.google.com/blog/topics/developers-practitioners/optimize-training-performance-reduction-server-vertex-ai>`__).
+Therefore, the distributed package exposes extension APIs to allow customizing
+collective communication backends.
+
+
+The 4 steps below show how to implement a dummy ``Backend`` backend
+and use that in Python application code. Please note that this tutorial focuses
+on demonstrating the extension APIs, instead of developing a functioning
+communication backend. Hence, the ``dummy`` backend just covers a subset of the
+APIs (``all_reduce`` and ``all_gather``), and simply sets the values of tensors
+to 0.
+
+
+Step 1: Implement a Subclass of ``Backend``
+------------------------------------------------
+
+This first step is to implement a ``Backend`` subclass that overrides
+target collective communication APIs and runs the custom communication algorithm.
+The extension also needs to implement a ``Work`` subclass, which
+serves as a future of communication results and allows asynchronous execution in
+application code. If the extension uses third-party libraries, it can
+include the headers and call into the library APIs from the ``BackendDummy``
+subclass. The two code snippets below present the implementation of ``dummy.h`` and
+``dummy.cpp``. See the `dummy collectives <https://github.com/H-Huang/torch_collective_extension>`__
+repository for the full implementation.
+
+.. code-block:: cpp
+
+    // file name: dummy.hpp
+    #include <torch/python.h>
+
+    #include <torch/csrc/distributed/c10d/Backend.hpp>
+    #include <torch/csrc/distributed/c10d/Work.hpp>
+    #include <torch/csrc/distributed/c10d/Store.hpp>
+    #include <torch/csrc/distributed/c10d/Types.hpp>
+    #include <torch/csrc/distributed/c10d/Utils.hpp>
+
+    #include <pybind11/chrono.h>
+
+    namespace c10d {
+
+    class BackendDummy : public Backend {
+      public:
+        BackendDummy(int rank, int size);
+
+        c10::intrusive_ptr<Work> allgather(
+            std::vector<std::vector<at::Tensor>>& outputTensors,
+            std::vector<at::Tensor>& inputTensors,
+            const AllgatherOptions& opts = AllgatherOptions()) override;
+
+        c10::intrusive_ptr<Work> allreduce(
+            std::vector<at::Tensor>& tensors,
+            const AllreduceOptions& opts = AllreduceOptions()) override;
+
+        // The collective communication APIs without a custom implementation
+        // will error out if invoked by application code.
+    };
+
+    class WorkDummy : public Work {
+      public:
+        WorkDummy(
+          OpType opType,
+          c10::intrusive_ptr<c10::ivalue::Future> future) // future of the output
+          : Work(
+              -1, // rank, only used by recvAnySource, irrelevant in this demo
+              opType),
+          future_(std::move(future)) {}
+        bool isCompleted() override;
+        bool isSuccess() const override;
+        bool wait(std::chrono::milliseconds timeout = kUnsetTimeout) override;
+        virtual c10::intrusive_ptr<c10::ivalue::Future> getFuture() override;
+
+      private:
+        c10::intrusive_ptr<c10::ivalue::Future> future_;
+    };
+    } // namespace c10d
+
+
+.. code-block:: cpp
+
+    // file name: dummy.cpp
+    #include "dummy.hpp"
+
+    namespace c10d {
+
+    // This is a dummy allgather that sets all output tensors to zero
+    // Modify the implementation to conduct real communication asynchronously
+    c10::intrusive_ptr<Work> BackendDummy::allgather(
+            std::vector<std::vector<at::Tensor>>& outputTensors,
+            std::vector<at::Tensor>& inputTensors,
+            const AllgatherOptions& /* unused */) {
+        for (auto& outputTensorVec : outputTensors) {
+            for (auto& outputTensor : outputTensorVec) {
+                outputTensor.zero_();
+            }
+        }
+
+        auto future = c10::make_intrusive<c10::ivalue::Future>(
+            c10::ListType::create(c10::ListType::create(c10::TensorType::get())));
+        future->markCompleted(c10::IValue(outputTensors));
+        return c10::make_intrusive<WorkDummy>(OpType::ALLGATHER, std::move(future));
+    }
+
+    // This is a dummy allreduce that sets all output tensors to zero
+    // Modify the implementation to conduct real communication asynchronously
+    c10::intrusive_ptr<Work> BackendDummy::allreduce(
+            std::vector<at::Tensor>& tensors,
+            const AllreduceOptions& opts) {
+        for (auto& tensor : tensors) {
+            tensor.zero_();
+        }
+
+        auto future = c10::make_intrusive<c10::ivalue::Future>(
+            c10::ListType::create(c10::TensorType::get()));
+        future->markCompleted(c10::IValue(tensors));
+        return c10::make_intrusive<WorkDummy>(OpType::ALLGATHER, std::move(future));
+    }
+    } // namespace c10d
+
+Step 2: Expose The Extension Python APIs
+----------------------------------------
+
+The backend constructors are called
+`from Python side <https://github.com/pytorch/pytorch/blob/v1.9.0/torch/distributed/distributed_c10d.py#L643-L650>`__,
+so the extension also needs to expose the constructor APIs to Python. This can
+be done by adding the following methods. In this example, ``store`` and
+``timeout`` are ignored by the ``BackendDummy`` instantiation method, as
+those are not used in this dummy implementation. However, real-world extensions
+should consider using the ``store`` to perform rendezvous and supporting the
+``timeout`` argument.
+
+.. code-block:: cpp
+
+    // file name: dummy.hpp
+    class BackendDummy : public Backend {
+        ...
+        <Step 1 code>
+        ...
+
+        static c10::intrusive_ptr<Backend> createBackendDummy(
+            const c10::intrusive_ptr<::c10d::Store>& store,
+            int rank,
+            int size,
+            const std::chrono::duration<float>& timeout);
+
+        static void BackendDummyConstructor() __attribute__((constructor)) {
+            py::object module = py::module::import("torch.distributed");
+            py::object register_backend =
+                module.attr("Backend").attr("register_backend");
+            // torch.distributed.Backend.register_backend will add `dummy` as a
+            // new valid backend.
+            register_backend("dummy", py::cpp_function(createBackendDummy));
+        }
+    }
+
+.. code-block:: cpp
+
+    // file name: dummy.cpp
+    c10::intrusive_ptr<Backend> BackendDummy::createBackendDummy(
+            const c10::intrusive_ptr<::c10d::Store>& /* unused */,
+            int rank,
+            int size,
+            const std::chrono::duration<float>& /* unused */) {
+        return c10::make_intrusive<BackendDummy>(rank, size);
+    }
+
+    PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
+        m.def("createBackendDummy", &BackendDummy::createBackendDummy);
+    }
+
+
+Step 3: Build The Custom Extension
+----------------------------------
+
+Now, the extension source code files are ready. We can then use
+`cpp extensions <https://pytorch.org/docs/stable/cpp_extension.html>`__
+to build it. To do that, create a ``setup.py`` file that prepares the paths and
+commands. Then call ``python setup.py develop`` to install the extension.
+
+If the extension depends on third-party libraries, you can also specify
+``libraries_dirs`` and ``libraries`` to the cpp extension APIs. See the
+`torch ucc <https://github.com/openucx/torch-ucc>`__
+project as a real-world example.
+
+.. code-block:: python
+
+    # file name: setup.py
+    import os
+    import sys
+    import torch
+    from setuptools import setup
+    from torch.utils import cpp_extension
+
+    sources = ["src/dummy.cpp"]
+    include_dirs = [f"{os.path.dirname(os.path.abspath(__file__))}/include/"]
+
+    if torch.cuda.is_available():
+        module = cpp_extension.CUDAExtension(
+            name = "dummy_collectives",
+            sources = sources,
+            include_dirs = include_dirs,
+        )
+    else:
+        module = cpp_extension.CppExtension(
+            name = "dummy_collectives",
+            sources = sources,
+            include_dirs = include_dirs,
+        )
+
+    setup(
+        name = "Dummy-Collectives",
+        version = "0.0.1",
+        ext_modules = [module],
+        cmdclass={'build_ext': cpp_extension.BuildExtension}
+    )
+
+Step 4: Use The Extension in Application
+----------------------------------------
+
+After installation, you can conveniently use the ``dummy`` backend when calling
+`init_process_group <https://pytorch.org/docs/stable/distributed.html#torch.distributed.init_process_group>`__
+as if it is an builtin backend.
+
+We can specify dispatching based on backend by changing the ``backend`` argument of ``init_process_group``. We
+can dispatch collective with CPU tensor to ``gloo`` backend and dispatch collective with CUDA tensor to ``dummy`` backend by
+specifying ``cpu:gloo,cuda:dummy`` as the backend argument.
+
+To send all tensors to ``dummy`` backend, we can simply specify ``dummy`` as the backend argument.
+
+.. code-block:: python
+
+    import os
+
+    import torch
+    # importing dummy_collectives makes torch.distributed recognize `dummy`
+    # as a valid backend.
+    import dummy_collectives
+
+    import torch.distributed as dist
+
+    os.environ['MASTER_ADDR'] = 'localhost'
+    os.environ['MASTER_PORT'] = '29500'
+
+    # Alternatively:
+    # dist.init_process_group("dummy", rank=0, world_size=1)
+    dist.init_process_group("cpu:gloo,cuda:dummy", rank=0, world_size=1)
+
+    # this goes through gloo
+    x = torch.ones(6)
+    dist.all_reduce(x)
+    print(f"cpu allreduce: {x}")
+
+    # this goes through dummy
+    if torch.cuda.is_available():
+        y = x.cuda()
+        dist.all_reduce(y)
+        print(f"cuda allreduce: {y}")
+
+        try:
+            dist.broadcast(y, 0)
+        except RuntimeError:
+            print("got RuntimeError when calling broadcast")
diff --git a/intermediate_source/pruning_tutorial.py b/intermediate_source/pruning_tutorial.py
new file mode 100644
index 00000000000..346200502d5
--- /dev/null
+++ b/intermediate_source/pruning_tutorial.py
@@ -0,0 +1,403 @@
+# -*- coding: utf-8 -*-
+"""
+Pruning Tutorial
+=====================================
+**Author**: `Michela Paganini <https://github.com/mickypaganini>`_
+
+State-of-the-art deep learning techniques rely on over-parametrized models 
+that are hard to deploy. On the contrary, biological neural networks are 
+known to use efficient sparse connectivity. Identifying optimal  
+techniques to compress models by reducing the number of parameters in them is 
+important in order to reduce memory, battery, and hardware consumption without 
+sacrificing accuracy. This in turn allows you to deploy lightweight models on device, and guarantee 
+privacy with private on-device computation. On the research front, pruning is 
+used to investigate the differences in learning dynamics between 
+over-parametrized and under-parametrized networks, to study the role of lucky 
+sparse subnetworks and initializations
+("`lottery tickets <https://arxiv.org/abs/1803.03635>`_") as a destructive 
+neural architecture search technique, and more.
+
+In this tutorial, you will learn how to use ``torch.nn.utils.prune`` to 
+sparsify your neural networks, and how to extend it to implement your 
+own custom pruning technique.
+
+Requirements
+------------
+``"torch>=1.4.0a0+8e8a5e0"``
+
+"""
+import torch
+from torch import nn
+import torch.nn.utils.prune as prune
+import torch.nn.functional as F
+
+######################################################################
+# Create a model
+# --------------
+#
+# In this tutorial, we use the `LeNet 
+# <http://yann.lecun.com/exdb/publis/pdf/lecun-98.pdf>`_ architecture from 
+# LeCun et al., 1998.
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+class LeNet(nn.Module):
+    def __init__(self):
+        super(LeNet, self).__init__()
+        # 1 input image channel, 6 output channels, 5x5 square conv kernel
+        self.conv1 = nn.Conv2d(1, 6, 5)
+        self.conv2 = nn.Conv2d(6, 16, 5)
+        self.fc1 = nn.Linear(16 * 5 * 5, 120)  # 5x5 image dimension
+        self.fc2 = nn.Linear(120, 84)
+        self.fc3 = nn.Linear(84, 10)
+
+    def forward(self, x):
+        x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
+        x = F.max_pool2d(F.relu(self.conv2(x)), 2)
+        x = x.view(-1, int(x.nelement() / x.shape[0]))
+        x = F.relu(self.fc1(x))
+        x = F.relu(self.fc2(x))
+        x = self.fc3(x)
+        return x
+
+model = LeNet().to(device=device)
+
+
+######################################################################
+# Inspect a Module
+# ----------------
+# 
+# Let's inspect the (unpruned) ``conv1`` layer in our LeNet model. It will contain two 
+# parameters ``weight`` and ``bias``, and no buffers, for now.
+module = model.conv1
+print(list(module.named_parameters()))
+
+######################################################################
+print(list(module.named_buffers()))
+
+######################################################################
+# Pruning a Module
+# ----------------
+# 
+# To prune a module (in this example, the ``conv1`` layer of our LeNet 
+# architecture), first select a pruning technique among those available in 
+# ``torch.nn.utils.prune`` (or
+# `implement <#extending-torch-nn-utils-pruning-with-custom-pruning-functions>`_
+# your own by subclassing 
+# ``BasePruningMethod``). Then, specify the module and the name of the parameter to 
+# prune within that module. Finally, using the adequate keyword arguments 
+# required by the selected pruning technique, specify the pruning parameters.
+#
+# In this example, we will prune at random 30% of the connections in 
+# the parameter named ``weight`` in the ``conv1`` layer.
+# The module is passed as the first argument to the function; ``name`` 
+# identifies the parameter within that module using its string identifier; and 
+# ``amount`` indicates either the percentage of connections to prune (if it 
+# is a float between 0. and 1.), or the absolute number of connections to 
+# prune (if it is a non-negative integer).
+prune.random_unstructured(module, name="weight", amount=0.3) 
+
+######################################################################
+# Pruning acts by removing ``weight`` from the parameters and replacing it with 
+# a new parameter called ``weight_orig`` (i.e. appending ``"_orig"`` to the 
+# initial parameter ``name``). ``weight_orig`` stores the unpruned version of 
+# the tensor. The ``bias`` was not pruned, so it will remain intact.
+print(list(module.named_parameters()))
+
+######################################################################
+# The pruning mask generated by the pruning technique selected above is saved 
+# as a module buffer named ``weight_mask`` (i.e. appending ``"_mask"`` to the 
+# initial parameter ``name``).
+print(list(module.named_buffers()))
+
+######################################################################
+# For the forward pass to work without modification, the ``weight`` attribute 
+# needs to exist. The pruning techniques implemented in 
+# ``torch.nn.utils.prune`` compute the pruned version of the weight (by 
+# combining the mask with the original parameter) and store them in the 
+# attribute ``weight``. Note, this is no longer a parameter of the ``module``,
+# it is now simply an attribute.
+print(module.weight)
+
+######################################################################
+# Finally, pruning is applied prior to each forward pass using PyTorch's
+# ``forward_pre_hooks``. Specifically, when the ``module`` is pruned, as we 
+# have done here, it will acquire a ``forward_pre_hook`` for each parameter 
+# associated with it that gets pruned. In this case, since we have so far 
+# only pruned the original parameter named ``weight``, only one hook will be
+# present.
+print(module._forward_pre_hooks)
+
+######################################################################
+# For completeness, we can now prune the ``bias`` too, to see how the 
+# parameters, buffers, hooks, and attributes of the ``module`` change.
+# Just for the sake of trying out another pruning technique, here we prune the 
+# 3 smallest entries in the bias by L1 norm, as implemented in the 
+# ``l1_unstructured`` pruning function.
+prune.l1_unstructured(module, name="bias", amount=3)
+
+######################################################################
+# We now expect the named parameters to include both ``weight_orig`` (from 
+# before) and ``bias_orig``. The buffers will include ``weight_mask`` and 
+# ``bias_mask``. The pruned versions of the two tensors will exist as 
+# module attributes, and the module will now have two ``forward_pre_hooks``.
+print(list(module.named_parameters()))
+
+######################################################################
+print(list(module.named_buffers()))
+
+######################################################################
+print(module.bias)
+
+######################################################################
+print(module._forward_pre_hooks)
+
+######################################################################
+# Iterative Pruning
+# -----------------
+# 
+# The same parameter in a module can be pruned multiple times, with the 
+# effect of the various pruning calls being equal to the combination of the
+# various masks applied in series.
+# The combination of a new mask with the old mask is handled by the 
+# ``PruningContainer``'s ``compute_mask`` method.
+#
+# Say, for example, that we now want to further prune ``module.weight``, this
+# time using structured pruning along the 0th axis of the tensor (the 0th axis 
+# corresponds to the output channels of the convolutional layer and has 
+# dimensionality 6 for ``conv1``), based on the channels' L2 norm. This can be 
+# achieved using the ``ln_structured`` function, with ``n=2`` and ``dim=0``.
+prune.ln_structured(module, name="weight", amount=0.5, n=2, dim=0)
+
+# As we can verify, this will zero out all the connections corresponding to 
+# 50% (3 out of 6) of the channels, while preserving the action of the 
+# previous mask.
+print(module.weight)
+
+############################################################################
+# The corresponding hook will now be of type 
+# ``torch.nn.utils.prune.PruningContainer``, and will store the history of 
+# pruning applied to the ``weight`` parameter.
+for hook in module._forward_pre_hooks.values():
+    if hook._tensor_name == "weight":  # select out the correct hook
+        break
+
+print(list(hook))  # pruning history in the container 
+
+######################################################################
+# Serializing a pruned model
+# --------------------------
+# All relevant tensors, including the mask buffers and the original parameters
+# used to compute the pruned tensors are stored in the model's ``state_dict`` 
+# and can therefore be easily serialized and saved, if needed.
+print(model.state_dict().keys())
+
+
+######################################################################
+# Remove pruning re-parametrization
+# ---------------------------------
+#
+# To make the pruning permanent, remove the re-parametrization in terms
+# of ``weight_orig`` and ``weight_mask``, and remove the ``forward_pre_hook``,
+# we can use the ``remove`` functionality from ``torch.nn.utils.prune``.
+# Note that this doesn't undo the pruning, as if it never happened. It simply 
+# makes it permanent, instead, by reassigning the parameter ``weight`` to the 
+# model parameters, in its pruned version.
+
+######################################################################
+# Prior to removing the re-parametrization:
+print(list(module.named_parameters()))
+######################################################################
+print(list(module.named_buffers()))
+######################################################################
+print(module.weight)
+
+######################################################################
+# After removing the re-parametrization:
+prune.remove(module, 'weight')
+print(list(module.named_parameters()))
+######################################################################
+print(list(module.named_buffers()))
+
+######################################################################
+# Pruning multiple parameters in a model 
+# --------------------------------------
+#
+# By specifying the desired pruning technique and parameters, we can easily 
+# prune multiple tensors in a network, perhaps according to their type, as we 
+# will see in this example.
+
+new_model = LeNet()
+for name, module in new_model.named_modules():
+    # prune 20% of connections in all 2D-conv layers 
+    if isinstance(module, torch.nn.Conv2d):
+        prune.l1_unstructured(module, name='weight', amount=0.2)
+    # prune 40% of connections in all linear layers 
+    elif isinstance(module, torch.nn.Linear):
+        prune.l1_unstructured(module, name='weight', amount=0.4)
+
+print(dict(new_model.named_buffers()).keys())  # to verify that all masks exist
+
+######################################################################
+# Global pruning
+# --------------
+#
+# So far, we only looked at what is usually referred to as "local" pruning,
+# i.e. the practice of pruning tensors in a model one by one, by 
+# comparing the statistics (weight magnitude, activation, gradient, etc.) of 
+# each entry exclusively to the other entries in that tensor. However, a 
+# common and perhaps more powerful technique is to prune the model all at 
+# once, by removing (for example) the lowest 20% of connections across the 
+# whole model, instead of removing the lowest 20% of connections in each 
+# layer. This is likely to result in different pruning percentages per layer.
+# Let's see how to do that using ``global_unstructured`` from 
+# ``torch.nn.utils.prune``.
+
+model = LeNet()
+
+parameters_to_prune = (
+    (model.conv1, 'weight'),
+    (model.conv2, 'weight'),
+    (model.fc1, 'weight'),
+    (model.fc2, 'weight'),
+    (model.fc3, 'weight'),
+)
+
+prune.global_unstructured(
+    parameters_to_prune,
+    pruning_method=prune.L1Unstructured,
+    amount=0.2,
+)
+
+######################################################################
+# Now we can check the sparsity induced in every pruned parameter, which will 
+# not be equal to 20% in each layer. However, the global sparsity will be 
+# (approximately) 20%.
+print(
+    "Sparsity in conv1.weight: {:.2f}%".format(
+        100. * float(torch.sum(model.conv1.weight == 0))
+        / float(model.conv1.weight.nelement())
+    )
+)
+print(
+    "Sparsity in conv2.weight: {:.2f}%".format(
+        100. * float(torch.sum(model.conv2.weight == 0))
+        / float(model.conv2.weight.nelement())
+    )
+)
+print(
+    "Sparsity in fc1.weight: {:.2f}%".format(
+        100. * float(torch.sum(model.fc1.weight == 0))
+        / float(model.fc1.weight.nelement())
+    )
+)
+print(
+    "Sparsity in fc2.weight: {:.2f}%".format(
+        100. * float(torch.sum(model.fc2.weight == 0))
+        / float(model.fc2.weight.nelement())
+    )
+)
+print(
+    "Sparsity in fc3.weight: {:.2f}%".format(
+        100. * float(torch.sum(model.fc3.weight == 0))
+        / float(model.fc3.weight.nelement())
+    )
+)
+print(
+    "Global sparsity: {:.2f}%".format(
+        100. * float(
+            torch.sum(model.conv1.weight == 0)
+            + torch.sum(model.conv2.weight == 0)
+            + torch.sum(model.fc1.weight == 0)
+            + torch.sum(model.fc2.weight == 0)
+            + torch.sum(model.fc3.weight == 0)
+        )
+        / float(
+            model.conv1.weight.nelement()
+            + model.conv2.weight.nelement()
+            + model.fc1.weight.nelement()
+            + model.fc2.weight.nelement()
+            + model.fc3.weight.nelement()
+        )
+    )
+)
+
+
+######################################################################
+# Extending ``torch.nn.utils.prune`` with custom pruning functions
+# ------------------------------------------------------------------
+# To implement your own pruning function, you can extend the
+# ``nn.utils.prune`` module by subclassing the ``BasePruningMethod``
+# base class, the same way all other pruning methods do. The base class
+# implements the following methods for you: ``__call__``, ``apply_mask``,
+# ``apply``, ``prune``, and ``remove``. Beyond some special cases, you shouldn't
+# have to reimplement these methods for your new pruning technique.
+# You will, however, have to implement ``__init__`` (the constructor),
+# and ``compute_mask`` (the instructions on how to compute the mask
+# for the given tensor according to the logic of your pruning
+# technique). In addition, you will have to specify which type of
+# pruning this technique implements (supported options are ``global``,
+# ``structured``, and ``unstructured``). This is needed to determine
+# how to combine masks in the case in which pruning is applied
+# iteratively. In other words, when pruning a prepruned parameter,
+# the current pruning technique is expected to act on the unpruned
+# portion of the parameter. Specifying the ``PRUNING_TYPE`` will
+# enable the ``PruningContainer`` (which handles the iterative
+# application of pruning masks) to correctly identify the slice of the
+# parameter to prune.
+#
+# Let's assume, for example, that you want to implement a pruning
+# technique that prunes every other entry in a tensor (or -- if the
+# tensor has previously been pruned -- in the remaining unpruned
+# portion of the tensor). This will be of ``PRUNING_TYPE='unstructured'``
+# because it acts on individual connections in a layer and not on entire
+# units/channels (``'structured'``), or across different parameters
+# (``'global'``).
+
+class FooBarPruningMethod(prune.BasePruningMethod):
+    """Prune every other entry in a tensor
+    """
+    PRUNING_TYPE = 'unstructured'
+
+    def compute_mask(self, t, default_mask):
+        mask = default_mask.clone()
+        mask.view(-1)[::2] = 0 
+        return mask
+
+######################################################################
+# Now, to apply this to a parameter in an ``nn.Module``, you should
+# also provide a simple function that instantiates the method and
+# applies it.
+def foobar_unstructured(module, name):
+    """Prunes tensor corresponding to parameter called `name` in `module`
+    by removing every other entry in the tensors.
+    Modifies module in place (and also return the modified module) 
+    by:
+    1) adding a named buffer called `name+'_mask'` corresponding to the 
+    binary mask applied to the parameter `name` by the pruning method.
+    The parameter `name` is replaced by its pruned version, while the 
+    original (unpruned) parameter is stored in a new parameter named 
+    `name+'_orig'`.
+
+    Args:
+        module (nn.Module): module containing the tensor to prune
+        name (string): parameter name within `module` on which pruning
+                will act.
+
+    Returns:
+        module (nn.Module): modified (i.e. pruned) version of the input
+            module
+    
+    Examples:
+        >>> m = nn.Linear(3, 4)
+        >>> foobar_unstructured(m, name='bias')
+    """
+    FooBarPruningMethod.apply(module, name)
+    return module
+
+######################################################################
+# Let's try it out!
+model = LeNet()
+foobar_unstructured(model.fc3, name='bias')
+
+print(model.fc3.bias_mask)
diff --git a/intermediate_source/realtime_rpi.rst b/intermediate_source/realtime_rpi.rst
new file mode 100644
index 00000000000..2e00b68d2f1
--- /dev/null
+++ b/intermediate_source/realtime_rpi.rst
@@ -0,0 +1,356 @@
+Real Time Inference on Raspberry Pi 4 and 5 (40 fps!)
+=================================================
+**Author**: `Tristan Rice <https://github.com/d4l3k>`_
+
+PyTorch has out of the box support for Raspberry Pi 4 and 5. This tutorial will guide
+you on how to setup a Raspberry Pi for running PyTorch and run a MobileNet v2
+classification model in real time (30-40 fps) on the CPU.
+
+This was all tested with Raspberry Pi 4 Model B 4GB but should work with the 2GB
+variant as well as on the 3B with reduced performance.
+
+.. image:: https://user-images.githubusercontent.com/909104/153093710-bc736b6f-69d9-4a50-a3e8-9f2b2c9e04fd.gif
+
+Prerequisites
+---------------
+
+To follow this tutorial you'll need a Raspberry Pi 4 or 5, a camera for it and all
+the other standard accessories.
+
+* `Raspberry Pi 4 Model B 2GB+ <https://www.raspberrypi.com/products/raspberry-pi-4-model-b/>`_
+* `Raspberry Pi Camera Module <https://www.raspberrypi.com/products/camera-module-v2/>`_
+* Heat sinks and Fan (optional but recommended)
+* 5V 3A USB-C Power Supply
+* SD card (at least 8gb)
+* SD card read/writer
+
+
+Raspberry Pi Setup
+----------------------
+
+PyTorch only provides pip packages for Arm 64bit (aarch64) so you'll need to install a 64 bit version of the OS on your Raspberry Pi
+
+You'll need to install the `official rpi-imager <https://www.raspberrypi.com/software/>`_ to install Rasbperry Pi OS.
+
+**32-bit Raspberry Pi OS will not work.**
+
+.. image:: https://user-images.githubusercontent.com/909104/152866212-36ce29b1-aba6-4924-8ae6-0a283f1fca14.gif
+
+Installation will take at least a few minutes depending on your internet speed and sdcard speed. Once it's done it should look like:
+
+.. image:: https://user-images.githubusercontent.com/909104/152867425-c005cff0-5f3f-47f1-922d-e0bbb541cd25.png
+
+Time to put your sdcard in your Raspberry Pi, connect the camera and boot it up.
+
+.. image:: https://user-images.githubusercontent.com/909104/152869862-c239c980-b089-4bd5-84eb-0a1e5cf22df2.png
+
+
+Raspberry Pi 4 Config
+~~~~~~~~~~~~~~~~~~~~~~~~
+
+If you're using a Raspberry Pi 4, you'll need some additional config changes. These changes are not required on Raspberry Pi 5.
+
+Once the OS boots and you complete the initial setup you'll need to edit the ``/boot/config.txt`` file to enable the camera.
+
+.. code:: toml
+
+    # This enables the extended features such as the camera.
+    start_x=1
+
+    # This needs to be at least 128M for the camera processing, if it's bigger you can just leave it as is.
+    gpu_mem=128
+
+And then reboot.
+
+Installing PyTorch and picamera2
+-------------------------------
+
+PyTorch and all the other libraries we need have ARM 64-bit/aarch64 variants so you can just install them via pip and have it work like any other Linux system.
+
+.. code:: shell
+
+    $ sudo apt install -y python3-picamera2 python3-libcamera
+    $ pip install torch torchvision --break-system-packages
+
+.. image:: https://user-images.githubusercontent.com/909104/152874260-95a7a8bd-0f9b-438a-9c0b-5b67729e233f.png
+
+
+We can now check that everything installed correctly:
+
+.. code:: shell
+
+  $ python -c "import torch; print(torch.__version__)"
+
+.. image:: https://user-images.githubusercontent.com/909104/152874271-d7057c2d-80fd-4761-aed4-df6c8b7aa99f.png
+
+
+Video Capture
+-------------------
+
+Test the camera is working first, by running ``libcamera-hello`` in a terminal.
+
+For video capture we're going to be using picamera2 to capture the video frames.
+
+The model we're using (MobileNetV2) takes in image sizes of ``224x224`` so we
+can request that directly from picamera2 at 36fps. We're targeting 30fps for the
+model but we request a slightly higher framerate than that so there's always
+enough frames.
+
+.. code:: python
+
+    from picamera2 import Picamera2
+
+    picam2 = Picamera2()
+
+    # print available sensor modes
+    print(picam2.sensor_modes)
+
+    config = picam2.create_still_configuration(main={
+        "size": (224, 224),
+        "format": "BGR888",
+    }, display="main")
+    picam2.configure(config)
+    picam2.set_controls({"FrameRate": 36})
+    picam2.start()
+
+To capture the frames we can call ``capture_image`` to return a ``PIL.Image``
+object that we can use with PyTorch.
+
+.. code:: python
+
+    # read frame
+    image = picam2.capture_image("main")
+
+    # show frame for testing
+    image.show()
+
+This data reading and processing takes about ``3.5 ms``.
+
+Image Preprocessing
+----------------------
+
+We need to take the frames and transform them into the format the model expects. This is the same processing as you would do on any machine with the standard torchvision transforms.
+
+.. code:: python
+
+    from torchvision import transforms
+
+    preprocess = transforms.Compose([
+        # convert the frame to a CHW torch tensor for training
+        transforms.ToTensor(),
+        # normalize the colors to the range that mobilenet_v2/3 expect
+        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+    ])
+    input_tensor = preprocess(image)
+    # The model can handle multiple images simultaneously so we need to add an
+    # empty dimension for the batch.
+    # [3, 224, 224] -> [1, 3, 224, 224]
+    input_batch = input_tensor.unsqueeze(0)
+
+Model Choices
+----------------
+
+There's a number of models you can choose from to use with different performance
+characteristics. Not all models provide a ``qnnpack`` pretrained variant so for
+testing purposes you should chose one that does but if you train and quantize
+your own model you can use any of them.
+
+We're using ``mobilenet_v2`` for this tutorial since it has good performance and
+accuracy.
+
+Raspberry Pi 4 Benchmark Results:
+
++--------------------+------+-----------------------+-----------------------+--------------------+
+| Model              | FPS  | Total Time (ms/frame) | Model Time (ms/frame) | qnnpack Pretrained |
++====================+======+=======================+=======================+====================+
+| mobilenet_v2       | 33.7 |                  29.7 |                  26.4 | True               |
++--------------------+------+-----------------------+-----------------------+--------------------+
+| mobilenet_v3_large | 29.3 |                  34.1 |                  30.7 | True               |
++--------------------+------+-----------------------+-----------------------+--------------------+
+| resnet18           |  9.2 |                 109.0 |                 100.3 | False              |
++--------------------+------+-----------------------+-----------------------+--------------------+
+| resnet50           |  4.3 |                 233.9 |                 225.2 | False              |
++--------------------+------+-----------------------+-----------------------+--------------------+
+| resnext101_32x8d   |  1.1 |                 892.5 |                 885.3 | False              |
++--------------------+------+-----------------------+-----------------------+--------------------+
+| inception_v3       |  4.9 |                 204.1 |                 195.5 | False              |
++--------------------+------+-----------------------+-----------------------+--------------------+
+| googlenet          |  7.4 |                 135.3 |                 132.0 | False              |
++--------------------+------+-----------------------+-----------------------+--------------------+
+| shufflenet_v2_x0_5 | 46.7 |                  21.4 |                  18.2 | False              |
++--------------------+------+-----------------------+-----------------------+--------------------+
+| shufflenet_v2_x1_0 | 24.4 |                  41.0 |                  37.7 | False              |
++--------------------+------+-----------------------+-----------------------+--------------------+
+| shufflenet_v2_x1_5 | 16.8 |                  59.6 |                  56.3 | False              |
++--------------------+------+-----------------------+-----------------------+--------------------+
+| shufflenet_v2_x2_0 | 11.6 |                  86.3 |                  82.7 | False              |
++--------------------+------+-----------------------+-----------------------+--------------------+
+
+MobileNetV2: Quantization and JIT
+-------------------------------------
+
+For optimal performance we want a model that's quantized and fused. Quantized
+means that it does the computation using int8 which is much more performant than
+the standard float32 math. Fused means that consecutive operations have been
+fused together into a more performant version where possible. Commonly things
+like activations (``ReLU``) can be merged into the layer before (``Conv2d``)
+during inference.
+
+The aarch64 version of pytorch requires using the ``qnnpack`` engine.
+
+.. code:: python
+
+    import torch
+    torch.backends.quantized.engine = 'qnnpack'
+
+For this example we'll use a prequantized and fused version of MobileNetV2 that's provided out of the box by torchvision.
+
+.. code:: python
+
+    from torchvision import models
+    net = models.quantization.mobilenet_v2(pretrained=True, quantize=True)
+
+We then want to jit the model to reduce Python overhead and fuse any ops. Jit gives us ~30fps instead of ~20fps without it.
+
+.. code:: python
+
+    net = torch.jit.script(net)
+
+Putting It Together
+------------------------
+
+We can now put all the pieces together and run it:
+
+.. code:: python
+
+    import time
+
+    import torch
+    from torchvision import models, transforms
+    from picamera2 import Picamera2
+
+    torch.backends.quantized.engine = 'qnnpack'
+
+    picam2 = Picamera2()
+
+    # print available sensor modes
+    print(picam2.sensor_modes)
+
+    config = picam2.create_still_configuration(main={
+        "size": (224, 224),
+        "format": "BGR888",
+    }, display="main")
+    picam2.configure(config)
+    picam2.set_controls({"FrameRate": 36})
+    picam2.start()
+
+    preprocess = transforms.Compose([
+        transforms.ToTensor(),
+        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+    ])
+
+    net = models.quantization.mobilenet_v2(pretrained=True, quantize=True)
+    # jit model to take it from ~20fps to ~30fps
+    net = torch.jit.script(net)
+
+    started = time.time()
+    last_logged = time.time()
+    frame_count = 0
+
+    with torch.no_grad():
+        while True:
+            # read frame
+            image = picam2.capture_image("main")
+
+
+            # preprocess
+            input_tensor = preprocess(image)
+
+            # create a mini-batch as expected by the model
+            input_batch = input_tensor.unsqueeze(0)
+
+            # run model
+            output = net(input_batch)
+            # do something with output ...
+            print(output.argmax())
+
+            # log model performance
+            frame_count += 1
+            now = time.time()
+            if now - last_logged > 1:
+                print(f"{frame_count / (now-last_logged)} fps")
+                last_logged = now
+                frame_count = 0
+
+
+Running it shows that we're hovering at ~30 fps on a Raspberry Pi 4 and ~41 fps on a Raspberry Pi 5.
+
+.. image:: https://user-images.githubusercontent.com/909104/152892609-7d115705-3ec9-4f8d-beed-a51711503a32.png
+
+This is with all the default settings in Raspberry Pi OS. If you disabled the UI
+and all the other background services that are enabled by default it's more
+performant and stable.
+
+If we check ``htop`` we see that we have almost 100% utilization.
+
+.. image:: https://user-images.githubusercontent.com/909104/152892630-f094b84b-19ba-48f6-8632-1b954abc59c7.png
+
+To verify that it's working end to end we can compute the probabilities of the
+classes and
+`use the ImageNet class labels <https://gist.github.com/yrevar/942d3a0ac09ec9e5eb3a>`_
+to print the detections.
+
+.. code:: python
+
+    top = list(enumerate(output[0].softmax(dim=0)))
+    top.sort(key=lambda x: x[1], reverse=True)
+    for idx, val in top[:10]:
+        print(f"{val.item()*100:.2f}% {classes[idx]}")
+
+``mobilenet_v3_large`` running in real time:
+
+.. image:: https://user-images.githubusercontent.com/909104/153093710-bc736b6f-69d9-4a50-a3e8-9f2b2c9e04fd.gif
+
+
+Detecting an orange:
+
+.. image:: https://user-images.githubusercontent.com/909104/153092153-d9c08dfe-105b-408a-8e1e-295da8a78c19.jpg
+
+
+Detecting a mug:
+
+.. image:: https://user-images.githubusercontent.com/909104/153092155-4b90002f-a0f3-4267-8d70-e713e7b4d5a0.jpg
+
+
+Troubleshooting: Performance
+--------------------------------
+
+PyTorch by default will use all of the cores available. If you have anything
+running in the background on the Raspberry Pi it may cause contention with the
+model inference causing latency spikes. To alleviate this you can reduce the
+number of threads which will reduce the peak latency at a small performance
+penalty.
+
+.. code:: python
+
+  torch.set_num_threads(2)
+
+For ``shufflenet_v2_x1_5`` using ``2 threads`` instead of ``4 threads``
+increases best case latency to ``72 ms`` from ``60 ms`` but eliminates the
+latency spikes of ``128 ms``.
+
+Next Steps
+------------
+
+You can create your own model or fine tune an existing one. If you fine tune on
+one of the models from
+`torchvision.models.quantized
+<https://pytorch.org/vision/stable/models.html#quantized-models>`_
+most of the work to fuse and quantize has already been done for you so you can
+directly deploy with good performance on a Raspberry Pi.
+
+See more:
+
+* `Quantization <https://pytorch.org/docs/stable/quantization.html>`_ for more information on how to quantize and fuse your model.
+* `Transfer Learning Tutorial <https://pytorch.org/tutorials/beginner/transfer_learning_tutorial.html>`_
+  for how to use transfer learning to fine tune a pre-existing model to your dataset.
diff --git a/intermediate_source/reinforcement_ppo.py b/intermediate_source/reinforcement_ppo.py
new file mode 100644
index 00000000000..c707c0ebb19
--- /dev/null
+++ b/intermediate_source/reinforcement_ppo.py
@@ -0,0 +1,705 @@
+# -*- coding: utf-8 -*-
+"""
+Reinforcement Learning (PPO) with TorchRL Tutorial
+==================================================
+**Author**: `Vincent Moens <https://github.com/vmoens>`_
+
+This tutorial demonstrates how to use PyTorch and :py:mod:`torchrl` to train a parametric policy
+network to solve the Inverted Pendulum task from the `OpenAI-Gym/Farama-Gymnasium
+control library <https://github.com/Farama-Foundation/Gymnasium>`__.
+
+.. figure:: /_static/img/invpendulum.gif
+   :alt: Inverted pendulum
+
+   Inverted pendulum
+
+Key learnings:
+
+- How to create an environment in TorchRL, transform its outputs, and collect data from this environment;
+- How to make your classes talk to each other using :class:`~tensordict.TensorDict`;
+- The basics of building your training loop with TorchRL:
+
+  - How to compute the advantage signal for policy gradient methods;
+  - How to create a stochastic policy using a probabilistic neural network;
+  - How to create a dynamic replay buffer and sample from it without repetition.
+
+We will cover six crucial components of TorchRL:
+
+* `environments <https://docs.pytorch.org/rl/stable/reference/envs.html>`__
+* `transforms <https://docs.pytorch.org/rl/stable/reference/envs.html#transforms>`__
+* `models (policy and value function) <https://docs.pytorch.org/rl/stable/reference/modules.html>`__
+* `loss modules <https://docs.pytorch.org/rl/stable/reference/objectives.html>`__
+* `data collectors <https://docs.pytorch.org/rl/stable/reference/collectors.html>`__
+* `replay buffers <https://docs.pytorch.org/rl/stable/reference/data.html#replay-buffers>`__
+
+"""
+
+######################################################################
+# If you are running this in Google Colab, make sure you install the following dependencies:
+#
+# .. code-block:: bash
+#
+#    !pip3 install torchrl
+#    !pip3 install gym[mujoco]
+#    !pip3 install tqdm
+#
+# Proximal Policy Optimization (PPO) is a policy-gradient algorithm where a
+# batch of data is being collected and directly consumed to train the policy to maximise
+# the expected return given some proximality constraints. You can think of it
+# as a sophisticated version of `REINFORCE <https://link.springer.com/content/pdf/10.1007/BF00992696.pdf>`_,
+# the foundational policy-optimization algorithm. For more information, see the
+# `Proximal Policy Optimization Algorithms <https://arxiv.org/abs/1707.06347>`_ paper.
+#
+# PPO is usually regarded as a fast and efficient method for online, on-policy
+# reinforcement algorithm. TorchRL provides a loss-module that does all the work
+# for you, so that you can rely on this implementation and focus on solving your
+# problem rather than re-inventing the wheel every time you want to train a policy.
+#
+# For completeness, here is a brief overview of what the loss computes, even though
+# this is taken care of by our :class:`~torchrl.objectives.ClipPPOLoss` module—the algorithm works as follows:
+# 1. we will sample a batch of data by playing the
+# policy in the environment for a given number of steps.
+# 2. Then, we will perform a given number of optimization steps with random sub-samples of this batch using
+# a clipped version of the REINFORCE loss.
+# 3. The clipping will put a pessimistic bound on our loss: lower return estimates will
+# be favored compared to higher ones.
+# The precise formula of the loss is:
+#
+# .. math::
+#
+#     L(s,a,\theta_k,\theta) = \min\left(
+#     \frac{\pi_{\theta}(a|s)}{\pi_{\theta_k}(a|s)}  A^{\pi_{\theta_k}}(s,a), \;\;
+#     g(\epsilon, A^{\pi_{\theta_k}}(s,a))
+#     \right),
+#
+# There are two components in that loss: in the first part of the minimum operator,
+# we simply compute an importance-weighted version of the REINFORCE loss (for example, a
+# REINFORCE loss that we have corrected for the fact that the current policy
+# configuration lags the one that was used for the data collection).
+# The second part of that minimum operator is a similar loss where we have clipped
+# the ratios when they exceeded or were below a given pair of thresholds.
+#
+# This loss ensures that whether the advantage is positive or negative, policy
+# updates that would produce significant shifts from the previous configuration
+# are being discouraged.
+#
+# This tutorial is structured as follows:
+#
+# 1. First, we will define a set of hyperparameters we will be using for training.
+#
+# 2. Next, we will focus on creating our environment, or simulator, using TorchRL's
+#    wrappers and transforms.
+#
+# 3. Next, we will design the policy network and the value model,
+#    which is indispensable to the loss function. These modules will be used
+#    to configure our loss module.
+#
+# 4. Next, we will create the replay buffer and data loader.
+#
+# 5. Finally, we will run our training loop and analyze the results.
+#
+# Throughout this tutorial, we'll be using the :mod:`tensordict` library.
+# :class:`~tensordict.TensorDict` is the lingua franca of TorchRL: it helps us abstract
+# what a module reads and writes and care less about the specific data
+# description and more about the algorithm itself.
+#
+
+import warnings
+warnings.filterwarnings("ignore")
+from torch import multiprocessing
+
+# sphinx_gallery_start_ignore
+
+# TorchRL prefers spawn method, that restricts creation of  ``~torchrl.envs.ParallelEnv`` inside
+# `__main__` method call, but for the easy of reading the code switch to fork
+# which is also a default spawn method in Google's Colaboratory
+try:
+    multiprocessing.set_start_method("fork")
+except RuntimeError:
+    pass
+
+# sphinx_gallery_end_ignore
+
+from collections import defaultdict
+
+import matplotlib.pyplot as plt
+import torch
+from tensordict.nn import TensorDictModule
+from tensordict.nn.distributions import NormalParamExtractor
+from torch import nn
+from torchrl.collectors import SyncDataCollector
+from torchrl.data.replay_buffers import ReplayBuffer
+from torchrl.data.replay_buffers.samplers import SamplerWithoutReplacement
+from torchrl.data.replay_buffers.storages import LazyTensorStorage
+from torchrl.envs import (Compose, DoubleToFloat, ObservationNorm, StepCounter,
+                          TransformedEnv)
+from torchrl.envs.libs.gym import GymEnv
+from torchrl.envs.utils import check_env_specs, ExplorationType, set_exploration_type
+from torchrl.modules import ProbabilisticActor, TanhNormal, ValueOperator
+from torchrl.objectives import ClipPPOLoss
+from torchrl.objectives.value import GAE
+from tqdm import tqdm
+
+######################################################################
+# Define Hyperparameters
+# ----------------------
+#
+# We set the hyperparameters for our algorithm. Depending on the resources
+# available, one may choose to execute the policy on GPU or on another
+# device.
+# The ``frame_skip`` will control how for how many frames is a single
+# action being executed. The rest of the arguments that count frames
+# must be corrected for this value (since one environment step will
+# actually return ``frame_skip`` frames).
+#
+
+is_fork = multiprocessing.get_start_method() == "fork"
+device = (
+    torch.device(0)
+    if torch.cuda.is_available() and not is_fork
+    else torch.device("cpu")
+)
+num_cells = 256  # number of cells in each layer i.e. output dim.
+lr = 3e-4
+max_grad_norm = 1.0
+
+######################################################################
+# Data collection parameters
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# When collecting data, we will be able to choose how big each batch will be
+# by defining a ``frames_per_batch`` parameter. We will also define how many
+# frames (such as the number of interactions with the simulator) we will allow ourselves to
+# use. In general, the goal of an RL algorithm is to learn to solve the task
+# as fast as it can in terms of environment interactions: the lower the ``total_frames``
+# the better.
+#
+frames_per_batch = 1000
+# For a complete training, bring the number of frames up to 1M
+total_frames = 50_000
+
+######################################################################
+# PPO parameters
+# ~~~~~~~~~~~~~~
+#
+# At each data collection (or batch collection) we will run the optimization
+# over a certain number of *epochs*, each time consuming the entire data we just
+# acquired in a nested training loop. Here, the ``sub_batch_size`` is different from the
+# ``frames_per_batch`` here above: recall that we are working with a "batch of data"
+# coming from our collector, which size is defined by ``frames_per_batch``, and that
+# we will further split in smaller sub-batches during the inner training loop.
+# The size of these sub-batches is controlled by ``sub_batch_size``.
+#
+sub_batch_size = 64  # cardinality of the sub-samples gathered from the current data in the inner loop
+num_epochs = 10  # optimization steps per batch of data collected
+clip_epsilon = (
+    0.2  # clip value for PPO loss: see the equation in the intro for more context.
+)
+gamma = 0.99
+lmbda = 0.95
+entropy_eps = 1e-4
+
+######################################################################
+# Define an environment
+# ---------------------
+#
+# In RL, an *environment* is usually the way we refer to a simulator or a
+# control system. Various libraries provide simulation environments for reinforcement
+# learning, including Gymnasium (previously OpenAI Gym), DeepMind control suite, and
+# many others.
+# As a general library, TorchRL's goal is to provide an interchangeable interface
+# to a large panel of RL simulators, allowing you to easily swap one environment
+# with another. For example, creating a wrapped gym environment can be achieved with few characters:
+#
+
+base_env = GymEnv("InvertedDoublePendulum-v4", device=device)
+
+######################################################################
+# There are a few things to notice in this code: first, we created
+# the environment by calling the ``GymEnv`` wrapper. If extra keyword arguments
+# are passed, they will be transmitted to the ``gym.make`` method, hence covering
+# the most common environment construction commands.
+# Alternatively, one could also directly create a gym environment using ``gym.make(env_name, **kwargs)``
+# and wrap it in a `GymWrapper` class.
+#
+# Also the ``device`` argument: for gym, this only controls the device where
+# input action and observed states will be stored, but the execution will always
+# be done on CPU. The reason for this is simply that gym does not support on-device
+# execution, unless specified otherwise. For other libraries, we have control over
+# the execution device and, as much as we can, we try to stay consistent in terms of
+# storing and execution backends.
+#
+# Transforms
+# ~~~~~~~~~~
+#
+# We will append some transforms to our environments to prepare the data for
+# the policy. In Gym, this is usually achieved via wrappers. TorchRL takes a different
+# approach, more similar to other pytorch domain libraries, through the use of transforms.
+# To add transforms to an environment, one should simply wrap it in a :class:`~torchrl.envs.transforms.TransformedEnv`
+# instance and append the sequence of transforms to it. The transformed environment will inherit
+# the device and meta-data of the wrapped environment, and transform these depending on the sequence
+# of transforms it contains.
+#
+# Normalization
+# ~~~~~~~~~~~~~
+#
+# The first to encode is a normalization transform.
+# As a rule of thumbs, it is preferable to have data that loosely
+# match a unit Gaussian distribution: to obtain this, we will
+# run a certain number of random steps in the environment and compute
+# the summary statistics of these observations.
+#
+# We'll append two other transforms: the :class:`~torchrl.envs.transforms.DoubleToFloat` transform will
+# convert double entries to single-precision numbers, ready to be read by the
+# policy. The :class:`~torchrl.envs.transforms.StepCounter` transform will be used to count the steps before
+# the environment is terminated. We will use this measure as a supplementary measure
+# of performance.
+#
+# As we will see later, many of the TorchRL's classes rely on :class:`~tensordict.TensorDict`
+# to communicate. You could think of it as a python dictionary with some extra
+# tensor features. In practice, this means that many modules we will be working
+# with need to be told what key to read (``in_keys``) and what key to write
+# (``out_keys``) in the ``tensordict`` they will receive. Usually, if ``out_keys``
+# is omitted, it is assumed that the ``in_keys`` entries will be updated
+# in-place. For our transforms, the only entry we are interested in is referred
+# to as ``"observation"`` and our transform layers will be told to modify this
+# entry and this entry only:
+#
+
+env = TransformedEnv(
+    base_env,
+    Compose(
+        # normalize observations
+        ObservationNorm(in_keys=["observation"]),
+        DoubleToFloat(),
+        StepCounter(),
+    ),
+)
+
+######################################################################
+# As you may have noticed, we have created a normalization layer but we did not
+# set its normalization parameters. To do this, :class:`~torchrl.envs.transforms.ObservationNorm` can
+# automatically gather the summary statistics of our environment:
+#
+env.transform[0].init_stats(num_iter=1000, reduce_dim=0, cat_dim=0)
+
+######################################################################
+# The :class:`~torchrl.envs.transforms.ObservationNorm` transform has now been populated with a
+# location and a scale that will be used to normalize the data.
+#
+# Let us do a little sanity check for the shape of our summary stats:
+#
+print("normalization constant shape:", env.transform[0].loc.shape)
+
+######################################################################
+# An environment is not only defined by its simulator and transforms, but also
+# by a series of metadata that describe what can be expected during its
+# execution.
+# For efficiency purposes, TorchRL is quite stringent when it comes to
+# environment specs, but you can easily check that your environment specs are
+# adequate.
+# In our example, the :class:`~torchrl.envs.libs.gym.GymWrapper` and
+# :class:`~torchrl.envs.libs.gym.GymEnv` that inherits
+# from it already take care of setting the proper specs for your environment so
+# you should not have to care about this.
+#
+# Nevertheless, let's see a concrete example using our transformed
+# environment by looking at its specs.
+# There are three specs to look at: ``observation_spec`` which defines what
+# is to be expected when executing an action in the environment,
+# ``reward_spec`` which indicates the reward domain and finally the
+# ``input_spec`` (which contains the ``action_spec``) and which represents
+# everything an environment requires to execute a single step.
+#
+print("observation_spec:", env.observation_spec)
+print("reward_spec:", env.reward_spec)
+print("input_spec:", env.input_spec)
+print("action_spec (as defined by input_spec):", env.action_spec)
+
+######################################################################
+# the :func:`check_env_specs` function runs a small rollout and compares its output against the environment
+# specs. If no error is raised, we can be confident that the specs are properly defined:
+#
+check_env_specs(env)
+
+######################################################################
+# For fun, let's see what a simple random rollout looks like. You can
+# call `env.rollout(n_steps)` and get an overview of what the environment inputs
+# and outputs look like. Actions will automatically be drawn from the action spec
+# domain, so you don't need to care about designing a random sampler.
+#
+# Typically, at each step, an RL environment receives an
+# action as input, and outputs an observation, a reward and a done state. The
+# observation may be composite, meaning that it could be composed of more than one
+# tensor. This is not a problem for TorchRL, since the whole set of observations
+# is automatically packed in the output :class:`~tensordict.TensorDict`. After executing a rollout
+# (for example, a sequence of environment steps and random action generations) over a given
+# number of steps, we will retrieve a :class:`~tensordict.TensorDict` instance with a shape
+# that matches this trajectory length:
+#
+rollout = env.rollout(3)
+print("rollout of three steps:", rollout)
+print("Shape of the rollout TensorDict:", rollout.batch_size)
+
+######################################################################
+# Our rollout data has a shape of ``torch.Size([3])``, which matches the number of steps
+# we ran it for. The ``"next"`` entry points to the data coming after the current step.
+# In most cases, the ``"next"`` data at time `t` matches the data at ``t+1``, but this
+# may not be the case if we are using some specific transformations (for example, multi-step).
+#
+# Policy
+# ------
+#
+# PPO utilizes a stochastic policy to handle exploration. This means that our
+# neural network will have to output the parameters of a distribution, rather
+# than a single value corresponding to the action taken.
+#
+# As the data is continuous, we use a Tanh-Normal distribution to respect the
+# action space boundaries. TorchRL provides such distribution, and the only
+# thing we need to care about is to build a neural network that outputs the
+# right number of parameters for the policy to work with (a location, or mean,
+# and a scale):
+#
+# .. math::
+#
+#     f_{\theta}(\text{observation}) = \mu_{\theta}(\text{observation}), \sigma^{+}_{\theta}(\text{observation})
+#
+# The only extra-difficulty that is brought up here is to split our output in two
+# equal parts and map the second to a strictly positive space.
+#
+# We design the policy in three steps:
+#
+# 1. Define a neural network ``D_obs`` -> ``2 * D_action``. Indeed, our ``loc`` (mu) and ``scale`` (sigma) both have dimension ``D_action``.
+#
+# 2. Append a :class:`~tensordict.nn.distributions.NormalParamExtractor` to extract a location and a scale (for example, splits the input in two equal parts and applies a positive transformation to the scale parameter).
+#
+# 3. Create a probabilistic :class:`~tensordict.nn.TensorDictModule` that can generate this distribution and sample from it.
+#
+
+actor_net = nn.Sequential(
+    nn.LazyLinear(num_cells, device=device),
+    nn.Tanh(),
+    nn.LazyLinear(num_cells, device=device),
+    nn.Tanh(),
+    nn.LazyLinear(num_cells, device=device),
+    nn.Tanh(),
+    nn.LazyLinear(2 * env.action_spec.shape[-1], device=device),
+    NormalParamExtractor(),
+)
+
+######################################################################
+# To enable the policy to "talk" with the environment through the ``tensordict``
+# data carrier, we wrap the ``nn.Module`` in a :class:`~tensordict.nn.TensorDictModule`. This
+# class will simply ready the ``in_keys`` it is provided with and write the
+# outputs in-place at the registered ``out_keys``.
+#
+policy_module = TensorDictModule(
+    actor_net, in_keys=["observation"], out_keys=["loc", "scale"]
+)
+
+######################################################################
+# We now need to build a distribution out of the location and scale of our
+# normal distribution. To do so, we instruct the
+# :class:`~torchrl.modules.tensordict_module.ProbabilisticActor`
+# class to build a :class:`~torchrl.modules.TanhNormal` out of the location and scale
+# parameters. We also provide the minimum and maximum values of this
+# distribution, which we gather from the environment specs.
+#
+# The name of the ``in_keys`` (and hence the name of the ``out_keys`` from
+# the :class:`~tensordict.nn.TensorDictModule` above) cannot be set to any value one may
+# like, as the :class:`~torchrl.modules.TanhNormal` distribution constructor will expect the
+# ``loc`` and ``scale`` keyword arguments. That being said,
+# :class:`~torchrl.modules.tensordict_module.ProbabilisticActor` also accepts
+# ``Dict[str, str]`` typed ``in_keys`` where the key-value pair indicates
+# what ``in_key`` string should be used for every keyword argument that is to be used.
+#
+policy_module = ProbabilisticActor(
+    module=policy_module,
+    spec=env.action_spec,
+    in_keys=["loc", "scale"],
+    distribution_class=TanhNormal,
+    distribution_kwargs={
+        "low": env.action_spec.space.low,
+        "high": env.action_spec.space.high,
+    },
+    return_log_prob=True,
+    # we'll need the log-prob for the numerator of the importance weights
+)
+
+######################################################################
+# Value network
+# -------------
+#
+# The value network is a crucial component of the PPO algorithm, even though it
+# won't be used at inference time. This module will read the observations and
+# return an estimation of the discounted return for the following trajectory.
+# This allows us to amortize learning by relying on the some utility estimation
+# that is learned on-the-fly during training. Our value network share the same
+# structure as the policy, but for simplicity we assign it its own set of
+# parameters.
+#
+value_net = nn.Sequential(
+    nn.LazyLinear(num_cells, device=device),
+    nn.Tanh(),
+    nn.LazyLinear(num_cells, device=device),
+    nn.Tanh(),
+    nn.LazyLinear(num_cells, device=device),
+    nn.Tanh(),
+    nn.LazyLinear(1, device=device),
+)
+
+value_module = ValueOperator(
+    module=value_net,
+    in_keys=["observation"],
+)
+
+######################################################################
+# let's try our policy and value modules. As we said earlier, the usage of
+# :class:`~tensordict.nn.TensorDictModule` makes it possible to directly read the output
+# of the environment to run these modules, as they know what information to read
+# and where to write it:
+#
+print("Running policy:", policy_module(env.reset()))
+print("Running value:", value_module(env.reset()))
+
+######################################################################
+# Data collector
+# --------------
+#
+# TorchRL provides a set of `DataCollector classes <https://docs.pytorch.org/rl/stable/reference/collectors.html>`__.
+# Briefly, these classes execute three operations: reset an environment,
+# compute an action given the latest observation, execute a step in the environment,
+# and repeat the last two steps until the environment signals a stop (or reaches
+# a done state).
+#
+# They allow you to control how many frames to collect at each iteration
+# (through the ``frames_per_batch`` parameter),
+# when to reset the environment (through the ``max_frames_per_traj`` argument),
+# on which ``device`` the policy should be executed, etc. They are also
+# designed to work efficiently with batched and multiprocessed environments.
+#
+# The simplest data collector is the :class:`~torchrl.collectors.collectors.SyncDataCollector`:
+# it is an iterator that you can use to get batches of data of a given length, and
+# that will stop once a total number of frames (``total_frames``) have been
+# collected.
+# Other data collectors (:class:`~torchrl.collectors.collectors.MultiSyncDataCollector` and
+# :class:`~torchrl.collectors.collectors.MultiaSyncDataCollector`) will execute
+# the same operations in synchronous and asynchronous manner over a
+# set of multiprocessed workers.
+#
+# As for the policy and environment before, the data collector will return
+# :class:`~tensordict.TensorDict` instances with a total number of elements that will
+# match ``frames_per_batch``. Using :class:`~tensordict.TensorDict` to pass data to the
+# training loop allows you to write data loading pipelines
+# that are 100% oblivious to the actual specificities of the rollout content.
+#
+collector = SyncDataCollector(
+    env,
+    policy_module,
+    frames_per_batch=frames_per_batch,
+    total_frames=total_frames,
+    split_trajs=False,
+    device=device,
+)
+
+######################################################################
+# Replay buffer
+# -------------
+#
+# Replay buffers are a common building piece of off-policy RL algorithms.
+# In on-policy contexts, a replay buffer is refilled every time a batch of
+# data is collected, and its data is repeatedly consumed for a certain number
+# of epochs.
+#
+# TorchRL's replay buffers are built using a common container
+# :class:`~torchrl.data.ReplayBuffer` which takes as argument the components
+# of the buffer: a storage, a writer, a sampler and possibly some transforms.
+# Only the storage (which indicates the replay buffer capacity) is mandatory.
+# We also specify a sampler without repetition to avoid sampling multiple times
+# the same item in one epoch.
+# Using a replay buffer for PPO is not mandatory and we could simply
+# sample the sub-batches from the collected batch, but using these classes
+# make it easy for us to build the inner training loop in a reproducible way.
+#
+
+replay_buffer = ReplayBuffer(
+    storage=LazyTensorStorage(max_size=frames_per_batch),
+    sampler=SamplerWithoutReplacement(),
+)
+
+######################################################################
+# Loss function
+# -------------
+#
+# The PPO loss can be directly imported from TorchRL for convenience using the
+# :class:`~torchrl.objectives.ClipPPOLoss` class. This is the easiest way of utilizing PPO:
+# it hides away the mathematical operations of PPO and the control flow that
+# goes with it.
+#
+# PPO requires some "advantage estimation" to be computed. In short, an advantage
+# is a value that reflects an expectancy over the return value while dealing with
+# the bias / variance tradeoff.
+# To compute the advantage, one just needs to (1) build the advantage module, which
+# utilizes our value operator, and (2) pass each batch of data through it before each
+# epoch.
+# The GAE module will update the input ``tensordict`` with new ``"advantage"`` and
+# ``"value_target"`` entries.
+# The ``"value_target"`` is a gradient-free tensor that represents the empirical
+# value that the value network should represent with the input observation.
+# Both of these will be used by :class:`~torchrl.objectives.ClipPPOLoss` to
+# return the policy and value losses.
+#
+
+advantage_module = GAE(
+    gamma=gamma, lmbda=lmbda, value_network=value_module, average_gae=True, device=device,
+)
+
+loss_module = ClipPPOLoss(
+    actor_network=policy_module,
+    critic_network=value_module,
+    clip_epsilon=clip_epsilon,
+    entropy_bonus=bool(entropy_eps),
+    entropy_coef=entropy_eps,
+    # these keys match by default but we set this for completeness
+    critic_coef=1.0,
+    loss_critic_type="smooth_l1",
+)
+
+optim = torch.optim.Adam(loss_module.parameters(), lr)
+scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(
+    optim, total_frames // frames_per_batch, 0.0
+)
+
+######################################################################
+# Training loop
+# -------------
+# We now have all the pieces needed to code our training loop.
+# The steps include:
+#
+# * Collect data
+#
+#   * Compute advantage
+#
+#     * Loop over the collected to compute loss values
+#     * Back propagate
+#     * Optimize
+#     * Repeat
+#
+#   * Repeat
+#
+# * Repeat
+#
+
+
+logs = defaultdict(list)
+pbar = tqdm(total=total_frames)
+eval_str = ""
+
+# We iterate over the collector until it reaches the total number of frames it was
+# designed to collect:
+for i, tensordict_data in enumerate(collector):
+    # we now have a batch of data to work with. Let's learn something from it.
+    for _ in range(num_epochs):
+        # We'll need an "advantage" signal to make PPO work.
+        # We re-compute it at each epoch as its value depends on the value
+        # network which is updated in the inner loop.
+        advantage_module(tensordict_data)
+        data_view = tensordict_data.reshape(-1)
+        replay_buffer.extend(data_view.cpu())
+        for _ in range(frames_per_batch // sub_batch_size):
+            subdata = replay_buffer.sample(sub_batch_size)
+            loss_vals = loss_module(subdata.to(device))
+            loss_value = (
+                loss_vals["loss_objective"]
+                + loss_vals["loss_critic"]
+                + loss_vals["loss_entropy"]
+            )
+
+            # Optimization: backward, grad clipping and optimization step
+            loss_value.backward()
+            # this is not strictly mandatory but it's good practice to keep
+            # your gradient norm bounded
+            torch.nn.utils.clip_grad_norm_(loss_module.parameters(), max_grad_norm)
+            optim.step()
+            optim.zero_grad()
+
+    logs["reward"].append(tensordict_data["next", "reward"].mean().item())
+    pbar.update(tensordict_data.numel())
+    cum_reward_str = (
+        f"average reward={logs['reward'][-1]: 4.4f} (init={logs['reward'][0]: 4.4f})"
+    )
+    logs["step_count"].append(tensordict_data["step_count"].max().item())
+    stepcount_str = f"step count (max): {logs['step_count'][-1]}"
+    logs["lr"].append(optim.param_groups[0]["lr"])
+    lr_str = f"lr policy: {logs['lr'][-1]: 4.4f}"
+    if i % 10 == 0:
+        # We evaluate the policy once every 10 batches of data.
+        # Evaluation is rather simple: execute the policy without exploration
+        # (take the expected value of the action distribution) for a given
+        # number of steps (1000, which is our ``env`` horizon).
+        # The ``rollout`` method of the ``env`` can take a policy as argument:
+        # it will then execute this policy at each step.
+        with set_exploration_type(ExplorationType.DETERMINISTIC), torch.no_grad():
+            # execute a rollout with the trained policy
+            eval_rollout = env.rollout(1000, policy_module)
+            logs["eval reward"].append(eval_rollout["next", "reward"].mean().item())
+            logs["eval reward (sum)"].append(
+                eval_rollout["next", "reward"].sum().item()
+            )
+            logs["eval step_count"].append(eval_rollout["step_count"].max().item())
+            eval_str = (
+                f"eval cumulative reward: {logs['eval reward (sum)'][-1]: 4.4f} "
+                f"(init: {logs['eval reward (sum)'][0]: 4.4f}), "
+                f"eval step-count: {logs['eval step_count'][-1]}"
+            )
+            del eval_rollout
+    pbar.set_description(", ".join([eval_str, cum_reward_str, stepcount_str, lr_str]))
+
+    # We're also using a learning rate scheduler. Like the gradient clipping,
+    # this is a nice-to-have but nothing necessary for PPO to work.
+    scheduler.step()
+
+######################################################################
+# Results
+# -------
+#
+# Before the 1M step cap is reached, the algorithm should have reached a max
+# step count of 1000 steps, which is the maximum number of steps before the
+# trajectory is truncated.
+#
+plt.figure(figsize=(10, 10))
+plt.subplot(2, 2, 1)
+plt.plot(logs["reward"])
+plt.title("training rewards (average)")
+plt.subplot(2, 2, 2)
+plt.plot(logs["step_count"])
+plt.title("Max step count (training)")
+plt.subplot(2, 2, 3)
+plt.plot(logs["eval reward (sum)"])
+plt.title("Return (test)")
+plt.subplot(2, 2, 4)
+plt.plot(logs["eval step_count"])
+plt.title("Max step count (test)")
+plt.show()
+
+######################################################################
+# Conclusion and next steps
+# -------------------------
+#
+# In this tutorial, we have learned:
+#
+# 1. How to create and customize an environment with :py:mod:`torchrl`;
+# 2. How to write a model and a loss function;
+# 3. How to set up a typical training loop.
+#
+# If you want to experiment with this tutorial a bit more, you can apply the following modifications:
+#
+# * From an efficiency perspective,
+#   we could run several simulations in parallel to speed up data collection.
+#   Check :class:`~torchrl.envs.ParallelEnv` for further information.
+#
+# * From a logging perspective, one could add a :class:`torchrl.record.VideoRecorder` transform to
+#   the environment after asking for rendering to get a visual rendering of the
+#   inverted pendulum in action. Check :py:mod:`torchrl.record` to
+#   know more.
+#
diff --git a/intermediate_source/reinforcement_q_learning.py b/intermediate_source/reinforcement_q_learning.py
index 5540405ee3a..1e50fcb3673 100644
--- a/intermediate_source/reinforcement_q_learning.py
+++ b/intermediate_source/reinforcement_q_learning.py
@@ -3,78 +3,79 @@
 Reinforcement Learning (DQN) Tutorial
 =====================================
 **Author**: `Adam Paszke <https://github.com/apaszke>`_
+            `Mark Towers <https://github.com/pseudo-rnd-thoughts>`_
 
 
 This tutorial shows how to use PyTorch to train a Deep Q Learning (DQN) agent
-on the CartPole-v0 task from the `OpenAI Gym <https://gym.openai.com/>`__.
+on the CartPole-v1 task from `Gymnasium <https://gymnasium.farama.org>`__.
+
+You might find it helpful to read the original `Deep Q Learning (DQN) <https://arxiv.org/abs/1312.5602>`__ paper
 
 **Task**
 
 The agent has to decide between two actions - moving the cart left or
-right - so that the pole attached to it stays upright. You can find an
-official leaderboard with various algorithms and visualizations at the
-`Gym website <https://gym.openai.com/envs/CartPole-v0>`__.
+right - so that the pole attached to it stays upright. You can find more
+information about the environment and other more challenging environments at
+`Gymnasium's website <https://gymnasium.farama.org/environments/classic_control/cart_pole/>`__.
 
 .. figure:: /_static/img/cartpole.gif
-   :alt: cartpole
+   :alt: CartPole
 
-   cartpole
+   CartPole
 
 As the agent observes the current state of the environment and chooses
 an action, the environment *transitions* to a new state, and also
 returns a reward that indicates the consequences of the action. In this
 task, rewards are +1 for every incremental timestep and the environment
-terminates if the pole falls over too far or the cart moves more then 2.4
+terminates if the pole falls over too far or the cart moves more than 2.4
 units away from center. This means better performing scenarios will run
 for longer duration, accumulating larger return.
 
 The CartPole task is designed so that the inputs to the agent are 4 real
 values representing the environment state (position, velocity, etc.).
-However, neural networks can solve the task purely by looking at the
-scene, so we'll use a patch of the screen centered on the cart as an
-input. Because of this, our results aren't directly comparable to the
-ones from the official leaderboard - our task is much harder.
-Unfortunately this does slow down the training, because we have to
-render all the frames.
+We take these 4 inputs without any scaling and pass them through a 
+small fully-connected network with 2 outputs, one for each action. 
+The network is trained to predict the expected value for each action, 
+given the input state. The action with the highest expected value is 
+then chosen.
 
-Strictly speaking, we will present the state as the difference between
-the current screen patch and the previous one. This will allow the agent
-to take the velocity of the pole into account from one image.
 
 **Packages**
 
 
 First, let's import needed packages. Firstly, we need
-`gym <https://gym.openai.com/docs>`__ for the environment
-(Install using `pip install gym`).
+`gymnasium <https://gymnasium.farama.org/>`__ for the environment,
+installed by using `pip`. This is a fork of the original OpenAI
+Gym project and maintained by the same team since Gym v0.19.
+If you are running this in Google Colab, run:
+
+.. code-block:: bash
+
+   %%bash
+   pip3 install gymnasium[classic_control]
+
 We'll also use the following from PyTorch:
 
 -  neural networks (``torch.nn``)
 -  optimization (``torch.optim``)
 -  automatic differentiation (``torch.autograd``)
--  utilities for vision tasks (``torchvision`` - `a separate
-   package <https://github.com/pytorch/vision>`__).
 
 """
 
-import gym
+import gymnasium as gym
 import math
 import random
-import numpy as np
 import matplotlib
 import matplotlib.pyplot as plt
-from collections import namedtuple
+from collections import namedtuple, deque
 from itertools import count
-from PIL import Image
 
 import torch
 import torch.nn as nn
 import torch.optim as optim
 import torch.nn.functional as F
-import torchvision.transforms as T
-
 
-env = gym.make('CartPole-v0').unwrapped
+env = gym.make("CartPole-v1")
 
 # set up matplotlib
 is_ipython = 'inline' in matplotlib.get_backend()
@@ -83,8 +84,30 @@
 
 plt.ion()
 
-# if gpu is to be used
-device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+# if GPU is to be used
+device = torch.device(
+    "cuda" if torch.cuda.is_available() else
+    "mps" if torch.backends.mps.is_available() else
+    "cpu"
+)
+
+
+# To ensure reproducibility during training, you can fix the random seeds
+# by uncommenting the lines below. This makes the results consistent across
+# runs, which is helpful for debugging or comparing different approaches.
+#
+# That said, allowing randomness can be beneficial in practice, as it lets
+# the model explore different training trajectories.
+
+
+# seed = 42
+# random.seed(seed)
+# torch.manual_seed(seed)
+# env.reset(seed=seed)
+# env.action_space.seed(seed)
+# env.observation_space.seed(seed)
+# if torch.cuda.is_available(): 
+#     torch.cuda.manual_seed(seed)
 
 
 ######################################################################
@@ -97,7 +120,7 @@
 # batch are decorrelated. It has been shown that this greatly stabilizes
 # and improves the DQN training procedure.
 #
-# For this, we're going to need two classses:
+# For this, we're going to need two classes:
 #
 # -  ``Transition`` - a named tuple representing a single transition in
 #    our environment. It essentially maps (state, action) pairs
@@ -115,16 +138,11 @@
 class ReplayMemory(object):
 
     def __init__(self, capacity):
-        self.capacity = capacity
-        self.memory = []
-        self.position = 0
+        self.memory = deque([], maxlen=capacity)
 
     def push(self, *args):
-        """Saves a transition."""
-        if len(self.memory) < self.capacity:
-            self.memory.append(None)
-        self.memory[self.position] = Transition(*args)
-        self.position = (self.position + 1) % self.capacity
+        """Save a transition"""
+        self.memory.append(Transition(*args))
 
     def sample(self, batch_size):
         return random.sample(self.memory, batch_size)
@@ -134,7 +152,7 @@ def __len__(self):
 
 
 ######################################################################
-# Now, let's define our model. But first, let quickly recap what a DQN is.
+# Now, let's define our model. But first, let's quickly recap what a DQN is.
 #
 # DQN algorithm
 # -------------
@@ -149,9 +167,11 @@ def __len__(self):
 # :math:`R_{t_0} = \sum_{t=t_0}^{\infty} \gamma^{t - t_0} r_t`, where
 # :math:`R_{t_0}` is also known as the *return*. The discount,
 # :math:`\gamma`, should be a constant between :math:`0` and :math:`1`
-# that ensures the sum converges. It makes rewards from the uncertain far
-# future less important for our agent than the ones in the near future
-# that it can be fairly confident about.
+# that ensures the sum converges. A lower :math:`\gamma` makes 
+# rewards from the uncertain far future less important for our agent 
+# than the ones in the near future that it can be fairly confident 
+# about. It also encourages agents to collect reward closer in time 
+# than equivalent rewards that are temporally far away in the future.
 #
 # The main idea behind Q-learning is that if we had a function
 # :math:`Q^*: State \times Action \rightarrow \mathbb{R}`, that could tell
@@ -174,9 +194,9 @@ def __len__(self):
 # The difference between the two sides of the equality is known as the
 # temporal difference error, :math:`\delta`:
 #
-# .. math:: \delta = Q(s, a) - (r + \gamma \max_a Q(s', a))
+# .. math:: \delta = Q(s, a) - (r + \gamma \max_a' Q(s', a))
 #
-# To minimise this error, we will use the `Huber
+# To minimize this error, we will use the `Huber
 # loss <https://en.wikipedia.org/wiki/Huber_loss>`__. The Huber loss acts
 # like the mean squared error when the error is small, but like the mean
 # absolute error when the error is large - this makes it more robust to
@@ -198,7 +218,7 @@ def __len__(self):
 # Q-network
 # ^^^^^^^^^
 #
-# Our model will be a convolutional neural network that takes in the
+# Our model will be a feed forward  neural network that takes in the
 # difference between the current and previous screen patches. It has two
 # outputs, representing :math:`Q(s, \mathrm{left})` and
 # :math:`Q(s, \mathrm{right})` (where :math:`s` is the input to the
@@ -208,85 +228,18 @@ def __len__(self):
 
 class DQN(nn.Module):
 
-    def __init__(self, h, w, outputs):
+    def __init__(self, n_observations, n_actions):
         super(DQN, self).__init__()
-        self.conv1 = nn.Conv2d(3, 16, kernel_size=5, stride=2)
-        self.bn1 = nn.BatchNorm2d(16)
-        self.conv2 = nn.Conv2d(16, 32, kernel_size=5, stride=2)
-        self.bn2 = nn.BatchNorm2d(32)
-        self.conv3 = nn.Conv2d(32, 32, kernel_size=5, stride=2)
-        self.bn3 = nn.BatchNorm2d(32)
-
-        # Number of Linear input connections depends on output of conv2d layers
-        # and therefore the input image size, so compute it.
-        def conv2d_size_out(size, kernel_size = 5, stride = 2):
-            return (size - (kernel_size - 1) - 1) // stride  + 1
-        convw = conv2d_size_out(conv2d_size_out(conv2d_size_out(w)))
-        convh = conv2d_size_out(conv2d_size_out(conv2d_size_out(h)))
-        linear_input_size = convw * convh * 32
-        self.head = nn.Linear(linear_input_size, outputs)
+        self.layer1 = nn.Linear(n_observations, 128)
+        self.layer2 = nn.Linear(128, 128)
+        self.layer3 = nn.Linear(128, n_actions)
 
     # Called with either one element to determine next action, or a batch
     # during optimization. Returns tensor([[left0exp,right0exp]...]).
     def forward(self, x):
-        x = F.relu(self.bn1(self.conv1(x)))
-        x = F.relu(self.bn2(self.conv2(x)))
-        x = F.relu(self.bn3(self.conv3(x)))
-        return self.head(x.view(x.size(0), -1))
-
-
-######################################################################
-# Input extraction
-# ^^^^^^^^^^^^^^^^
-#
-# The code below are utilities for extracting and processing rendered
-# images from the environment. It uses the ``torchvision`` package, which
-# makes it easy to compose image transforms. Once you run the cell it will
-# display an example patch that it extracted.
-#
-
-resize = T.Compose([T.ToPILImage(),
-                    T.Resize(40, interpolation=Image.CUBIC),
-                    T.ToTensor()])
-
-
-def get_cart_location(screen_width):
-    world_width = env.x_threshold * 2
-    scale = screen_width / world_width
-    return int(env.state[0] * scale + screen_width / 2.0)  # MIDDLE OF CART
-
-def get_screen():
-    # Returned screen requested by gym is 400x600x3, but is sometimes larger
-    # such as 800x1200x3. Transpose it into torch order (CHW).
-    screen = env.render(mode='rgb_array').transpose((2, 0, 1))
-    # Cart is in the lower half, so strip off the top and bottom of the screen
-    _, screen_height, screen_width = screen.shape
-    screen = screen[:, int(screen_height*0.4):int(screen_height * 0.8)]
-    view_width = int(screen_width * 0.6)
-    cart_location = get_cart_location(screen_width)
-    if cart_location < view_width // 2:
-        slice_range = slice(view_width)
-    elif cart_location > (screen_width - view_width // 2):
-        slice_range = slice(-view_width, None)
-    else:
-        slice_range = slice(cart_location - view_width // 2,
-                            cart_location + view_width // 2)
-    # Strip off the edges, so that we have a square image centered on a cart
-    screen = screen[:, :, slice_range]
-    # Convert to float, rescale, convert to torch tensor
-    # (this doesn't require a copy)
-    screen = np.ascontiguousarray(screen, dtype=np.float32) / 255
-    screen = torch.from_numpy(screen)
-    # Resize, and add a batch dimension (BCHW)
-    return resize(screen).unsqueeze(0).to(device)
-
-
-env.reset()
-plt.figure()
-plt.imshow(get_screen().cpu().squeeze(0).permute(1, 2, 0).numpy(),
-           interpolation='none')
-plt.title('Example extracted screen')
-plt.show()
+        x = F.relu(self.layer1(x))
+        x = F.relu(self.layer2(x))
+        return self.layer3(x)
 
 
 ######################################################################
@@ -298,41 +251,47 @@ def get_screen():
 # This cell instantiates our model and its optimizer, and defines some
 # utilities:
 #
-# -  ``select_action`` - will select an action accordingly to an epsilon
+# -  ``select_action`` - will select an action according to an epsilon
 #    greedy policy. Simply put, we'll sometimes use our model for choosing
 #    the action, and sometimes we'll just sample one uniformly. The
 #    probability of choosing a random action will start at ``EPS_START``
 #    and will decay exponentially towards ``EPS_END``. ``EPS_DECAY``
 #    controls the rate of the decay.
-# -  ``plot_durations`` - a helper for plotting the durations of episodes,
+# -  ``plot_durations`` - a helper for plotting the duration of episodes,
 #    along with an average over the last 100 episodes (the measure used in
 #    the official evaluations). The plot will be underneath the cell
 #    containing the main training loop, and will update after every
 #    episode.
 #
 
+# BATCH_SIZE is the number of transitions sampled from the replay buffer
+# GAMMA is the discount factor as mentioned in the previous section
+# EPS_START is the starting value of epsilon
+# EPS_END is the final value of epsilon
+# EPS_DECAY controls the rate of exponential decay of epsilon, higher means a slower decay
+# TAU is the update rate of the target network
+# LR is the learning rate of the ``AdamW`` optimizer
+
 BATCH_SIZE = 128
-GAMMA = 0.999
+GAMMA = 0.99
 EPS_START = 0.9
-EPS_END = 0.05
-EPS_DECAY = 200
-TARGET_UPDATE = 10
+EPS_END = 0.01
+EPS_DECAY = 2500
+TAU = 0.005
+LR = 3e-4
 
-# Get screen size so that we can initialize layers correctly based on shape
-# returned from AI gym. Typical dimensions at this point are close to 3x40x90
-# which is the result of a clamped and down-scaled render buffer in get_screen()
-init_screen = get_screen()
-_, _, screen_height, screen_width = init_screen.shape
 
 # Get number of actions from gym action space
 n_actions = env.action_space.n
+# Get the number of state observations
+state, info = env.reset()
+n_observations = len(state)
 
-policy_net = DQN(screen_height, screen_width, n_actions).to(device)
-target_net = DQN(screen_height, screen_width, n_actions).to(device)
+policy_net = DQN(n_observations, n_actions).to(device)
+target_net = DQN(n_observations, n_actions).to(device)
 target_net.load_state_dict(policy_net.state_dict())
-target_net.eval()
 
-optimizer = optim.RMSprop(policy_net.parameters())
+optimizer = optim.AdamW(policy_net.parameters(), lr=LR, amsgrad=True)
 memory = ReplayMemory(10000)
 
 
@@ -347,22 +306,25 @@ def select_action(state):
     steps_done += 1
     if sample > eps_threshold:
         with torch.no_grad():
-            # t.max(1) will return largest column value of each row.
+            # t.max(1) will return the largest column value of each row.
             # second column on max result is index of where max element was
             # found, so we pick action with the larger expected reward.
-            return policy_net(state).max(1)[1].view(1, 1)
+            return policy_net(state).max(1).indices.view(1, 1)
     else:
-        return torch.tensor([[random.randrange(n_actions)]], device=device, dtype=torch.long)
+        return torch.tensor([[env.action_space.sample()]], device=device, dtype=torch.long)
 
 
 episode_durations = []
 
 
-def plot_durations():
-    plt.figure(2)
-    plt.clf()
+def plot_durations(show_result=False):
+    plt.figure(1)
     durations_t = torch.tensor(episode_durations, dtype=torch.float)
-    plt.title('Training...')
+    if show_result:
+        plt.title('Result')
+    else:
+        plt.clf()
+        plt.title('Training...')
     plt.xlabel('Episode')
     plt.ylabel('Duration')
     plt.plot(durations_t.numpy())
@@ -374,8 +336,11 @@ def plot_durations():
 
     plt.pause(0.001)  # pause a bit so that plots are updated
     if is_ipython:
-        display.clear_output(wait=True)
-        display.display(plt.gcf())
+        if not show_result:
+            display.display(plt.gcf())
+            display.clear_output(wait=True)
+        else:
+            display.display(plt.gcf())
 
 
 ######################################################################
@@ -388,12 +353,11 @@ def plot_durations():
 # single step of the optimization. It first samples a batch, concatenates
 # all the tensors into a single one, computes :math:`Q(s_t, a_t)` and
 # :math:`V(s_{t+1}) = \max_a Q(s_{t+1}, a)`, and combines them into our
-# loss. By defition we set :math:`V(s) = 0` if :math:`s` is a terminal
+# loss. By definition we set :math:`V(s) = 0` if :math:`s` is a terminal
 # state. We also use a target network to compute :math:`V(s_{t+1})` for
-# added stability. The target network has its weights kept frozen most of
-# the time, but is updated with the policy network's weights every so often.
-# This is usually a set number of steps but we shall use episodes for
-# simplicity.
+# added stability. The target network is updated at every step with a 
+# `soft update <https://arxiv.org/pdf/1509.02971.pdf>`__ controlled by 
+# the hyperparameter ``TAU``, which was previously defined.
 #
 
 def optimize_model():
@@ -408,7 +372,7 @@ def optimize_model():
     # Compute a mask of non-final states and concatenate the batch elements
     # (a final state would've been the one after which simulation ended)
     non_final_mask = torch.tensor(tuple(map(lambda s: s is not None,
-                                          batch.next_state)), device=device, dtype=torch.uint8)
+                                          batch.next_state)), device=device, dtype=torch.bool)
     non_final_next_states = torch.cat([s for s in batch.next_state
                                                 if s is not None])
     state_batch = torch.cat(batch.state)
@@ -422,58 +386,62 @@ def optimize_model():
 
     # Compute V(s_{t+1}) for all next states.
     # Expected values of actions for non_final_next_states are computed based
-    # on the "older" target_net; selecting their best reward with max(1)[0].
+    # on the "older" target_net; selecting their best reward with max(1).values
     # This is merged based on the mask, such that we'll have either the expected
     # state value or 0 in case the state was final.
     next_state_values = torch.zeros(BATCH_SIZE, device=device)
-    next_state_values[non_final_mask] = target_net(non_final_next_states).max(1)[0].detach()
+    with torch.no_grad():
+        next_state_values[non_final_mask] = target_net(non_final_next_states).max(1).values
     # Compute the expected Q values
     expected_state_action_values = (next_state_values * GAMMA) + reward_batch
 
     # Compute Huber loss
-    loss = F.smooth_l1_loss(state_action_values, expected_state_action_values.unsqueeze(1))
+    criterion = nn.SmoothL1Loss()
+    loss = criterion(state_action_values, expected_state_action_values.unsqueeze(1))
 
     # Optimize the model
     optimizer.zero_grad()
     loss.backward()
-    for param in policy_net.parameters():
-        param.grad.data.clamp_(-1, 1)
+    # In-place gradient clipping
+    torch.nn.utils.clip_grad_value_(policy_net.parameters(), 100)
     optimizer.step()
 
 
 ######################################################################
 #
 # Below, you can find the main training loop. At the beginning we reset
-# the environment and initialize the ``state`` Tensor. Then, we sample
-# an action, execute it, observe the next screen and the reward (always
+# the environment and obtain the initial ``state`` Tensor. Then, we sample
+# an action, execute it, observe the next state and the reward (always
 # 1), and optimize our model once. When the episode ends (our model
 # fails), we restart the loop.
 #
-# Below, `num_episodes` is set small. You should download
-# the notebook and run lot more epsiodes, such as 300+ for meaningful
-# duration improvements.
+# Below, `num_episodes` is set to 600 if a GPU is available, otherwise 50 
+# episodes are scheduled so training does not take too long. However, 50 
+# episodes is insufficient for to observe good performance on CartPole.
+# You should see the model constantly achieve 500 steps within 600 training 
+# episodes. Training RL agents can be a noisy process, so restarting training
+# can produce better results if convergence is not observed.
 #
 
-num_episodes = 50
+if torch.cuda.is_available() or torch.backends.mps.is_available():
+    num_episodes = 600
+else:
+    num_episodes = 50
+
 for i_episode in range(num_episodes):
-    # Initialize the environment and state
-    env.reset()
-    last_screen = get_screen()
-    current_screen = get_screen()
-    state = current_screen - last_screen
+    # Initialize the environment and get its state
+    state, info = env.reset()
+    state = torch.tensor(state, dtype=torch.float32, device=device).unsqueeze(0)
     for t in count():
-        # Select and perform an action
         action = select_action(state)
-        _, reward, done, _ = env.step(action.item())
+        observation, reward, terminated, truncated, _ = env.step(action.item())
         reward = torch.tensor([reward], device=device)
+        done = terminated or truncated
 
-        # Observe new state
-        last_screen = current_screen
-        current_screen = get_screen()
-        if not done:
-            next_state = current_screen - last_screen
-        else:
+        if terminated:
             next_state = None
+        else:
+            next_state = torch.tensor(observation, dtype=torch.float32, device=device).unsqueeze(0)
 
         # Store the transition in memory
         memory.push(state, action, next_state, reward)
@@ -481,19 +449,24 @@ def optimize_model():
         # Move to the next state
         state = next_state
 
-        # Perform one step of the optimization (on the target network)
+        # Perform one step of the optimization (on the policy network)
         optimize_model()
+
+        # Soft update of the target network's weights
+        # θ′ ← τ θ + (1 −τ )θ′
+        target_net_state_dict = target_net.state_dict()
+        policy_net_state_dict = policy_net.state_dict()
+        for key in policy_net_state_dict:
+            target_net_state_dict[key] = policy_net_state_dict[key]*TAU + target_net_state_dict[key]*(1-TAU)
+        target_net.load_state_dict(target_net_state_dict)
+
         if done:
             episode_durations.append(t + 1)
             plot_durations()
             break
-    # Update the target network, copying all weights and biases in DQN
-    if i_episode % TARGET_UPDATE == 0:
-        target_net.load_state_dict(policy_net.state_dict())
 
 print('Complete')
-env.render()
-env.close()
+plot_durations(show_result=True)
 plt.ioff()
 plt.show()
 
@@ -506,6 +479,6 @@ def optimize_model():
 # step sample from the gym environment. We record the results in the
 # replay memory and also run optimization step on every iteration.
 # Optimization picks a random batch from the replay memory to do training of the
-# new policy. "Older" target_net is also used in optimization to compute the
-# expected Q values; it is updated occasionally to keep it current.
+# new policy. The "older" target_net is also used in optimization to compute the
+# expected Q values. A soft update of its weights are performed at every step.
 #
diff --git a/intermediate_source/rpc_async_execution.rst b/intermediate_source/rpc_async_execution.rst
new file mode 100644
index 00000000000..4c7739104cc
--- /dev/null
+++ b/intermediate_source/rpc_async_execution.rst
@@ -0,0 +1,523 @@
+Implementing Batch RPC Processing Using Asynchronous Executions
+===============================================================
+**Author**: `Shen Li <https://mrshenli.github.io/>`_
+
+.. note::
+   |edit| View and edit this tutorial in `github <https://github.com/pytorch/tutorials/blob/main/intermediate_source/rpc_async_execution.rst>`__.
+
+Prerequisites:
+
+-  `PyTorch Distributed Overview <../beginner/dist_overview.html>`__
+-  `Getting started with Distributed RPC Framework <rpc_tutorial.html>`__
+-  `Implementing a Parameter Server using Distributed RPC Framework <rpc_param_server_tutorial.html>`__
+-  `RPC Asynchronous Execution Decorator <https://pytorch.org/docs/master/rpc.html#torch.distributed.rpc.functions.async_execution>`__
+
+This tutorial demonstrates how to build batch-processing RPC applications with
+the `@rpc.functions.async_execution <https://pytorch.org/docs/master/rpc.html#torch.distributed.rpc.functions.async_execution>`__
+decorator, which helps to speed up training by reducing the number of blocked
+RPC threads and consolidating CUDA operations on the callee.
+
+.. note:: This tutorial requires PyTorch v1.6.0 or above.
+
+Basics
+------
+
+Previous tutorials have shown the steps to build distributed training
+applications using `torch.distributed.rpc <https://pytorch.org/docs/stable/rpc.html>`__,
+but they didn't elaborate on what happens on the callee side when processing an
+RPC request. As of PyTorch v1.5, each RPC request will block one thread on the
+callee to execute the function in that request until that function returns.
+This works for many use cases, but there is one caveat. If the user function
+blocks on IO, e.g., with nested RPC invocation, or signaling, e.g., waiting for
+a different RPC request to unblock, the RPC thread on the callee will have to
+idle waiting until the IO finishes or the signaling event occurs. As a result,
+RPC callees are likely to use more threads than necessary. The cause of this
+problem is that RPC treats user functions as black boxes, and knows very little
+about what happens in the function. To allow user functions to yield and free
+RPC threads, more hints need to be provided to the RPC system.
+
+Since v1.6.0, PyTorch addresses this problem by introducing two new concepts:
+
+* A `torch.futures.Future <https://pytorch.org/docs/master/futures.html>`__ type
+  that encapsulates an asynchronous execution, which also supports installing
+  callback functions.
+* An `@rpc.functions.async_execution <https://pytorch.org/docs/master/rpc.html#torch.distributed.rpc.functions.async_execution>`__
+  decorator that allows applications to tell the callee that the target function
+  will return a future and can pause and yield multiple times during execution.
+
+With these two tools, the application code can break a user function into
+multiple smaller functions, chain them together as callbacks on ``Future``
+objects, and return the ``Future`` that contains the final result. On the callee
+side, when getting the ``Future`` object, it installs subsequent RPC response
+preparation and communication as callbacks as well, which will be triggered
+when the final result is ready. In this way, the callee no longer needs to block
+one thread and wait until the final return value is ready. Please refer to the
+API doc of
+`@rpc.functions.async_execution <https://pytorch.org/docs/master/rpc.html#torch.distributed.rpc.functions.async_execution>`__
+for simple examples.
+
+Besides reducing the number of idle threads on the callee, these tools also help
+to make batch RPC processing easier and faster. The following two sections of
+this tutorial demonstrate how to build distributed batch-updating parameter
+server and batch-processing reinforcement learning applications using the
+`@rpc.functions.async_execution <https://pytorch.org/docs/master/rpc.html#torch.distributed.rpc.functions.async_execution>`__
+decorator.
+
+Batch-Updating Parameter Server
+-------------------------------
+
+Consider a synchronized parameter server training application with one parameter
+server (PS) and multiple trainers. In this application, the PS holds the
+parameters and waits for all trainers to report gradients. In every iteration,
+it waits until receiving gradients from all trainers and then updates all
+parameters in one shot. The code below shows the implementation of the PS class.
+The ``update_and_fetch_model`` method is decorated using
+``@rpc.functions.async_execution`` and will be called by trainers. Each
+invocation returns a ``Future`` object that will be populated with the updated
+model. Invocations launched by most trainers just accumulate gradients to the
+``.grad`` field, return immediately, and yield the RPC thread on the PS. The
+last arriving trainer will trigger the optimizer step and consume all previously
+reported gradients. Then it sets the ``future_model`` with the updated model,
+which in turn notifies all previous requests from other trainers through the
+``Future`` object and sends out the updated model to all trainers.
+
+.. code:: python
+
+    import threading
+    import torchvision
+    import torch
+    import torch.distributed.rpc as rpc
+    from torch import optim
+
+    num_classes, batch_update_size = 30, 5
+
+    class BatchUpdateParameterServer(object):
+        def __init__(self, batch_update_size=batch_update_size):
+            self.model = torchvision.models.resnet50(num_classes=num_classes)
+            self.lock = threading.Lock()
+            self.future_model = torch.futures.Future()
+            self.batch_update_size = batch_update_size
+            self.curr_update_size = 0
+            self.optimizer = optim.SGD(self.model.parameters(), lr=0.001, momentum=0.9)
+            for p in self.model.parameters():
+                p.grad = torch.zeros_like(p)
+
+        def get_model(self):
+            return self.model
+
+        @staticmethod
+        @rpc.functions.async_execution
+        def update_and_fetch_model(ps_rref, grads):
+            # Using the RRef to retrieve the local PS instance
+            self = ps_rref.local_value()
+            with self.lock:
+                self.curr_update_size += 1
+                # accumulate gradients into .grad field
+                for p, g in zip(self.model.parameters(), grads):
+                    p.grad += g
+
+                # Save the current future_model and return it to make sure the
+                # returned Future object holds the correct model even if another
+                # thread modifies future_model before this thread returns.
+                fut = self.future_model
+
+                if self.curr_update_size >= self.batch_update_size:
+                    # update the model
+                    for p in self.model.parameters():
+                        p.grad /= self.batch_update_size
+                    self.curr_update_size = 0
+                    self.optimizer.step()
+                    self.optimizer.zero_grad()
+                    # by settiing the result on the Future object, all previous
+                    # requests expecting this updated model will be notified and
+                    # the their responses will be sent accordingly.
+                    fut.set_result(self.model)
+                    self.future_model = torch.futures.Future()
+
+            return fut
+
+For the trainers, they are all initialized using the same set of
+parameters from the PS. In every iteration, each trainer first runs the forward
+and the backward passes to generate gradients locally. Then, each trainer
+reports its gradients to the PS using RPC, and fetches back the updated
+parameters through the return value of the same RPC request. In the trainer's
+implementation, whether the target function is marked with
+``@rpc.functions.async_execution`` or not makes no difference. The
+trainer simply calls ``update_and_fetch_model`` using ``rpc_sync`` which will
+block on the trainer until the updated model is returned.
+
+.. code:: python
+
+    batch_size, image_w, image_h  = 20, 64, 64
+
+    class Trainer(object):
+        def __init__(self, ps_rref):
+            self.ps_rref, self.loss_fn = ps_rref, torch.nn.MSELoss()
+            self.one_hot_indices = torch.LongTensor(batch_size) \
+                                        .random_(0, num_classes) \
+                                        .view(batch_size, 1)
+
+        def get_next_batch(self):
+            for _ in range(6):
+                inputs = torch.randn(batch_size, 3, image_w, image_h)
+                labels = torch.zeros(batch_size, num_classes) \
+                            .scatter_(1, self.one_hot_indices, 1)
+                yield inputs.cuda(), labels.cuda()
+
+        def train(self):
+            name = rpc.get_worker_info().name
+            # get initial model parameters
+            m = self.ps_rref.rpc_sync().get_model().cuda()
+            # start training
+            for inputs, labels in self.get_next_batch():
+                self.loss_fn(m(inputs), labels).backward()
+                m = rpc.rpc_sync(
+                    self.ps_rref.owner(),
+                    BatchUpdateParameterServer.update_and_fetch_model,
+                    args=(self.ps_rref, [p.grad for p in m.cpu().parameters()]),
+                ).cuda()
+
+We skip the code that launches multiple processes in this tutorial and please
+refer to the `examples <https://github.com/pytorch/examples/tree/master/distributed/rpc>`__
+repo for the full implementation. Note that, it is possible to implement batch
+processing without the
+`@rpc.functions.async_execution <https://pytorch.org/docs/master/rpc.html#torch.distributed.rpc.functions.async_execution>`__
+decorator. However, that would require either blocking more RPC threads on
+the PS or use another round of RPC to fetch updated models, where the latter
+would add both more code complexity and more communication overhead.
+
+This section uses a simple parameter sever training example to show how to
+implement batch RPC applications using the
+`@rpc.functions.async_execution <https://pytorch.org/docs/master/rpc.html#torch.distributed.rpc.functions.async_execution>`__
+decorator. In the next section, we re-implement the reinforcement learning
+example in the previous
+`Getting started with Distributed RPC Framework <https://pytorch.org/tutorials/intermediate/rpc_tutorial.html>`__
+tutorial using batch processing, and demonstrate its impact on the training
+speed.
+
+Batch-Processing CartPole Solver
+--------------------------------
+
+This section uses CartPole-v1 from OpenAI Gym as
+an example to show the performance impact of batch processing RPC. Please note
+that since the goal is to demonstrate the usage of
+`@rpc.functions.async_execution <https://pytorch.org/docs/master/rpc.html#torch.distributed.rpc.functions.async_execution>`__
+instead of building the best CartPole solver or solving most different RL
+problems, we use very simple policies and reward calculation strategies and
+focus on the multi-observer single-agent batch RPC implementation. We use a
+similar ``Policy`` model as the previous tutorial which is shown below. Compared
+to the previous tutorial, the difference is that its constructor takes an
+additional ``batch`` argument which controls the ``dim`` parameter for
+``F.softmax`` because with batching, the ``x`` argument in the ``forward``
+function contains states from multiple observers and hence the dimension needs
+to change properly. Everything else stays intact.
+
+.. code:: python
+
+    import argparse
+    import torch.nn as nn
+    import torch.nn.functional as F
+
+    parser = argparse.ArgumentParser(description='PyTorch RPC Batch RL example')
+    parser.add_argument('--gamma', type=float, default=1.0, metavar='G',
+                        help='discount factor (default: 1.0)')
+    parser.add_argument('--seed', type=int, default=543, metavar='N',
+                        help='random seed (default: 543)')
+    parser.add_argument('--num-episode', type=int, default=10, metavar='E',
+                        help='number of episodes (default: 10)')
+    args = parser.parse_args()
+
+    torch.manual_seed(args.seed)
+
+    class Policy(nn.Module):
+        def __init__(self, batch=True):
+            super(Policy, self).__init__()
+            self.affine1 = nn.Linear(4, 128)
+            self.dropout = nn.Dropout(p=0.6)
+            self.affine2 = nn.Linear(128, 2)
+            self.dim = 2 if batch else 1
+
+        def forward(self, x):
+            x = self.affine1(x)
+            x = self.dropout(x)
+            x = F.relu(x)
+            action_scores = self.affine2(x)
+            return F.softmax(action_scores, dim=self.dim)
+
+
+The constructor of the ``Observer`` adjusts accordingly as well. It also takes a
+``batch`` argument, which governs which ``Agent`` function it uses to select
+actions. In batch mode, it calls ``select_action_batch`` function on ``Agent``
+which will be presented shortly, and this function will be decorated with
+`@rpc.functions.async_execution <https://pytorch.org/docs/master/rpc.html#torch.distributed.rpc.functions.async_execution>`__.
+
+
+.. code:: python
+
+    import gym
+    import torch.distributed.rpc as rpc
+
+    class Observer:
+        def __init__(self, batch=True):
+            self.id = rpc.get_worker_info().id - 1
+            self.env = gym.make('CartPole-v1')
+            self.env.seed(args.seed)
+            self.select_action = Agent.select_action_batch if batch else Agent.select_action
+
+Compared to the previous tutorial
+`Getting started with Distributed RPC Framework <https://pytorch.org/tutorials/intermediate/rpc_tutorial.html>`__,
+observers behave a little differently. Instead of exiting when the environment
+is stopped, it always runs ``n_steps`` iterations in every episode. When the
+environment returns, the observer simply resets the environment and start over
+again. With this design, the agent will receive a fixed number of states from
+every observer and hence can pack them into a fixed-size tensor. In every
+step, the ``Observer`` uses RPC to send its state to the ``Agent`` and fetches
+the action through the return value. At the end of every episode, it returns the
+rewards of all steps to ``Agent``. Note that this ``run_episode`` function will
+be called by the ``Agent`` using RPC. So the ``rpc_sync`` call in this function
+will be a nested RPC invocation. We could mark this function as ``@rpc.functions.async_execution``
+too to avoid blocking one thread on the ``Observer``. However, as the bottleneck
+is the ``Agent`` instead of the ``Observer``, it should be OK to block one
+thread on the ``Observer`` process.
+
+
+.. code:: python
+
+    import torch
+
+    class Observer:
+        ...
+
+        def run_episode(self, agent_rref, n_steps):
+            state, ep_reward = self.env.reset(), NUM_STEPS
+            rewards = torch.zeros(n_steps)
+            start_step = 0
+            for step in range(n_steps):
+                state = torch.from_numpy(state).float().unsqueeze(0)
+                # send the state to the agent to get an action
+                action = rpc.rpc_sync(
+                    agent_rref.owner(),
+                    self.select_action,
+                    args=(agent_rref, self.id, state)
+                )
+
+                # apply the action to the environment, and get the reward
+                state, reward, done, _ = self.env.step(action)
+                rewards[step] = reward
+
+                if done or step + 1 >= n_steps:
+                    curr_rewards = rewards[start_step:(step + 1)]
+                    R = 0
+                    for i in range(curr_rewards.numel() -1, -1, -1):
+                        R = curr_rewards[i] + args.gamma * R
+                        curr_rewards[i] = R
+                    state = self.env.reset()
+                    if start_step == 0:
+                        ep_reward = min(ep_reward, step - start_step + 1)
+                    start_step = step + 1
+
+            return [rewards, ep_reward]
+
+The constructor of the ``Agent`` also takes a ``batch`` argument, which controls
+how action probs are batched. In batch mode, the ``saved_log_probs`` contains a
+list of tensors, where each tensor contains action robs from all observers in
+one step. Without batching, the ``saved_log_probs`` is a dictionary where the
+key is the observer id and the value is a list of action probs for that
+observer.
+
+.. code:: python
+
+    import threading
+    from torch.distributed.rpc import RRef
+
+    class Agent:
+        def __init__(self, world_size, batch=True):
+            self.ob_rrefs = []
+            self.agent_rref = RRef(self)
+            self.rewards = {}
+            self.policy = Policy(batch).cuda()
+            self.optimizer = optim.Adam(self.policy.parameters(), lr=1e-2)
+            self.running_reward = 0
+
+            for ob_rank in range(1, world_size):
+                ob_info = rpc.get_worker_info(OBSERVER_NAME.format(ob_rank))
+                self.ob_rrefs.append(rpc.remote(ob_info, Observer, args=(batch,)))
+                self.rewards[ob_info.id] = []
+
+            self.states = torch.zeros(len(self.ob_rrefs), 1, 4)
+            self.batch = batch
+            self.saved_log_probs = [] if batch else {k:[] for k in range(len(self.ob_rrefs))}
+            self.future_actions = torch.futures.Future()
+            self.lock = threading.Lock()
+            self.pending_states = len(self.ob_rrefs)
+
+The non-batching ``select_acion`` simply runs the state throw the policy, saves
+the action prob, and returns the action to the observer right away.
+
+.. code:: python
+
+    from torch.distributions import Categorical
+
+    class Agent:
+        ...
+
+        @staticmethod
+        def select_action(agent_rref, ob_id, state):
+            self = agent_rref.local_value()
+            probs = self.policy(state.cuda())
+            m = Categorical(probs)
+            action = m.sample()
+            self.saved_log_probs[ob_id].append(m.log_prob(action))
+            return action.item()
+
+With batching, the state is stored in a 2D tensor ``self.states``, using the
+observer id as the row id. Then, it chains a ``Future`` by installing a callback
+function to the batch-generated ``self.future_actions`` ``Future`` object, which
+will be populated with the specific row indexed using the id of that observer.
+The last arriving observer runs all batched states through the policy in one
+shot and set  ``self.future_actions`` accordingly. When this occurs, all the
+callback functions installed on ``self.future_actions`` will be triggered and
+their return values will be used to populate the chained ``Future`` object,
+which in turn notifies the ``Agent`` to prepare and communicate responses for
+all previous RPC requests from other observers.
+
+.. code:: python
+
+    class Agent:
+        ...
+
+        @staticmethod
+        @rpc.functions.async_execution
+        def select_action_batch(agent_rref, ob_id, state):
+            self = agent_rref.local_value()
+            self.states[ob_id].copy_(state)
+            future_action = self.future_actions.then(
+                lambda future_actions: future_actions.wait()[ob_id].item()
+            )
+
+            with self.lock:
+                self.pending_states -= 1
+                if self.pending_states == 0:
+                    self.pending_states = len(self.ob_rrefs)
+                    probs = self.policy(self.states.cuda())
+                    m = Categorical(probs)
+                    actions = m.sample()
+                    self.saved_log_probs.append(m.log_prob(actions).t()[0])
+                    future_actions = self.future_actions
+                    self.future_actions = torch.futures.Future()
+                    future_actions.set_result(actions.cpu())
+            return future_action
+
+Now let's define how different RPC functions are stitched together. The ``Agent``
+controls the execution of every episode. It first uses ``rpc_async`` to kick off
+the episode on all observers and block on the returned futures which will be
+populated with observer rewards. Note that the code below uses the RRef helper
+``ob_rref.rpc_async()`` to launch the ``run_episode`` function on the owner
+of the ``ob_rref`` RRef with the provided arguments.
+It then converts the saved action probs and returned observer rewards into
+expected data format, and launch the training step. Finally, it resets all
+states and returns the reward of the current episode. This function is the entry
+point to run one episode.
+
+.. code:: python
+
+    class Agent:
+        ...
+
+        def run_episode(self, n_steps=0):
+            futs = []
+            for ob_rref in self.ob_rrefs:
+                # make async RPC to kick off an episode on all observers
+                futs.append(ob_rref.rpc_async().run_episode(self.agent_rref, n_steps))
+
+            # wait until all obervers have finished this episode
+            rets = torch.futures.wait_all(futs)
+            rewards = torch.stack([ret[0] for ret in rets]).cuda().t()
+            ep_rewards = sum([ret[1] for ret in rets]) / len(rets)
+
+            # stack saved probs into one tensor
+            if self.batch:
+                probs = torch.stack(self.saved_log_probs)
+            else:
+                probs = [torch.stack(self.saved_log_probs[i]) for i in range(len(rets))]
+                probs = torch.stack(probs)
+
+            policy_loss = -probs * rewards / len(rets)
+            policy_loss.sum().backward()
+            self.optimizer.step()
+            self.optimizer.zero_grad()
+
+            # reset variables
+            self.saved_log_probs = [] if self.batch else {k:[] for k in range(len(self.ob_rrefs))}
+            self.states = torch.zeros(len(self.ob_rrefs), 1, 4)
+
+            # calculate running rewards
+            self.running_reward = 0.5 * ep_rewards + 0.5 * self.running_reward
+            return ep_rewards, self.running_reward
+
+The rest of the code is normal processes launching and logging which are
+similar to other RPC tutorials. In this tutorial, all observers passively
+waiting for commands from the agent. Please refer to the
+`examples <https://github.com/pytorch/examples/tree/master/distributed/rpc>`__
+repo for the full implementation.
+
+.. code:: python
+
+    def run_worker(rank, world_size, n_episode, batch, print_log=True):
+        os.environ['MASTER_ADDR'] = 'localhost'
+        os.environ['MASTER_PORT'] = '29500'
+        if rank == 0:
+            # rank0 is the agent
+            rpc.init_rpc(AGENT_NAME, rank=rank, world_size=world_size)
+
+            agent = Agent(world_size, batch)
+            for i_episode in range(n_episode):
+                last_reward, running_reward = agent.run_episode(n_steps=NUM_STEPS)
+
+                if print_log:
+                    print('Episode {}\tLast reward: {:.2f}\tAverage reward: {:.2f}'.format(
+                        i_episode, last_reward, running_reward))
+        else:
+            # other ranks are the observer
+            rpc.init_rpc(OBSERVER_NAME.format(rank), rank=rank, world_size=world_size)
+            # observers passively waiting for instructions from agents
+        rpc.shutdown()
+
+
+    def main():
+        for world_size in range(2, 12):
+            delays = []
+            for batch in [True, False]:
+                tik = time.time()
+                mp.spawn(
+                    run_worker,
+                    args=(world_size, args.num_episode, batch),
+                    nprocs=world_size,
+                    join=True
+                )
+                tok = time.time()
+                delays.append(tok - tik)
+
+            print(f"{world_size}, {delays[0]}, {delays[1]}")
+
+
+    if __name__ == '__main__':
+        main()
+
+Batch RPC helps to consolidate the action inference into less CUDA operations,
+and hence reduces the amortized overhead. The above ``main`` function runs the
+same code on both batch and no-batch modes using different numbers of observers,
+ranging from 1 to 10. The figure below plots the execution time of different
+world sizes using default argument values. The results confirmed our expectation
+that batch processing helped to speed up training.
+
+
+.. figure:: /_static/img/rpc-images/batch.png
+    :alt:
+
+Learn More
+----------
+
+-  `Batch-Updating Parameter Server Source Code <https://github.com/pytorch/examples/blob/master/distributed/rpc/batch/parameter_server.py>`__
+-  `Batch-Processing CartPole Solver <https://github.com/pytorch/examples/blob/master/distributed/rpc/batch/reinforce.py>`__
+-  `Distributed Autograd <https://pytorch.org/docs/master/rpc.html#distributed-autograd-framework>`__
diff --git a/intermediate_source/rpc_param_server_tutorial.rst b/intermediate_source/rpc_param_server_tutorial.rst
new file mode 100644
index 00000000000..324331646c5
--- /dev/null
+++ b/intermediate_source/rpc_param_server_tutorial.rst
@@ -0,0 +1,386 @@
+
+Implementing a Parameter Server Using Distributed RPC Framework
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+**Author**\ : `Rohan Varma <https://github.com/rohan-varma>`_
+
+.. note::
+   |edit| View and edit this tutorial in `github <https://github.com/pytorch/tutorials/blob/main/intermediate_source/rpc_param_server_tutorial.rst>`__.
+
+Prerequisites:
+
+-  `PyTorch Distributed Overview <../beginner/dist_overview.html>`__
+-  `RPC API documents <https://pytorch.org/docs/master/rpc.html>`__
+
+This tutorial walks through a simple example of implementing a parameter server using PyTorch's `Distributed RPC framework <https://pytorch.org/docs/stable/rpc.html>`_. The parameter server framework is a paradigm in which a set of servers store parameters, such as large embedding tables, and several trainers query the parameter servers in order to retrieve the most up to date parameters. These trainers can run a training loop locally and occasionally synchronize with the parameter server to get the latest parameters. For more reading on the parameter server approach, check out `this paper <https://www.cs.cmu.edu/~muli/file/parameter_server_osdi14.pdf>`_.
+
+Using the Distributed RPC Framework, we'll build an example where multiple trainers use RPC to communicate with the same parameter server and use `RRef <https://pytorch.org/docs/stable/rpc.html#torch.distributed.rpc.RRef>`_ to access states on the remote parameter server instance. Each trainer will launch its dedicated backward pass in a distributed fashion through stitching of the autograd graph across multiple nodes using distributed autograd.
+
+**Note**\ : This tutorial covers the use of the Distributed RPC Framework, which is useful for splitting a model onto multiple machines, or for implementing a parameter-server training strategy where network trainers fetch parameters hosted on a different machine. If instead you are looking for replicating your model across many GPUs, please see the `Distributed Data Parallel tutorial <https://pytorch.org/tutorials/intermediate/ddp_tutorial.html>`_. There is also another `RPC tutorial <https://pytorch.org/tutorials/intermediate/rpc_tutorial.html>`_ that covers reinforcement learning and RNN use cases.
+
+Let's start with the familiar: importing our required modules and defining a simple ConvNet that will train on the MNIST dataset. The below network is largely adopted from the network defined in the `pytorch/examples repo <https://github.com/pytorch/examples/tree/master/mnist>`_.
+
+.. code-block:: python
+
+   import argparse
+   import os
+   import time
+   from threading import Lock
+
+   import torch
+   import torch.distributed.autograd as dist_autograd
+   import torch.distributed.rpc as rpc
+   import torch.multiprocessing as mp
+   import torch.nn as nn
+   import torch.nn.functional as F
+   from torch import optim
+   from torch.distributed.optim import DistributedOptimizer
+   from torchvision import datasets, transforms
+
+   # --------- MNIST Network to train, from pytorch/examples -----
+
+   class Net(nn.Module):
+       def __init__(self, num_gpus=0):
+           super(Net, self).__init__()
+           print(f"Using {num_gpus} GPUs to train")
+           self.num_gpus = num_gpus
+           device = torch.device(
+               "cuda:0" if torch.cuda.is_available() and self.num_gpus > 0 else "cpu")
+           print(f"Putting first 2 convs on {str(device)}")
+           # Put conv layers on the first cuda device, or CPU if no cuda device
+           self.conv1 = nn.Conv2d(1, 32, 3, 1).to(device)
+           self.conv2 = nn.Conv2d(32, 64, 3, 1).to(device)
+           # Put rest of the network on the 2nd cuda device, if there is one
+           if "cuda" in str(device) and num_gpus > 1:
+               device = torch.device("cuda:1")
+
+           print(f"Putting rest of layers on {str(device)}")
+           self.dropout1 = nn.Dropout2d(0.25).to(device)
+           self.dropout2 = nn.Dropout2d(0.5).to(device)
+           self.fc1 = nn.Linear(9216, 128).to(device)
+           self.fc2 = nn.Linear(128, 10).to(device)
+
+       def forward(self, x):
+           x = self.conv1(x)
+           x = F.relu(x)
+           x = self.conv2(x)
+           x = F.max_pool2d(x, 2)
+
+           x = self.dropout1(x)
+           x = torch.flatten(x, 1)
+           # Move tensor to next device if necessary
+           next_device = next(self.fc1.parameters()).device
+           x = x.to(next_device)
+
+           x = self.fc1(x)
+           x = F.relu(x)
+           x = self.dropout2(x)
+           x = self.fc2(x)
+           output = F.log_softmax(x, dim=1)
+           return output
+Next, let's define some helper functions that will be useful for the rest of our script. The following uses `rpc_sync <https://pytorch.org/docs/stable/rpc.html#torch.distributed.rpc.rpc_sync>`_ and `RRef <https://pytorch.org/docs/stable/rpc.html#torch.distributed.rpc.RRef>`_ in order to define a function that invokes a given method on an object living on a remote node. Below, our handle to the remote object is given by the ``rref`` argument, and we run it on its owning node: ``rref.owner()``. On the caller node, we run this command synchronously through the use of ``rpc_sync``\ , meaning that we will block until a response is received.
+
+.. code-block:: python
+
+   # --------- Helper Methods --------------------
+
+   # On the local node, call a method with first arg as the value held by the
+   # RRef. Other args are passed in as arguments to the function called.
+   # Useful for calling instance methods. method could be any matching function, including
+   # class methods.
+   def call_method(method, rref, *args, **kwargs):
+       return method(rref.local_value(), *args, **kwargs)
+
+   # Given an RRef, return the result of calling the passed in method on the value
+   # held by the RRef. This call is done on the remote node that owns
+   # the RRef and passes along the given argument.
+   # Example: If the value held by the RRef is of type Foo, then
+   # remote_method(Foo.bar, rref, arg1, arg2) is equivalent to calling
+   # <foo_instance>.bar(arg1, arg2) on the remote node and getting the result
+   # back.
+
+   def remote_method(method, rref, *args, **kwargs):
+       args = [method, rref] + list(args)
+       return rpc.rpc_sync(rref.owner(), call_method, args=args, kwargs=kwargs)
+Now, we're ready to define our parameter server. We will subclass ``nn.Module`` and save a handle to our network defined above. We'll also save an input device which will be the device our input is transferred to before invoking the model.
+
+.. code-block:: python
+
+   # --------- Parameter Server --------------------
+   class ParameterServer(nn.Module):
+       def __init__(self, num_gpus=0):
+           super().__init__()
+           model = Net(num_gpus=num_gpus)
+           self.model = model
+           self.input_device = torch.device(
+               "cuda:0" if torch.cuda.is_available() and num_gpus > 0 else "cpu")
+Next, we'll define our forward pass. Note that regardless of the device of the model output, we move the output to CPU, as the Distributed RPC Framework currently only supports sending CPU tensors over RPC. We have intentionally disabled sending CUDA tensors over RPC due to the potential for different devices (CPU/GPU) on on the caller/callee, but may support this in future releases.
+
+.. code-block:: python
+
+   class ParameterServer(nn.Module):
+   ...
+       def forward(self, inp):
+           inp = inp.to(self.input_device)
+           out = self.model(inp)
+           # This output is forwarded over RPC, which as of 1.5.0 only accepts CPU tensors.
+           # Tensors must be moved in and out of GPU memory due to this.
+           out = out.to("cpu")
+           return out
+Next, we'll define a few miscellaneous functions useful for training and verification purposes. The first, ``get_dist_gradients``\ , will take in a Distributed Autograd context ID and call into the ``dist_autograd.get_gradients`` API in order to retrieve gradients computed by distributed autograd. More information can be found in the `distributed autograd documentation <https://pytorch.org/docs/stable/rpc.html#distributed-autograd-framework>`_. Note that we also iterate through the resulting dictionary and convert each tensor to a CPU tensor, as the framework currently only supports sending tensors over RPC. Next, ``get_param_rrefs`` will iterate through our model parameters and wrap them as a (local) `RRef <https://pytorch.org/docs/stable/rpc.html#torch.distributed.rpc.RRef>`_. This method will be invoked over RPC by trainer nodes and will return a list of the parameters to be optimized. This is required as input to the `Distributed Optimizer <https://pytorch.org/docs/stable/rpc.html#module-torch.distributed.optim>`_\ , which requires all parameters it must optimize as a list of ``RRef``\ s.
+
+.. code-block:: python
+
+   # Use dist autograd to retrieve gradients accumulated for this model.
+   # Primarily used for verification.
+   def get_dist_gradients(self, cid):
+       grads = dist_autograd.get_gradients(cid)
+       # This output is forwarded over RPC, which as of 1.5.0 only accepts CPU tensors.
+       # Tensors must be moved in and out of GPU memory due to this.
+       cpu_grads = {}
+       for k, v in grads.items():
+           k_cpu, v_cpu = k.to("cpu"), v.to("cpu")
+           cpu_grads[k_cpu] = v_cpu
+       return cpu_grads
+
+   # Wrap local parameters in a RRef. Needed for building the
+   # DistributedOptimizer which optimizes paramters remotely.
+   def get_param_rrefs(self):
+       param_rrefs = [rpc.RRef(param) for param in self.model.parameters()]
+       return param_rrefs
+Finally, we'll create methods to initialize our parameter server. Note that there will only be one instance of a parameter server across all processes, and all trainers will talk to the same parameter server and update the same stored model. As seen in ``run_parameter_server``\ , the server itself does not take any independent actions; it waits for requests from trainers (which are yet to be defined) and responds to them by running the requested function.
+
+.. code-block:: python
+
+   # The global parameter server instance.
+   param_server = None
+   # A lock to ensure we only have one parameter server.
+   global_lock = Lock()
+
+
+   def get_parameter_server(num_gpus=0):
+       """
+       Returns a singleton parameter server to all trainer processes
+       """
+       global param_server
+       # Ensure that we get only one handle to the ParameterServer.
+       with global_lock:
+           if not param_server:
+               # construct it once
+               param_server = ParameterServer(num_gpus=num_gpus)
+           return param_server
+
+   def run_parameter_server(rank, world_size):
+       # The parameter server just acts as a host for the model and responds to
+       # requests from trainers.
+       # rpc.shutdown() will wait for all workers to complete by default, which
+       # in this case means that the parameter server will wait for all trainers
+       # to complete, and then exit.
+       print("PS master initializing RPC")
+       rpc.init_rpc(name="parameter_server", rank=rank, world_size=world_size)
+       print("RPC initialized! Running parameter server...")
+       rpc.shutdown()
+       print("RPC shutdown on parameter server.")
+Note that above, ``rpc.shutdown()`` will not immediately shut down the Parameter Server. Instead, it will wait for all workers (trainers in this case) to also call into ``rpc.shutdown()``. This gives us the guarantee that the parameter server will not go offline before all trainers (yet to be define) have completed their training process.
+
+Next, we'll define our ``TrainerNet`` class. This will also be a subclass of ``nn.Module``\ , and our ``__init__`` method will use the ``rpc.remote`` API to obtain an RRef, or Remote Reference, to our parameter server. Note that here we are not copying the parameter server to our local process, instead, we can think of ``self.param_server_rref`` as a distributed shared pointer to the parameter server that lives on a separate process.
+
+.. code-block:: python
+
+   # --------- Trainers --------------------
+
+   # nn.Module corresponding to the network trained by this trainer. The
+   # forward() method simply invokes the network on the given parameter
+   # server.
+   class TrainerNet(nn.Module):
+       def __init__(self, num_gpus=0):
+           super().__init__()
+           self.num_gpus = num_gpus
+           self.param_server_rref = rpc.remote(
+               "parameter_server", get_parameter_server, args=(num_gpus,))
+Next, we'll define a method called ``get_global_param_rrefs``. To motivate the need for this method, it is worth it to read through the documentation on `DistributedOptimizer <https://pytorch.org/docs/stable/rpc.html#module-torch.distributed.optim>`_, specifically the API signature.  The optimizer must be passed a list of ``RRef``\ s corresponding to the remote parameters to be optimized, so here we obtain the necessary ``RRef``\ s. Since the only remote worker that a given ``TrainerNet`` interacts with is the ``ParameterServer``\ , we simply invoke a ``remote_method`` on the ``ParameterServer``. We use the ``get_param_rrefs`` method which we defined in the ``ParameterServer`` class. This method will return a list of ``RRef``\ s to the parameters that need to be optimized. Note that in this case our ``TrainerNet`` does not define its own paramaters; if it did, we would need to wrap each parameter in an ``RRef`` as well and include it into our input to ``DistributedOptimizer``.
+
+.. code-block:: python
+
+   class TrainerNet(nn.Module):
+   ...
+       def get_global_param_rrefs(self):
+           remote_params = remote_method(
+               ParameterServer.get_param_rrefs,
+               self.param_server_rref)
+           return remote_params
+Now, we're ready to define our ``forward`` method, which will invoke (synchronous) RPC to run the forward pass of the network defined on the ``ParameterServer``. Note that we pass in ``self.param_server_rref``\ , which is a remote handle to our ``ParameterServer``\ , to our RPC call. This call will send an RPC to the node on which our ``ParameterServer`` is running, invoke the ``forward`` pass, and return the ``Tensor`` corresponding to the model's output.
+
+.. code-block:: python
+
+   class TrainerNet(nn.Module):
+   ...
+       def forward(self, x):
+           model_output = remote_method(
+               ParameterServer.forward, self.param_server_rref, x)
+           return model_output
+With our trainer fully defined, it's now time to write our neural network training loop that will create our network and optimizer, run some inputs through the network and compute the loss. The training loop looks a lot like that of a local training program, with some modifications due to the nature of our network being distributed across machines.
+
+Below, we initialize our ``TrainerNet`` and build a ``DistributedOptimizer``. Note that as mentioned above, we must pass in all of the global (across all nodes participating in distributed training) parameters that we want to be optimized. In addition, we pass in the local optimizer to be used, in this case, SGD. Note that we can configure the underlying optimizer algorithm in the same way as creating a local optimizer - all arguments for ``optimizer.SGD`` will be forwarded properly. As an example, we pass in a custom learning rate that will be used as the learning rate for all local optimizers.
+
+.. code-block:: python
+
+   def run_training_loop(rank, num_gpus, train_loader, test_loader):
+       # Runs the typical nueral network forward + backward + optimizer step, but
+       # in a distributed fashion.
+       net = TrainerNet(num_gpus=num_gpus)
+       # Build DistributedOptimizer.
+       param_rrefs = net.get_global_param_rrefs()
+       opt = DistributedOptimizer(optim.SGD, param_rrefs, lr=0.03)
+Next, we define our main training loop. We loop through iterables given by PyTorch's `DataLoader <https://pytorch.org/docs/stable/data.html>`_. Before writing our typical forward/backward/optimizer loop, we first wrap the logic within a `Distributed Autograd context <https://pytorch.org/docs/stable/rpc.html#torch.distributed.autograd.context>`_. Note that this is needed to record RPCs invoked in the model's forward pass, so that an appropriate graph can be constructed which includes all participating distributed workers in the backward pass. The distributed autograd context returns a ``context_id`` which serves as an identifier for accumulating and optimizing gradients corresponding to a particular iteration.
+
+As opposed to calling the typical ``loss.backward()`` which would kick off the backward pass on this local worker, we call ``dist_autograd.backward()`` and pass in our context_id as well as ``loss``\ , which is the root at which we want the backward pass to begin. In addition, we pass this ``context_id`` into our optimizer call, which is required to be able to look up the corresponding gradients computed by this particular backwards pass across all nodes.
+
+.. code-block:: python
+
+   def run_training_loop(rank, num_gpus, train_loader, test_loader):
+   ...
+       for i, (data, target) in enumerate(train_loader):
+           with dist_autograd.context() as cid:
+               model_output = net(data)
+               target = target.to(model_output.device)
+               loss = F.nll_loss(model_output, target)
+               if i % 5 == 0:
+                   print(f"Rank {rank} training batch {i} loss {loss.item()}")
+               dist_autograd.backward(cid, [loss])
+               # Ensure that dist autograd ran successfully and gradients were
+               # returned.
+               assert remote_method(
+                   ParameterServer.get_dist_gradients,
+                   net.param_server_rref,
+                   cid) != {}
+               opt.step(cid)
+
+        print("Training complete!")
+        print("Getting accuracy....")
+        get_accuracy(test_loader, net)
+The following simply computes the accuracy of our model after we're done training, much like a traditional local model. However, note that the ``net`` we pass into this function above is an instance of ``TrainerNet`` and therefore the forward pass invokes RPC in a transparent fashion.
+
+.. code-block:: python
+
+   def get_accuracy(test_loader, model):
+       model.eval()
+       correct_sum = 0
+       # Use GPU to evaluate if possible
+       device = torch.device("cuda:0" if model.num_gpus > 0
+           and torch.cuda.is_available() else "cpu")
+       with torch.no_grad():
+           for i, (data, target) in enumerate(test_loader):
+               out = model(data, -1)
+               pred = out.argmax(dim=1, keepdim=True)
+               pred, target = pred.to(device), target.to(device)
+               correct = pred.eq(target.view_as(pred)).sum().item()
+               correct_sum += correct
+
+       print(f"Accuracy {correct_sum / len(test_loader.dataset)}")
+Next, similar to how we defined ``run_parameter_server`` as the main loop for our ``ParameterServer`` that is responsible for initializing RPC, let's define a similar loop for our trainers. The difference will be that our trainers must run the training loop we defined above:
+
+.. code-block:: python
+
+   # Main loop for trainers.
+   def run_worker(rank, world_size, num_gpus, train_loader, test_loader):
+       print(f"Worker rank {rank} initializing RPC")
+       rpc.init_rpc(
+           name=f"trainer_{rank}",
+           rank=rank,
+           world_size=world_size)
+
+       print(f"Worker {rank} done initializing RPC")
+
+       run_training_loop(rank, num_gpus, train_loader, test_loader)
+       rpc.shutdown()
+Note that similar to ``run_parameter_server``\ , ``rpc.shutdown()`` will by default wait for all workers, both trainers and ParameterServers, to call into ``rpc.shutdown()`` before this node exits. This ensures that nodes are terminated gracefully and no node goes offline while another is expecting it to be online.
+
+We've now completed our trainer and parameter server specific code, and all that's left is to add code to launch trainers and parameter servers. First, we must take in various arguments that apply to our parameter server and trainers. ``world_size`` corresponds to the total number of nodes that will participate in training, and is the sum of all trainers and the parameter server. We also must pass in a unique ``rank`` for each individual process, from 0 (where we will run our single parameter server) to ``world_size - 1``. ``master_addr`` and ``master_port`` are arguments that can be used to identify where the rank 0 process is running, and will be used by individual nodes to discover each other. To test this example out locally, simply pass in ``localhost`` and the same ``master_port`` to all instances spawned. Note that for demonstration purposes, this example supports only between 0-2 GPUs, although the pattern can be extended to make use of additional GPUs.
+
+.. code-block:: python
+
+   if __name__ == '__main__':
+       parser = argparse.ArgumentParser(
+           description="Parameter-Server RPC based training")
+       parser.add_argument(
+           "--world_size",
+           type=int,
+           default=4,
+           help="""Total number of participating processes. Should be the sum of
+           master node and all training nodes.""")
+       parser.add_argument(
+           "--rank",
+           type=int,
+           default=None,
+           help="Global rank of this process. Pass in 0 for master.")
+       parser.add_argument(
+           "--num_gpus",
+           type=int,
+           default=0,
+           help="""Number of GPUs to use for training, Currently supports between 0
+            and 2 GPUs. Note that this argument will be passed to the parameter servers.""")
+       parser.add_argument(
+           "--master_addr",
+           type=str,
+           default="localhost",
+           help="""Address of master, will default to localhost if not provided.
+           Master must be able to accept network traffic on the address + port.""")
+       parser.add_argument(
+           "--master_port",
+           type=str,
+           default="29500",
+           help="""Port that master is listening on, will default to 29500 if not
+           provided. Master must be able to accept network traffic on the host and port.""")
+
+       args = parser.parse_args()
+       assert args.rank is not None, "must provide rank argument."
+       assert args.num_gpus <= 3, f"Only 0-2 GPUs currently supported (got {args.num_gpus})."
+       os.environ['MASTER_ADDR'] = args.master_addr
+       os.environ["MASTER_PORT"] = args.master_port
+Now, we'll create a process corresponding to either a parameter server or trainer depending on our command line arguments. We'll create a ``ParameterServer`` if our passed in rank is 0, and a ``TrainerNet`` otherwise. Note that we're using ``torch.multiprocessing`` to launch a subprocess corresponding to the function that we want to execute, and waiting on this process's completion from the main thread with ``p.join()``. In the case of initializing our trainers, we also use PyTorch's `dataloaders <https://pytorch.org/docs/stable/data.html>`_ in order to specify train and test data loaders on the MNIST dataset.
+
+.. code-block:: python
+
+   processes = []
+   world_size = args.world_size
+   if args.rank == 0:
+       p = mp.Process(target=run_parameter_server, args=(0, world_size))
+       p.start()
+       processes.append(p)
+   else:
+       # Get data to train on
+       train_loader = torch.utils.data.DataLoader(
+           datasets.MNIST('../data', train=True, download=True,
+                          transform=transforms.Compose([
+                              transforms.ToTensor(),
+                              transforms.Normalize((0.1307,), (0.3081,))
+                          ])),
+           batch_size=32, shuffle=True,)
+       test_loader = torch.utils.data.DataLoader(
+           datasets.MNIST(
+               '../data',
+               train=False,
+               transform=transforms.Compose([
+                       transforms.ToTensor(),
+                       transforms.Normalize((0.1307,), (0.3081,))
+                           ])),
+           batch_size=32,
+           shuffle=True,
+       )
+       # start training worker on this node
+       p = mp.Process(
+           target=run_worker,
+           args=(
+               args.rank,
+               world_size, args.num_gpus,
+               train_loader,
+               test_loader))
+       p.start()
+       processes.append(p)
+
+   for p in processes:
+       p.join()
+To run the example locally, run the following command worker for the server and each worker you wish to spawn, in separate terminal windows: ``python rpc_parameter_server.py --world_size=WORLD_SIZE --rank=RANK``. For example, for a master node with world size of 2, the command would be ``python rpc_parameter_server.py --world_size=2 --rank=0``. The trainer can then be launched with the command ``python rpc_parameter_server.py --world_size=2 --rank=1`` in a separate window, and this will begin training with one server and a single trainer. Note that this tutorial assumes that training occurs using between 0 and 2 GPUs, and this argument can be configured by passing ``--num_gpus=N`` into the training script.
+
+You can pass in the command line arguments ``--master_addr=ADDRESS`` and ``--master_port=PORT`` to indicate the address and port that the master worker is listening on, for example, to test functionality where trainers and master nodes run on different machines.
diff --git a/intermediate_source/rpc_tutorial.rst b/intermediate_source/rpc_tutorial.rst
new file mode 100644
index 00000000000..791ecf86d35
--- /dev/null
+++ b/intermediate_source/rpc_tutorial.rst
@@ -0,0 +1,622 @@
+Getting Started with Distributed RPC Framework
+=================================================
+**Author**: `Shen Li <https://mrshenli.github.io/>`_
+
+.. note::
+   |edit| View and edit this tutorial in `github <https://github.com/pytorch/tutorials/blob/main/intermediate_source/rpc_tutorial.rst>`__.
+
+Prerequisites:
+
+-  `PyTorch Distributed Overview <../beginner/dist_overview.html>`__
+-  `RPC API documents <https://pytorch.org/docs/master/rpc.html>`__
+
+This tutorial uses two simple examples to demonstrate how to build distributed
+training with the `torch.distributed.rpc <https://pytorch.org/docs/stable/rpc.html>`__
+package which was first introduced as an experimental feature in PyTorch v1.4.
+Source code of the two examples can be found in
+`PyTorch examples <https://github.com/pytorch/examples>`__.
+
+Previous tutorials,
+`Getting Started With Distributed Data Parallel <ddp_tutorial.html>`__
+and `Writing Distributed Applications With PyTorch <dist_tuto.html>`__,
+described `DistributedDataParallel <https://docs.pytorch.org/docs/stable/generated/torch.nn.parallel.DistributedDataParallel.html>`__
+which supports a specific training paradigm where the model is replicated across
+multiple processes and each process handles a split of the input data.
+Sometimes, you might run into scenarios that require different training
+paradigms. For example:
+
+1) In reinforcement learning, it might be relatively expensive to acquire
+   training data from environments while the model itself can be quite small. In
+   this case, it might be useful to spawn multiple observers running in parallel
+   and share a single agent. In this case, the agent takes care of the training
+   locally, but the application would still need libraries to send and receive
+   data between observers and the trainer.
+2) Your model might be too large to fit in GPUs on a single machine, and hence
+   would need a library to help split the model onto multiple machines. Or you
+   might be implementing a `parameter server <https://www.cs.cmu.edu/~muli/file/parameter_server_osdi14.pdf>`__
+   training framework, where model parameters and trainers live on different
+   machines.
+
+
+The `torch.distributed.rpc <https://pytorch.org/docs/stable/rpc.html>`__ package
+can help with the above scenarios. In case 1, `RPC <https://pytorch.org/docs/stable/rpc.html#rpc>`__
+and `RRef <https://pytorch.org/docs/stable/rpc.html#rref>`__ allow sending data
+from one worker to another while easily referencing remote data objects. In
+case 2, `distributed autograd <https://pytorch.org/docs/stable/rpc.html#distributed-autograd-framework>`__
+and `distributed optimizer <https://pytorch.org/docs/stable/rpc.html#module-torch.distributed.optim>`__
+make executing backward pass and optimizer step as if it is local training. In
+the next two sections, we will demonstrate APIs of
+`torch.distributed.rpc <https://pytorch.org/docs/stable/rpc.html>`__ using a
+reinforcement learning example and a language model example. Please note, this
+tutorial does not aim at building the most accurate or efficient models to
+solve given problems, instead, the main goal here is to show how to use the
+`torch.distributed.rpc <https://pytorch.org/docs/stable/rpc.html>`__ package to
+build distributed training applications.
+
+
+
+Distributed Reinforcement Learning using RPC and RRef
+-----------------------------------------------------
+
+This section describes steps to build a toy distributed reinforcement learning
+model using RPC to solve CartPole-v1 from `OpenAI Gym <https://www.gymlibrary.dev/environments/classic_control/cart_pole/>`__.
+The policy code is mostly borrowed from the existing single-thread
+`example <https://github.com/pytorch/examples/blob/master/reinforcement_learning>`__
+as shown below. We will skip details of the ``Policy`` design, and focus on RPC
+usages.
+
+.. code:: python
+
+    import torch.nn as nn
+    import torch.nn.functional as F
+
+    class Policy(nn.Module):
+
+        def __init__(self):
+            super(Policy, self).__init__()
+            self.affine1 = nn.Linear(4, 128)
+            self.dropout = nn.Dropout(p=0.6)
+            self.affine2 = nn.Linear(128, 2)
+
+        def forward(self, x):
+            x = self.affine1(x)
+            x = self.dropout(x)
+            x = F.relu(x)
+            action_scores = self.affine2(x)
+            return F.softmax(action_scores, dim=1)
+
+
+We are ready to present the observer. In this example, each observer creates its
+own environment, and waits for the agent's command to run an episode. In each
+episode, one observer loops at most ``n_steps`` iterations, and in each
+iteration, it uses RPC to pass its environment state to the agent and gets an
+action back. Then it applies that action to its environment, and gets the reward
+and the next state from the environment. After that, the observer uses another
+RPC to report the reward to the agent. Again, please note that, this is
+obviously not the most efficient observer implementation. For example, one
+simple optimization could be packing current state and last reward in one RPC to
+reduce the communication overhead. However, the goal is to demonstrate RPC API
+instead of building the best solver for CartPole. So, let's keep the logic
+simple and the two steps explicit in this example.
+
+.. code:: python
+
+    import argparse
+    import gym
+    import torch.distributed.rpc as rpc
+
+    parser = argparse.ArgumentParser(
+        description="RPC Reinforcement Learning Example",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+
+    parser.add_argument('--world_size', default=2, type=int, metavar='W',
+                        help='number of workers')
+    parser.add_argument('--log_interval', type=int, default=10, metavar='N',
+                        help='interval between training status logs')
+    parser.add_argument('--gamma', type=float, default=0.99, metavar='G',
+                        help='how much to value future rewards')
+    parser.add_argument('--seed', type=int, default=1, metavar='S',
+                        help='random seed  for reproducibility')
+    args = parser.parse_args()
+
+    class Observer:
+
+        def __init__(self):
+            self.id = rpc.get_worker_info().id
+            self.env = gym.make('CartPole-v1')
+            self.env.seed(args.seed)
+
+        def run_episode(self, agent_rref):
+            state, ep_reward = self.env.reset(), 0
+            for _ in range(10000):
+                # send the state to the agent to get an action
+                action = agent_rref.rpc_sync().select_action(self.id, state)
+
+                # apply the action to the environment, and get the reward
+                state, reward, done, _ = self.env.step(action)
+
+                # report the reward to the agent for training purpose
+                agent_rref.rpc_sync().report_reward(self.id, reward)
+
+                # finishes after the number of self.env._max_episode_steps
+                if done:
+                    break
+
+
+The code for agent is a little more complex, and we will break it into multiple
+pieces. In this example, the agent serves as both the trainer and the master,
+such that it sends command to multiple distributed observers to run episodes,
+and it also records all actions and rewards locally which will be used during
+the training phase after each episode. The code below shows ``Agent``
+constructor where most lines are initializing various components. The loop at
+the end initializes observers remotely on other workers, and holds ``RRefs`` to
+those observers locally. The agent will use those observer ``RRefs`` later to
+send commands. Applications don't need to worry about the lifetime of ``RRefs``.
+The owner of each ``RRef`` maintains a reference counting map to track its
+lifetime, and guarantees the remote data object will not be deleted as long as
+there is any live user of that ``RRef``. Please refer to the ``RRef``
+`design doc <https://pytorch.org/docs/stable/rpc/rref.html>`__ for details.
+
+
+.. code:: python
+
+    import gym
+    import numpy as np
+
+    import torch
+    import torch.distributed.rpc as rpc
+    import torch.optim as optim
+    from torch.distributed.rpc import RRef, rpc_async, remote
+    from torch.distributions import Categorical
+
+    class Agent:
+        def __init__(self, world_size):
+            self.ob_rrefs = []
+            self.agent_rref = RRef(self)
+            self.rewards = {}
+            self.saved_log_probs = {}
+            self.policy = Policy()
+            self.optimizer = optim.Adam(self.policy.parameters(), lr=1e-2)
+            self.eps = np.finfo(np.float32).eps.item()
+            self.running_reward = 0
+            self.reward_threshold = gym.make('CartPole-v1').spec.reward_threshold
+            for ob_rank in range(1, world_size):
+                ob_info = rpc.get_worker_info(OBSERVER_NAME.format(ob_rank))
+                self.ob_rrefs.append(remote(ob_info, Observer))
+                self.rewards[ob_info.id] = []
+                self.saved_log_probs[ob_info.id] = []
+
+
+Next, the agent exposes two APIs to observers for selecting actions and
+reporting rewards. Those functions only run locally on the agent, but will
+be triggered by observers through RPC.
+
+
+.. code:: python
+
+    class Agent:
+        ...
+        def select_action(self, ob_id, state):
+            state = torch.from_numpy(state).float().unsqueeze(0)
+            probs = self.policy(state)
+            m = Categorical(probs)
+            action = m.sample()
+            self.saved_log_probs[ob_id].append(m.log_prob(action))
+            return action.item()
+
+        def report_reward(self, ob_id, reward):
+            self.rewards[ob_id].append(reward)
+
+
+Let's add a ``run_episode`` function on agent which tells all observers
+to execute an episode. In this function, it first creates a list to collect
+futures from asynchronous RPCs, and then loop over all observer ``RRefs`` to
+make asynchronous RPCs. In these RPCs, the agent also passes an ``RRef`` of
+itself to the observer, so that the observer can call functions on the agent as
+well. As shown above, each observer will make RPCs back to the agent, which are
+nested RPCs. After each episode, the ``saved_log_probs`` and ``rewards`` will
+contain the recorded action probs and rewards.
+
+
+.. code:: python
+
+    class Agent:
+        ...
+        def run_episode(self):
+            futs = []
+            for ob_rref in self.ob_rrefs:
+                # make async RPC to kick off an episode on all observers
+                futs.append(
+                    rpc_async(
+                        ob_rref.owner(),
+                        ob_rref.rpc_sync().run_episode,
+                        args=(self.agent_rref,)
+                    )
+                )
+
+            # wait until all obervers have finished this episode
+            for fut in futs:
+                fut.wait()
+
+
+Finally, after one episode, the agent needs to train the model, which
+is implemented in the ``finish_episode`` function below. There is no RPCs in
+this function and it is mostly borrowed from the single-thread
+`example <https://github.com/pytorch/examples/blob/master/reinforcement_learning>`__.
+Hence, we skip describing its contents.
+
+
+
+.. code:: python
+
+    class Agent:
+        ...
+        def finish_episode(self):
+          # joins probs and rewards from different observers into lists
+          R, probs, rewards = 0, [], []
+          for ob_id in self.rewards:
+              probs.extend(self.saved_log_probs[ob_id])
+              rewards.extend(self.rewards[ob_id])
+
+          # use the minimum observer reward to calculate the running reward
+          min_reward = min([sum(self.rewards[ob_id]) for ob_id in self.rewards])
+          self.running_reward = 0.05 * min_reward + (1 - 0.05) * self.running_reward
+
+          # clear saved probs and rewards
+          for ob_id in self.rewards:
+              self.rewards[ob_id] = []
+              self.saved_log_probs[ob_id] = []
+
+          policy_loss, returns = [], []
+          for r in rewards[::-1]:
+              R = r + args.gamma * R
+              returns.insert(0, R)
+          returns = torch.tensor(returns)
+          returns = (returns - returns.mean()) / (returns.std() + self.eps)
+          for log_prob, R in zip(probs, returns):
+              policy_loss.append(-log_prob * R)
+          self.optimizer.zero_grad()
+          policy_loss = torch.cat(policy_loss).sum()
+          policy_loss.backward()
+          self.optimizer.step()
+          return min_reward
+
+
+With ``Policy``, ``Observer``, and ``Agent`` classes, we are ready to launch
+multiple processes to perform the distributed training. In this example, all
+processes run the same ``run_worker`` function, and they use the rank to
+distinguish their role. Rank 0 is always the agent, and all other ranks are
+observers. The agent serves as master by repeatedly calling ``run_episode`` and
+``finish_episode`` until the running reward surpasses the reward threshold
+specified by the environment. All observers passively waiting for commands
+from the agent. The code is wrapped by
+`rpc.init_rpc <https://pytorch.org/docs/stable/rpc.html#torch.distributed.rpc.init_rpc>`__ and
+`rpc.shutdown <https://pytorch.org/docs/stable/rpc.html#torch.distributed.rpc.shutdown>`__,
+which initializes and terminates RPC instances respectively. More details are
+available in the `API page <https://pytorch.org/docs/stable/rpc.html>`__.
+
+
+.. code:: python
+
+    import os
+    from itertools import count
+
+    import torch.multiprocessing as mp
+
+    AGENT_NAME = "agent"
+    OBSERVER_NAME="obs{}"
+
+    def run_worker(rank, world_size):
+        os.environ['MASTER_ADDR'] = 'localhost'
+        os.environ['MASTER_PORT'] = '29500'
+        if rank == 0:
+            # rank0 is the agent
+            rpc.init_rpc(AGENT_NAME, rank=rank, world_size=world_size)
+
+            agent = Agent(world_size)
+            print(f"This will run until reward threshold of {agent.reward_threshold}"
+                    " is reached. Ctrl+C to exit.")
+            for i_episode in count(1):
+                agent.run_episode()
+                last_reward = agent.finish_episode()
+
+                if i_episode % args.log_interval == 0:
+                    print(f"Episode {i_episode}\tLast reward: {last_reward:.2f}\tAverage reward: "
+                        f"{agent.running_reward:.2f}")
+                if agent.running_reward > agent.reward_threshold:
+                    print(f"Solved! Running reward is now {agent.running_reward}!")
+                    break
+        else:
+            # other ranks are the observer
+            rpc.init_rpc(OBSERVER_NAME.format(rank), rank=rank, world_size=world_size)
+            # observers passively waiting for instructions from the agent
+
+        # block until all rpcs finish, and shutdown the RPC instance
+        rpc.shutdown()
+
+
+    mp.spawn(
+        run_worker,
+        args=(args.world_size, ),
+        nprocs=args.world_size,
+        join=True
+    )
+
+Below are some sample outputs when training with `world_size=2`.
+
+::
+
+    This will run until reward threshold of 475.0 is reached. Ctrl+C to exit.
+    Episode 10      Last reward: 26.00      Average reward: 10.01
+    Episode 20      Last reward: 16.00      Average reward: 11.27
+    Episode 30      Last reward: 49.00      Average reward: 18.62
+    Episode 40      Last reward: 45.00      Average reward: 26.09
+    Episode 50      Last reward: 44.00      Average reward: 30.03
+    Episode 60      Last reward: 111.00     Average reward: 42.23
+    Episode 70      Last reward: 131.00     Average reward: 70.11
+    Episode 80      Last reward: 87.00      Average reward: 76.51
+    Episode 90      Last reward: 86.00      Average reward: 95.93
+    Episode 100     Last reward: 13.00      Average reward: 123.93
+    Episode 110     Last reward: 33.00      Average reward: 91.39
+    Episode 120     Last reward: 73.00      Average reward: 76.38
+    Episode 130     Last reward: 137.00     Average reward: 88.08
+    Episode 140     Last reward: 89.00      Average reward: 104.96
+    Episode 150     Last reward: 97.00      Average reward: 98.74
+    Episode 160     Last reward: 150.00     Average reward: 100.87
+    Episode 170     Last reward: 126.00     Average reward: 104.38
+    Episode 180     Last reward: 500.00     Average reward: 213.74
+    Episode 190     Last reward: 322.00     Average reward: 300.22
+    Episode 200     Last reward: 165.00     Average reward: 272.71
+    Episode 210     Last reward: 168.00     Average reward: 233.11
+    Episode 220     Last reward: 184.00     Average reward: 195.02
+    Episode 230     Last reward: 284.00     Average reward: 208.32
+    Episode 240     Last reward: 395.00     Average reward: 247.37
+    Episode 250     Last reward: 500.00     Average reward: 335.42
+    Episode 260     Last reward: 500.00     Average reward: 386.30
+    Episode 270     Last reward: 500.00     Average reward: 405.29
+    Episode 280     Last reward: 500.00     Average reward: 443.29
+    Episode 290     Last reward: 500.00     Average reward: 464.65
+    Solved! Running reward is now 475.3163778435275!
+
+
+In this example, we show how to use RPC as the communication vehicle to pass
+data across workers, and how to use RRef to reference remote objects. It is true
+that you could build the entire structure directly on top of ``ProcessGroup``
+``send`` and ``recv`` APIs or use other communication/RPC libraries. However,
+by using `torch.distributed.rpc`, you can get the native support and
+continuously optimized performance under the hood.
+
+Next, we will show how to combine RPC and RRef with distributed autograd and
+distributed optimizer to perform distributed model parallel training.
+
+
+
+Distributed RNN using Distributed Autograd and Distributed Optimizer
+--------------------------------------------------------------------
+
+In this section, we use an RNN model to show how to build distributed model
+parallel training with the RPC API. The example RNN model is very small and
+can easily fit into a single GPU, but we still divide its layers onto two
+different workers to demonstrate the idea. Developer can apply the similar
+techniques to distribute much larger models across multiple devices and
+machines.
+
+The RNN model design is borrowed from the word language model in PyTorch
+`example <https://github.com/pytorch/examples/tree/master/word_language_model>`__
+repository, which contains three main components, an embedding table, an
+``LSTM`` layer, and a decoder. The code below wraps the embedding table and the
+decoder into sub-modules, so that their constructors can be passed to the RPC
+API. In the ``EmbeddingTable`` sub-module, we intentionally put the
+``Embedding`` layer on GPU to cover the use case. In v1.4, RPC always creates
+CPU tensor arguments or return values on the destination worker. If the function
+takes a GPU tensor, you need to move it to the proper device explicitly.
+
+
+.. code:: python
+
+    class EmbeddingTable(nn.Module):
+        r"""
+        Encoding layers of the RNNModel
+        """
+        def __init__(self, ntoken, ninp, dropout):
+            super(EmbeddingTable, self).__init__()
+            self.drop = nn.Dropout(dropout)
+            self.encoder = nn.Embedding(ntoken, ninp).cuda()
+            self.encoder.weight.data.uniform_(-0.1, 0.1)
+
+        def forward(self, input):
+            return self.drop(self.encoder(input.cuda()).cpu()
+
+
+    class Decoder(nn.Module):
+        def __init__(self, ntoken, nhid, dropout):
+            super(Decoder, self).__init__()
+            self.drop = nn.Dropout(dropout)
+            self.decoder = nn.Linear(nhid, ntoken)
+            self.decoder.bias.data.zero_()
+            self.decoder.weight.data.uniform_(-0.1, 0.1)
+
+        def forward(self, output):
+            return self.decoder(self.drop(output))
+
+
+With the above sub-modules, we can now piece them together using RPC to
+create an RNN model. In the code below ``ps`` represents a parameter server,
+which hosts parameters of the embedding table and the decoder. The constructor
+uses the `remote <https://pytorch.org/docs/stable/rpc.html#torch.distributed.rpc.remote>`__
+API to create an ``EmbeddingTable`` object and a ``Decoder`` object on the
+parameter server, and locally creates the ``LSTM`` sub-module. During the
+forward pass, the trainer uses the ``EmbeddingTable`` ``RRef`` to find the
+remote sub-module and passes the input data to the ``EmbeddingTable`` using RPC
+and fetches the lookup results. Then, it runs the embedding through the local
+``LSTM`` layer, and finally uses another RPC to send the output to the
+``Decoder`` sub-module. In general, to implement distributed model parallel
+training, developers can divide the model into sub-modules, invoke RPC to create
+sub-module instances remotely, and use on ``RRef`` to find them when necessary.
+As you can see in the code below, it looks very similar to single-machine model
+parallel training. The main difference is replacing ``Tensor.to(device)`` with
+RPC functions.
+
+
+.. code:: python
+
+    class RNNModel(nn.Module):
+        def __init__(self, ps, ntoken, ninp, nhid, nlayers, dropout=0.5):
+            super(RNNModel, self).__init__()
+
+            # setup embedding table remotely
+            self.emb_table_rref = rpc.remote(ps, EmbeddingTable, args=(ntoken, ninp, dropout))
+            # setup LSTM locally
+            self.rnn = nn.LSTM(ninp, nhid, nlayers, dropout=dropout)
+            # setup decoder remotely
+            self.decoder_rref = rpc.remote(ps, Decoder, args=(ntoken, nhid, dropout))
+
+        def forward(self, input, hidden):
+            # pass input to the remote embedding table and fetch emb tensor back
+            emb = _remote_method(EmbeddingTable.forward, self.emb_table_rref, input)
+            output, hidden = self.rnn(emb, hidden)
+            # pass output to the rremote decoder and get the decoded output back
+            decoded = _remote_method(Decoder.forward, self.decoder_rref, output)
+            return decoded, hidden
+
+Before introducing the distributed optimizer, let's add a helper function to
+generate a list of RRefs of model parameters, which will be consumed by the
+distributed optimizer. In local training, applications could call
+``Module.parameters()`` to grab references to all parameter tensors, and pass it
+to the local optimizer for subsequent updates. However, the same API does not
+work in distributed training scenarios as some parameters live on remote
+machines. Therefore, instead of taking a list of parameter ``Tensors``, the
+distributed optimizer takes a list of ``RRefs``, one ``RRef`` per model
+parameter for both local and remote model parameters. The helper function is
+pretty simple, just call ``Module.parameters()`` and creates a local ``RRef`` on
+each of the parameters.
+
+
+.. code:: python
+
+    def _parameter_rrefs(module):
+        param_rrefs = []
+        for param in module.parameters():
+            param_rrefs.append(RRef(param))
+        return param_rrefs
+
+
+Then, as the ``RNNModel`` contains three sub-modules, we need to call
+``_parameter_rrefs`` three times, and wrap that into another helper function.
+
+
+.. code:: python
+
+    class RNNModel(nn.Module):
+        ...
+        def parameter_rrefs(self):
+            remote_params = []
+            # get RRefs of embedding table
+            remote_params.extend(_remote_method(_parameter_rrefs, self.emb_table_rref))
+            # create RRefs for local parameters
+            remote_params.extend(_parameter_rrefs(self.rnn))
+            # get RRefs of decoder
+            remote_params.extend(_remote_method(_parameter_rrefs, self.decoder_rref))
+            return remote_params
+
+
+Now, we are ready to implement the training loop. After initializing model
+arguments, we create the ``RNNModel`` and the ``DistributedOptimizer``. The
+distributed optimizer will take a list of parameter ``RRefs``, find all distinct
+owner workers, and create the given local optimizer (i.e., ``SGD`` in this case,
+you can use other local optimizers as well) on each of the owner worker using
+the given arguments (i.e., ``lr=0.05``).
+
+In the training loop, it first creates a distributed autograd context, which
+will help the distributed autograd engine to find gradients and involved RPC
+send/recv functions. The design details of the distributed autograd engine can
+be found in its `design note <https://pytorch.org/docs/stable/rpc/distributed_autograd.html>`__.
+Then, it kicks off the forward pass as if it is a local
+model, and run the distributed backward pass. For the distributed backward, you
+only need to specify a list of roots, in this case, it is the loss ``Tensor``.
+The distributed autograd engine will traverse the distributed graph
+automatically and write gradients properly. Next, it runs the ``step``
+function on the distributed optimizer, which will reach out to all involved
+local optimizers to update model parameters. Compared to local training, one
+minor difference is that you don't need to run ``zero_grad()`` because each
+autograd context has dedicated space to store gradients, and as we create a
+context per iteration, those gradients from different iterations will not
+accumulate to the same set of ``Tensors``.
+
+
+.. code:: python
+
+    def run_trainer():
+        batch = 5
+        ntoken = 10
+        ninp = 2
+
+        nhid = 3
+        nindices = 3
+        nlayers = 4
+        hidden = (
+            torch.randn(nlayers, nindices, nhid),
+            torch.randn(nlayers, nindices, nhid)
+        )
+
+        model = rnn.RNNModel('ps', ntoken, ninp, nhid, nlayers)
+
+        # setup distributed optimizer
+        opt = DistributedOptimizer(
+            optim.SGD,
+            model.parameter_rrefs(),
+            lr=0.05,
+        )
+
+        criterion = torch.nn.CrossEntropyLoss()
+
+        def get_next_batch():
+            for _ in range(5):
+                data = torch.LongTensor(batch, nindices) % ntoken
+                target = torch.LongTensor(batch, ntoken) % nindices
+                yield data, target
+
+        # train for 10 iterations
+        for epoch in range(10):
+            for data, target in get_next_batch():
+                # create distributed autograd context
+                with dist_autograd.context() as context_id:
+                    hidden[0].detach_()
+                    hidden[1].detach_()
+                    output, hidden = model(data, hidden)
+                    loss = criterion(output, target)
+                    # run distributed backward pass
+                    dist_autograd.backward(context_id, [loss])
+                    # run distributed optimizer
+                    opt.step(context_id)
+                    # not necessary to zero grads since they are
+                    # accumulated into the distributed autograd context
+                    # which is reset every iteration.
+            print("Training epoch {}".format(epoch))
+
+
+Finally, let's add some glue code to launch the parameter server and the trainer
+processes.
+
+
+.. code:: python
+
+    def run_worker(rank, world_size):
+        os.environ['MASTER_ADDR'] = 'localhost'
+        os.environ['MASTER_PORT'] = '29500'
+        if rank == 1:
+            rpc.init_rpc("trainer", rank=rank, world_size=world_size)
+            _run_trainer()
+        else:
+            rpc.init_rpc("ps", rank=rank, world_size=world_size)
+            # parameter server do nothing
+            pass
+
+        # block until all rpcs finish
+        rpc.shutdown()
+
+
+    if __name__=="__main__":
+        world_size = 2
+        mp.spawn(run_worker, args=(world_size, ), nprocs=world_size, join=True)
diff --git a/intermediate_source/scaled_dot_product_attention_tutorial.py b/intermediate_source/scaled_dot_product_attention_tutorial.py
new file mode 100644
index 00000000000..35b1ba7be4e
--- /dev/null
+++ b/intermediate_source/scaled_dot_product_attention_tutorial.py
@@ -0,0 +1,407 @@
+"""
+(Beta) Implementing High-Performance Transformers with Scaled Dot Product Attention (SDPA)
+==========================================================================================
+
+
+**Author:** `Driss Guessous <https://github.com/drisspg>`_
+"""
+
+######################################################################
+# Summary
+# ~~~~~~~~
+#
+# In this tutorial, we want to highlight a new ``torch.nn.functional`` function
+# that can be helpful for implementing transformer architectures. The
+# function is named ``torch.nn.functional.scaled_dot_product_attention``.
+# For detailed description of the function, see the `PyTorch documentation <https://pytorch.org/docs/master/generated/torch.nn.functional.scaled_dot_product_attention.html#torch.nn.functional.scaled_dot_product_attention>`__.
+# This function has already been incorporated into ``torch.nn.MultiheadAttention`` and ``torch.nn.TransformerEncoderLayer``.
+#
+# Overview
+# ~~~~~~~~~
+# At a high level, this PyTorch function calculates the
+# scaled dot product attention (SDPA) between query, key, and value according to
+# the definition found in the paper `Attention is all you
+# need <https://arxiv.org/abs/1706.03762>`__. While this function can
+# be written in PyTorch using existing functions, a fused implementation can provide
+# large performance benefits over a naive implementation.
+#
+# Fused implementations
+# ~~~~~~~~~~~~~~~~~~~~~~
+#
+# For CUDA tensor inputs, the function will dispatch into one of the following
+# implementations:
+#
+# * `FlashAttention: Fast and Memory-Efficient Exact Attention with IO-Awareness <https://arxiv.org/abs/2205.14135>`__
+# * `Memory-Efficient Attention <https://github.com/facebookresearch/xformers>`__
+# * A PyTorch implementation defined in C++
+#
+# .. note::
+#
+#   This tutorial requires PyTorch 2.0.0 or later.
+#
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+device = "cuda" if torch.cuda.is_available() else "cpu"
+
+# Example Usage:
+query, key, value = torch.randn(2, 3, 8, device=device), torch.randn(2, 3, 8, device=device), torch.randn(2, 3, 8, device=device)
+F.scaled_dot_product_attention(query, key, value)
+
+
+######################################################################
+# Explicit Dispatcher Control
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# While the function will implicitly dispatch to one of the three
+# implementations, the user can also explicitly control the dispatch via
+# the use of a context manager. This context manager allows users to
+# explicitly disable certain implementations. If a user wants to ensure
+# the function is indeed using the fastest implementation for their
+# specific inputs, the context manager can be used to sweep through
+# measuring performance.
+#
+
+# Lets define a helpful benchmarking function:
+import torch.utils.benchmark as benchmark
+def benchmark_torch_function_in_microseconds(f, *args, **kwargs):
+    t0 = benchmark.Timer(
+        stmt="f(*args, **kwargs)", globals={"args": args, "kwargs": kwargs, "f": f}
+    )
+    return t0.blocked_autorange().mean * 1e6
+
+# Lets define the hyper-parameters of our input
+batch_size = 32
+max_sequence_len = 1024
+num_heads = 32
+embed_dimension = 32
+
+dtype = torch.float16
+
+query = torch.rand(batch_size, num_heads, max_sequence_len, embed_dimension, device=device, dtype=dtype)
+key = torch.rand(batch_size, num_heads, max_sequence_len, embed_dimension, device=device, dtype=dtype)
+value = torch.rand(batch_size, num_heads, max_sequence_len, embed_dimension, device=device, dtype=dtype)
+
+print(f"The default implementation runs in {benchmark_torch_function_in_microseconds(F.scaled_dot_product_attention, query, key, value):.3f} microseconds")
+
+# Lets explore the speed of each of the 3 implementations
+from torch.nn.attention import SDPBackend, sdpa_kernel
+
+
+with sdpa_kernel(SDPBackend.MATH):
+    math_time=benchmark_torch_function_in_microseconds(F.scaled_dot_product_attention, query, key, value)
+    print(f"The math implementation runs in {math_time:.3f} microseconds")
+
+with sdpa_kernel(SDPBackend.FLASH_ATTENTION):
+    try:
+        flash_time=benchmark_torch_function_in_microseconds(F.scaled_dot_product_attention, query, key, value)
+        print(f"The flash attention implementation runs in {flash_time:.3f} microseconds")
+    except RuntimeError:
+        print("FlashAttention is not supported. See warnings for reasons.")
+
+with sdpa_kernel(SDPBackend.EFFICIENT_ATTENTION):
+    try:
+        efficient_time=benchmark_torch_function_in_microseconds(F.scaled_dot_product_attention, query, key, value)
+        print(f"The memory efficient implementation runs in {efficient_time:.3f} microseconds")
+    except RuntimeError:
+        print("EfficientAttention is not supported. See warnings for reasons.")
+
+
+######################################################################
+# Hardware dependence
+# ~~~~~~~~~~~~~~~~~~~
+#
+# Depending on what machine you ran the above cell on and what hardware is
+# available, your results might be different.
+# - If you don’t have a GPU and are running on CPU then with FP32 the context manager
+# will have no effect and all three runs should return similar timings.
+# - Depending on what compute capability your graphics card supports
+# flash attention or memory efficient might have failed.
+
+
+######################################################################
+# Causal Self Attention
+# ~~~~~~~~~~~~~~~~~~~~~
+#
+# Below is an example implementation of a multi-headed causal self
+# attention block inspired by
+# `Andrej Karpathy NanoGPT <https://github.com/karpathy/nanoGPT>`__ repository.
+#
+
+class CausalSelfAttention(nn.Module):
+
+    def __init__(self, num_heads: int, embed_dimension: int, bias: bool=False, is_causal: bool=False, dropout:float=0.0):
+        super().__init__()
+        assert embed_dimension % num_heads == 0
+        # key, query, value projections for all heads, but in a batch
+        self.c_attn = nn.Linear(embed_dimension, 3 * embed_dimension, bias=bias)
+        # output projection
+        self.c_proj = nn.Linear(embed_dimension, embed_dimension, bias=bias)
+        # regularization
+        self.dropout = dropout
+        self.resid_dropout = nn.Dropout(dropout)
+        self.num_heads = num_heads
+        self.embed_dimension = embed_dimension
+        # Perform causal masking
+        self.is_causal = is_causal
+
+    def forward(self, x):
+        # calculate query, key, values for all heads in batch and move head forward to be the batch dim
+        query_projected = self.c_attn(x)
+
+        batch_size = query_projected.size(0)
+        embed_dim = query_projected.size(2)
+        head_dim = embed_dim // (self.num_heads * 3)
+
+        query, key, value = query_projected.chunk(3, -1)
+        query = query.view(batch_size, -1, self.num_heads, head_dim).transpose(1, 2)
+        key = key.view(batch_size, -1, self.num_heads, head_dim).transpose(1, 2)
+        value = value.view(batch_size, -1, self.num_heads, head_dim).transpose(1, 2)
+
+        if self.training:
+            dropout = self.dropout
+            is_causal = self.is_causal
+        else:
+            dropout = 0.0
+            is_causal = False
+
+        y = F.scaled_dot_product_attention(query, key, value, attn_mask=None, dropout_p=dropout, is_causal=is_causal)
+        y = y.transpose(1, 2).view(batch_size, -1, self.num_heads * head_dim)
+
+        y = self.resid_dropout(self.c_proj(y))
+        return y
+
+
+num_heads = 8
+heads_per_dim = 64
+embed_dimension = num_heads * heads_per_dim
+dtype = torch.float16
+model = CausalSelfAttention(num_heads=num_heads, embed_dimension=embed_dimension, bias=False, is_causal=True, dropout=0.1).to("cuda").to(dtype).eval()
+print(model)
+
+
+#####################################################################
+# ``NestedTensor`` and Dense tensor support
+# -----------------------------------------
+#
+# SDPA supports both ``NestedTensor`` and Dense tensor inputs. ``NestedTensors`` handle the case where the input is a batch of variable length sequences
+# without needing to pad each sequence to the maximum length in the batch. For more information about ``NestedTensors`` see
+# `torch.nested <https://pytorch.org/docs/stable/nested.html>`__ and `NestedTensors Tutorial <https://pytorch.org/tutorials/prototype/nestedtensor.html>`__.
+#
+
+import random
+def generate_rand_batch(
+    batch_size,
+    max_sequence_len,
+    embed_dimension,
+    pad_percentage=None,
+    dtype=torch.float16,
+    device="cuda",
+):
+    if not pad_percentage:
+        return (
+            torch.randn(
+                batch_size,
+                max_sequence_len,
+                embed_dimension,
+                dtype=dtype,
+                device=device,
+            ),
+            None,
+        )
+    # Random sequence lengths
+    seq_len_list = [
+        int(max_sequence_len * (1 - random.gauss(pad_percentage, 0.01)))
+        for _ in range(batch_size)
+    ]
+    # Make random entry in the batch have max sequence length
+    seq_len_list[random.randint(0, batch_size - 1)] = max_sequence_len
+    return (
+        torch.nested.nested_tensor(
+            [
+                torch.randn(seq_len, embed_dimension,
+                            dtype=dtype, device=device)
+                for seq_len in seq_len_list
+            ]
+        ),
+        seq_len_list,
+    )
+
+random_nt, _ = generate_rand_batch(32, 512, embed_dimension, pad_percentage=0.5, dtype=dtype, device=device)
+random_dense, _ = generate_rand_batch(32, 512, embed_dimension, pad_percentage=None, dtype=dtype, device=device)
+
+# Currently the fused implementations don't support ``NestedTensor`` for training
+model.eval()
+
+with sdpa_kernel(SDPBackend.FLASH_ATTENTION):
+    try:
+        print(f"Random NT runs in {benchmark_torch_function_in_microseconds(model, random_nt):.3f} microseconds")
+        print(f"Random Dense runs in {benchmark_torch_function_in_microseconds(model, random_dense):.3f} microseconds")
+    except RuntimeError:
+        print("FlashAttention is not supported. See warnings for reasons.")
+
+
+######################################################################
+# Using SDPA with ``torch.compile``
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# With the release of PyTorch 2.0, a new feature called
+# ``torch.compile()`` has been introduced, which can provide
+# significant performance improvements over eager mode.
+# Scaled dot product attention is fully composable with ``torch.compile()``.
+# To demonstrate this, let's compile the ``CausalSelfAttention`` module using
+# ``torch.compile()`` and observe the resulting performance improvements.
+#
+
+batch_size = 32
+max_sequence_len = 256
+x = torch.rand(batch_size, max_sequence_len,
+               embed_dimension, device=device, dtype=dtype)
+print(
+    f"The non compiled module runs in  {benchmark_torch_function_in_microseconds(model, x):.3f} microseconds")
+
+
+compiled_model = torch.compile(model)
+# Let's compile it
+compiled_model(x)
+print(
+    f"The compiled module runs in  {benchmark_torch_function_in_microseconds(compiled_model, x):.3f} microseconds")
+
+
+######################################################################
+#
+# The exact execution time is dependent on machine, however the results for mine:
+# The non compiled module runs in  166.616 microseconds
+# The compiled module runs in  166.726 microseconds
+# That is not what we were expecting. Let's dig a little deeper.
+# PyTorch comes with an amazing built-in profiler that you can use to
+# inspect the performance characteristics of your code.
+#
+
+from torch.profiler import profile, record_function, ProfilerActivity
+activities = [ProfilerActivity.CPU]
+if device == 'cuda':
+    activities.append(ProfilerActivity.CUDA)
+
+with profile(activities=activities, record_shapes=False) as prof:
+    with record_function(" Non-Compilied Causal Attention"):
+        for _ in range(25):
+            model(x)
+print(prof.key_averages().table(sort_by="cuda_time_total", row_limit=10))
+
+
+with profile(activities=activities, record_shapes=False) as prof:
+    with record_function("Compiled Causal Attention"):
+        for _ in range(25):
+            compiled_model(x)
+print(prof.key_averages().table(sort_by="cuda_time_total", row_limit=10))
+
+# For even more insights, you can export the trace and use ``chrome://tracing`` to view the results
+#
+# .. code-block:: python
+#
+#    prof.export_chrome_trace("compiled_causal_attention_trace.json").
+
+
+
+
+######################################################################
+# The previous code snippet generates a report of the top 10 PyTorch functions
+# that consumed the most GPU execution time, for both the compiled and non-compiled module.
+# The analysis reveals that the majority of time spent on the GPU is concentrated
+# on the same set of functions for both modules.
+# The reason for this here is that ``torch.compile`` is very good at removing the
+# framework overhead associated with PyTorch. If your model is launching
+# large, efficient CUDA kernels, which in this case ``CausalSelfAttention``
+# is, then the overhead of PyTorch can be hidden.
+#
+# In reality, your module does not normally consist of a singular
+# ``CausalSelfAttention`` block. When experimenting with `Andrej Karpathy NanoGPT <https://github.com/karpathy/nanoGPT>`__ repository, compiling
+# the module took the time per train step from: ``6090.49ms`` to
+# ``3273.17ms``! This was done on commit: ``ae3a8d5`` of NanoGPT training on
+# the Shakespeare dataset.
+#
+
+######################################################################
+# Using SDPA with attn_bias subclasses
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+# As of PyTorch 2.3, we have added a new submodule that contains tensor subclasses.
+# Designed to be used with ``torch.nn.functional.scaled_dot_product_attention``.
+# The module is named ``torch.nn.attention.bias`` and contains the following two
+# utilities for generating causal attention variants:
+#
+# - ``torch.nn.attention.bias.causal_upper_left``
+# - ``torch.nn.attention.bias.causal_lower_right``
+#
+# .. note::
+#    The current argument ``is_causal`` in ``torch.nn.functional.scaled_dot_product_attention``
+#    is the same as using ``torch.nn.attention.bias.causal_upper_left``.
+#
+
+from torch.nn.attention.bias import causal_lower_right, causal_upper_left
+
+batch_size = 32
+sequence_length_q = 2
+sequence_length_kv = 10
+num_heads = 16
+embed_dimension = 32
+
+dtype = torch.float16
+
+query = torch.rand(batch_size, num_heads, sequence_length_q, embed_dimension, device=device, dtype=dtype)
+key = torch.rand(batch_size, num_heads, sequence_length_kv, embed_dimension, device=device, dtype=dtype)
+value = torch.rand(batch_size, num_heads, sequence_length_kv, embed_dimension, device=device, dtype=dtype)
+
+upper_left_bias = causal_upper_left(sequence_length_q, sequence_length_kv)
+lower_right_bias = causal_lower_right(sequence_length_q, sequence_length_kv)
+
+print(type(upper_left_bias))
+print(type(lower_right_bias))
+
+assert type(upper_left_bias) == type(lower_right_bias)
+assert issubclass(type(upper_left_bias), torch.Tensor)
+
+# As you can see from the previous output, are the same type ``torch.nn.attention.bias.CausalBias``
+# and subclass ``torch.Tensor``
+
+# Lets see what these tensors look like
+print(upper_left_bias)
+print(lower_right_bias)
+
+# Upper Left Bias aligns the causal attention mask to the upper left corner of the attention scores matrix.
+# This only has an impact when the attention scores matrix is not square, which is common for decoding use cases.
+# Another way of thinking about this concept is that when you use upper left bias,
+# the 0th token in the query is aligned to the 0th token in the key, while for lower right bias,
+# Assuming the attention score matrix is two dimensional, ``attn_score[0][0]`` is the attention score
+# between the 0th token in the query and the 0th token in the key.
+# For lower right bias, the sequence of q is aligned so that the last token in q is aligned to the last token in k
+# (for example, ``attn_score[-1][-1])`` is all True since the last token in q is at the same position as the last token in k
+# even if the sequence length of q and k are different.
+
+# These objects are intended to be used with sdpa
+out_upper_left = F.scaled_dot_product_attention(query, key, value, upper_left_bias)
+out_lower_right = F.scaled_dot_product_attention(query, key, value, lower_right_bias)
+out_is_causal = F.scaled_dot_product_attention(query, key, value, is_causal=True)
+
+assert torch.allclose(out_upper_left, out_is_causal)
+assert not torch.allclose(out_upper_left, out_lower_right)
+
+# These attention biases should also be compatible with torch.compile
+compiled_sdpa = torch.compile(F.scaled_dot_product_attention, fullgraph=True)
+out_upper_left = compiled_sdpa(query, key, value, upper_left_bias)
+
+######################################################################
+# Conclusion
+# ~~~~~~~~~~~
+#
+# In this tutorial, we have demonstrated the basic usage of
+# ``torch.nn.functional.scaled_dot_product_attention``. We have shown how
+# the ``sdpa_kernel`` context manager can be used to assert a certain
+# implementation is used on GPU. As well, we built a simple
+# ``CausalSelfAttention`` module that works with ``NestedTensor`` and is torch
+# compilable. In the process we have shown how to the profiling tools can
+# be used to explore the performance characteristics of a user defined
+# module.
+#
diff --git a/intermediate_source/seq2seq_translation_tutorial.py b/intermediate_source/seq2seq_translation_tutorial.py
old mode 100644
new mode 100755
index 587d5edfe94..5de4bb4ca3e
--- a/intermediate_source/seq2seq_translation_tutorial.py
+++ b/intermediate_source/seq2seq_translation_tutorial.py
@@ -1,13 +1,23 @@
 # -*- coding: utf-8 -*-
 """
-Translation with a Sequence to Sequence Network and Attention
-*************************************************************
-**Author**: `Sean Robertson <https://github.com/spro/practical-pytorch>`_
+NLP From Scratch: Translation with a Sequence to Sequence Network and Attention
+*******************************************************************************
+**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 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.
 
 In this project we will be teaching a neural network to translate from
 French to English.
 
-::
+.. code-block:: sh
 
     [KEY: > input, = target, < output]
 
@@ -70,23 +80,11 @@
 helpful as those concepts are very similar to the Encoder and Decoder
 models, respectively.
 
-And for more, read the papers that introduced these topics:
-
--  `Learning Phrase Representations using RNN Encoder-Decoder for
-   Statistical Machine Translation <https://arxiv.org/abs/1406.1078>`__
--  `Sequence to Sequence Learning with Neural
-   Networks <https://arxiv.org/abs/1409.3215>`__
--  `Neural Machine Translation by Jointly Learning to Align and
-   Translate <https://arxiv.org/abs/1409.0473>`__
--  `A Neural Conversational Model <https://arxiv.org/abs/1506.05869>`__
-
-
 **Requirements**
 """
 from __future__ import unicode_literals, print_function, division
 from io import open
 import unicodedata
-import string
 import re
 import random
 
@@ -95,6 +93,9 @@
 from torch import optim
 import torch.nn.functional as F
 
+import numpy as np
+from torch.utils.data import TensorDataset, DataLoader, RandomSampler
+
 device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 
 ######################################################################
@@ -111,15 +112,15 @@
 # yet, someone did the extra work of splitting language pairs into
 # individual text files here: https://www.manythings.org/anki/
 #
-# The English to French pairs are too big to include in the repo, so
+# The English to French pairs are too big to include in the repository, so
 # download to ``data/eng-fra.txt`` before continuing. The file is a tab
 # separated list of translation pairs:
 #
-# ::
+# .. code-block:: sh
 #
 #     I am cold.    J'ai froid.
 #
-# .. Note::
+# .. note::
 #    Download the data from
 #    `here <https://download.pytorch.org/tutorial/data.zip>`_
 #    and extract it to the current directory.
@@ -144,13 +145,12 @@
 # the networks later. To keep track of all this we will use a helper class
 # called ``Lang`` which has word → index (``word2index``) and index → word
 # (``index2word``) dictionaries, as well as a count of each word
-# ``word2count`` to use to later replace rare words.
+# ``word2count`` which will be used to replace rare words later.
 #
 
 SOS_token = 0
 EOS_token = 1
 
-
 class Lang:
     def __init__(self, name):
         self.name = name
@@ -188,13 +188,11 @@ def unicodeToAscii(s):
     )
 
 # Lowercase, trim, and remove non-letter characters
-
-
 def normalizeString(s):
     s = unicodeToAscii(s.lower().strip())
     s = re.sub(r"([.!?])", r" \1", s)
-    s = re.sub(r"[^a-zA-Z.!?]+", r" ", s)
-    return s
+    s = re.sub(r"[^a-zA-Z!?]+", r" ", s)
+    return s.strip()
 
 
 ######################################################################
@@ -246,7 +244,6 @@ def readLangs(lang1, lang2, reverse=False):
     "they are", "they re "
 )
 
-
 def filterPair(p):
     return len(p[0].split(' ')) < MAX_LENGTH and \
         len(p[1].split(' ')) < MAX_LENGTH and \
@@ -279,7 +276,6 @@ def prepareData(lang1, lang2, reverse=False):
     print(output_lang.name, output_lang.n_words)
     return input_lang, output_lang, pairs
 
-
 input_lang, output_lang, pairs = prepareData('eng', 'fra', True)
 print(random.choice(pairs))
 
@@ -306,10 +302,10 @@ def prepareData(lang1, lang2, reverse=False):
 # length and order, which makes it ideal for translation between two
 # languages.
 #
-# Consider the sentence "Je ne suis pas le chat noir" → "I am not the
-# black cat". Most of the words in the input sentence have a direct
+# Consider the sentence ``Je ne suis pas le chat noir`` → ``I am not the
+# black cat``. Most of the words in the input sentence have a direct
 # translation in the output sentence, but are in slightly different
-# orders, e.g. "chat noir" and "black cat". Because of the "ne/pas"
+# orders, e.g. ``chat noir`` and ``black cat``. Because of the ``ne/pas``
 # construction there is also one more word in the input sentence. It would
 # be difficult to produce a correct translation directly from the sequence
 # of input words.
@@ -335,22 +331,19 @@ def prepareData(lang1, lang2, reverse=False):
 #
 
 class EncoderRNN(nn.Module):
-    def __init__(self, input_size, hidden_size):
+    def __init__(self, input_size, hidden_size, dropout_p=0.1):
         super(EncoderRNN, self).__init__()
         self.hidden_size = hidden_size
 
         self.embedding = nn.Embedding(input_size, hidden_size)
-        self.gru = nn.GRU(hidden_size, hidden_size)
+        self.gru = nn.GRU(hidden_size, hidden_size, batch_first=True)
+        self.dropout = nn.Dropout(dropout_p)
 
-    def forward(self, input, hidden):
-        embedded = self.embedding(input).view(1, 1, -1)
-        output = embedded
-        output, hidden = self.gru(output, hidden)
+    def forward(self, input):
+        embedded = self.dropout(self.embedding(input))
+        output, hidden = self.gru(embedded)
         return output, hidden
 
-    def initHidden(self):
-        return torch.zeros(1, 1, self.hidden_size, device=device)
-
 ######################################################################
 # The Decoder
 # -----------
@@ -382,23 +375,39 @@ def initHidden(self):
 class DecoderRNN(nn.Module):
     def __init__(self, hidden_size, output_size):
         super(DecoderRNN, self).__init__()
-        self.hidden_size = hidden_size
-
         self.embedding = nn.Embedding(output_size, hidden_size)
-        self.gru = nn.GRU(hidden_size, hidden_size)
+        self.gru = nn.GRU(hidden_size, hidden_size, batch_first=True)
         self.out = nn.Linear(hidden_size, output_size)
-        self.softmax = nn.LogSoftmax(dim=1)
 
-    def forward(self, input, hidden):
-        output = self.embedding(input).view(1, 1, -1)
+    def forward(self, encoder_outputs, encoder_hidden, target_tensor=None):
+        batch_size = encoder_outputs.size(0)
+        decoder_input = torch.empty(batch_size, 1, dtype=torch.long, device=device).fill_(SOS_token)
+        decoder_hidden = encoder_hidden
+        decoder_outputs = []
+
+        for i in range(MAX_LENGTH):
+            decoder_output, decoder_hidden  = self.forward_step(decoder_input, decoder_hidden)
+            decoder_outputs.append(decoder_output)
+
+            if target_tensor is not None:
+                # Teacher forcing: Feed the target as the next input
+                decoder_input = target_tensor[:, i].unsqueeze(1) # Teacher forcing
+            else:
+                # Without teacher forcing: use its own predictions as the next input
+                _, topi = decoder_output.topk(1)
+                decoder_input = topi.squeeze(-1).detach()  # detach from history as input
+
+        decoder_outputs = torch.cat(decoder_outputs, dim=1)
+        decoder_outputs = F.log_softmax(decoder_outputs, dim=-1)
+        return decoder_outputs, decoder_hidden, None # We return `None` for consistency in the training loop
+
+    def forward_step(self, input, hidden):
+        output = self.embedding(input)
         output = F.relu(output)
         output, hidden = self.gru(output, hidden)
-        output = self.softmax(self.out(output[0]))
+        output = self.out(output)
         return output, hidden
 
-    def initHidden(self):
-        return torch.zeros(1, 1, self.hidden_size, device=device)
-
 ######################################################################
 # I encourage you to train and observe the results of this model, but to
 # save space we'll be going straight for the gold and introducing the
@@ -410,7 +419,7 @@ def initHidden(self):
 # Attention Decoder
 # ^^^^^^^^^^^^^^^^^
 #
-# If only the context vector is passed betweeen the encoder and decoder,
+# If only the context vector is passed between the encoder and decoder,
 # that single vector carries the burden of encoding the entire sentence.
 #
 # Attention allows the decoder network to "focus" on a different part of
@@ -436,42 +445,87 @@ def initHidden(self):
 #    :alt:
 #
 #
+# Bahdanau attention, also known as additive attention, is a commonly used
+# attention mechanism in sequence-to-sequence models, particularly in neural
+# machine translation tasks. It was introduced by Bahdanau et al. in their
+# paper titled `Neural Machine Translation by Jointly Learning to Align and Translate <https://arxiv.org/pdf/1409.0473.pdf>`__.
+# This attention mechanism employs a learned alignment model to compute attention
+# scores between the encoder and decoder hidden states. It utilizes a feed-forward
+# neural network to calculate alignment scores.
+#
+# However, there are alternative attention mechanisms available, such as Luong attention,
+# which computes attention scores by taking the dot product between the decoder hidden
+# state and the encoder hidden states. It does not involve the non-linear transformation
+# used in Bahdanau attention.
+#
+# In this tutorial, we will be using Bahdanau attention. However, it would be a valuable
+# exercise to explore modifying the attention mechanism to use Luong attention.
+
+class BahdanauAttention(nn.Module):
+    def __init__(self, hidden_size):
+        super(BahdanauAttention, self).__init__()
+        self.Wa = nn.Linear(hidden_size, hidden_size)
+        self.Ua = nn.Linear(hidden_size, hidden_size)
+        self.Va = nn.Linear(hidden_size, 1)
+
+    def forward(self, query, keys):
+        scores = self.Va(torch.tanh(self.Wa(query) + self.Ua(keys)))
+        scores = scores.squeeze(2).unsqueeze(1)
+
+        weights = F.softmax(scores, dim=-1)
+        context = torch.bmm(weights, keys)
+
+        return context, weights
 
 class AttnDecoderRNN(nn.Module):
-    def __init__(self, hidden_size, output_size, dropout_p=0.1, max_length=MAX_LENGTH):
+    def __init__(self, hidden_size, output_size, dropout_p=0.1):
         super(AttnDecoderRNN, self).__init__()
-        self.hidden_size = hidden_size
-        self.output_size = output_size
-        self.dropout_p = dropout_p
-        self.max_length = max_length
+        self.embedding = nn.Embedding(output_size, hidden_size)
+        self.attention = BahdanauAttention(hidden_size)
+        self.gru = nn.GRU(2 * hidden_size, hidden_size, batch_first=True)
+        self.out = nn.Linear(hidden_size, output_size)
+        self.dropout = nn.Dropout(dropout_p)
 
-        self.embedding = nn.Embedding(self.output_size, self.hidden_size)
-        self.attn = nn.Linear(self.hidden_size * 2, self.max_length)
-        self.attn_combine = nn.Linear(self.hidden_size * 2, self.hidden_size)
-        self.dropout = nn.Dropout(self.dropout_p)
-        self.gru = nn.GRU(self.hidden_size, self.hidden_size)
-        self.out = nn.Linear(self.hidden_size, self.output_size)
+    def forward(self, encoder_outputs, encoder_hidden, target_tensor=None):
+        batch_size = encoder_outputs.size(0)
+        decoder_input = torch.empty(batch_size, 1, dtype=torch.long, device=device).fill_(SOS_token)
+        decoder_hidden = encoder_hidden
+        decoder_outputs = []
+        attentions = []
+
+        for i in range(MAX_LENGTH):
+            decoder_output, decoder_hidden, attn_weights = self.forward_step(
+                decoder_input, decoder_hidden, encoder_outputs
+            )
+            decoder_outputs.append(decoder_output)
+            attentions.append(attn_weights)
+
+            if target_tensor is not None:
+                # Teacher forcing: Feed the target as the next input
+                decoder_input = target_tensor[:, i].unsqueeze(1) # Teacher forcing
+            else:
+                # Without teacher forcing: use its own predictions as the next input
+                _, topi = decoder_output.topk(1)
+                decoder_input = topi.squeeze(-1).detach()  # detach from history as input
 
-    def forward(self, input, hidden, encoder_outputs):
-        embedded = self.embedding(input).view(1, 1, -1)
-        embedded = self.dropout(embedded)
+        decoder_outputs = torch.cat(decoder_outputs, dim=1)
+        decoder_outputs = F.log_softmax(decoder_outputs, dim=-1)
+        attentions = torch.cat(attentions, dim=1)
 
-        attn_weights = F.softmax(
-            self.attn(torch.cat((embedded[0], hidden[0]), 1)), dim=1)
-        attn_applied = torch.bmm(attn_weights.unsqueeze(0),
-                                 encoder_outputs.unsqueeze(0))
+        return decoder_outputs, decoder_hidden, attentions
 
-        output = torch.cat((embedded[0], attn_applied[0]), 1)
-        output = self.attn_combine(output).unsqueeze(0)
 
-        output = F.relu(output)
-        output, hidden = self.gru(output, hidden)
+    def forward_step(self, input, hidden, encoder_outputs):
+        embedded =  self.dropout(self.embedding(input))
 
-        output = F.log_softmax(self.out(output[0]), dim=1)
-        return output, hidden, attn_weights
+        query = hidden.permute(1, 0, 2)
+        context, attn_weights = self.attention(query, encoder_outputs)
+        input_gru = torch.cat((embedded, context), dim=2)
 
-    def initHidden(self):
-        return torch.zeros(1, 1, self.hidden_size, device=device)
+        output, hidden = self.gru(input_gru, hidden)
+        output = self.out(output)
+
+        return output, hidden, attn_weights
 
 
 ######################################################################
@@ -495,18 +549,38 @@ def initHidden(self):
 def indexesFromSentence(lang, sentence):
     return [lang.word2index[word] for word in sentence.split(' ')]
 
-
 def tensorFromSentence(lang, sentence):
     indexes = indexesFromSentence(lang, sentence)
     indexes.append(EOS_token)
-    return torch.tensor(indexes, dtype=torch.long, device=device).view(-1, 1)
-
+    return torch.tensor(indexes, dtype=torch.long, device=device).view(1, -1)
 
 def tensorsFromPair(pair):
     input_tensor = tensorFromSentence(input_lang, pair[0])
     target_tensor = tensorFromSentence(output_lang, pair[1])
     return (input_tensor, target_tensor)
 
+def get_dataloader(batch_size):
+    input_lang, output_lang, pairs = prepareData('eng', 'fra', True)
+
+    n = len(pairs)
+    input_ids = np.zeros((n, MAX_LENGTH), dtype=np.int32)
+    target_ids = np.zeros((n, MAX_LENGTH), dtype=np.int32)
+
+    for idx, (inp, tgt) in enumerate(pairs):
+        inp_ids = indexesFromSentence(input_lang, inp)
+        tgt_ids = indexesFromSentence(output_lang, tgt)
+        inp_ids.append(EOS_token)
+        tgt_ids.append(EOS_token)
+        input_ids[idx, :len(inp_ids)] = inp_ids
+        target_ids[idx, :len(tgt_ids)] = tgt_ids
+
+    train_data = TensorDataset(torch.LongTensor(input_ids).to(device),
+                               torch.LongTensor(target_ids).to(device))
+
+    train_sampler = RandomSampler(train_data)
+    train_dataloader = DataLoader(train_data, sampler=train_sampler, batch_size=batch_size)
+    return input_lang, output_lang, train_dataloader
+
 
 ######################################################################
 # Training the Model
@@ -521,7 +595,7 @@ def tensorsFromPair(pair):
 # each next input, instead of using the decoder's guess as the next input.
 # Using teacher forcing causes it to converge faster but `when the trained
 # network is exploited, it may exhibit
-# instability <http://minds.jacobs-university.de/sites/default/files/uploads/papers/ESNTutorialRev.pdf>`__.
+# instability <http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.378.4095&rep=rep1&type=pdf>`__.
 #
 # You can observe outputs of teacher-forced networks that read with
 # coherent grammar but wander far from the correct translation -
@@ -535,59 +609,31 @@ def tensorsFromPair(pair):
 # ``teacher_forcing_ratio`` up to use more of it.
 #
 
-teacher_forcing_ratio = 0.5
-
-
-def train(input_tensor, target_tensor, encoder, decoder, encoder_optimizer, decoder_optimizer, criterion, max_length=MAX_LENGTH):
-    encoder_hidden = encoder.initHidden()
-
-    encoder_optimizer.zero_grad()
-    decoder_optimizer.zero_grad()
-
-    input_length = input_tensor.size(0)
-    target_length = target_tensor.size(0)
+def train_epoch(dataloader, encoder, decoder, encoder_optimizer,
+          decoder_optimizer, criterion):
 
-    encoder_outputs = torch.zeros(max_length, encoder.hidden_size, device=device)
+    total_loss = 0
+    for data in dataloader:
+        input_tensor, target_tensor = data
 
-    loss = 0
+        encoder_optimizer.zero_grad()
+        decoder_optimizer.zero_grad()
 
-    for ei in range(input_length):
-        encoder_output, encoder_hidden = encoder(
-            input_tensor[ei], encoder_hidden)
-        encoder_outputs[ei] = encoder_output[0, 0]
+        encoder_outputs, encoder_hidden = encoder(input_tensor)
+        decoder_outputs, _, _ = decoder(encoder_outputs, encoder_hidden, target_tensor)
 
-    decoder_input = torch.tensor([[SOS_token]], device=device)
+        loss = criterion(
+            decoder_outputs.view(-1, decoder_outputs.size(-1)),
+            target_tensor.view(-1)
+        )
+        loss.backward()
 
-    decoder_hidden = encoder_hidden
-
-    use_teacher_forcing = True if random.random() < teacher_forcing_ratio else False
-
-    if use_teacher_forcing:
-        # Teacher forcing: Feed the target as the next input
-        for di in range(target_length):
-            decoder_output, decoder_hidden, decoder_attention = decoder(
-                decoder_input, decoder_hidden, encoder_outputs)
-            loss += criterion(decoder_output, target_tensor[di])
-            decoder_input = target_tensor[di]  # Teacher forcing
-
-    else:
-        # Without teacher forcing: use its own predictions as the next input
-        for di in range(target_length):
-            decoder_output, decoder_hidden, decoder_attention = decoder(
-                decoder_input, decoder_hidden, encoder_outputs)
-            topv, topi = decoder_output.topk(1)
-            decoder_input = topi.squeeze().detach()  # detach from history as input
-
-            loss += criterion(decoder_output, target_tensor[di])
-            if decoder_input.item() == EOS_token:
-                break
+        encoder_optimizer.step()
+        decoder_optimizer.step()
 
-    loss.backward()
+        total_loss += loss.item()
 
-    encoder_optimizer.step()
-    decoder_optimizer.step()
-
-    return loss.item() / target_length
+    return total_loss / len(dataloader)
 
 
 ######################################################################
@@ -598,13 +644,11 @@ def train(input_tensor, target_tensor, encoder, decoder, encoder_optimizer, deco
 import time
 import math
 
-
 def asMinutes(s):
     m = math.floor(s / 60)
     s -= m * 60
     return '%dm %ds' % (m, s)
 
-
 def timeSince(since, percent):
     now = time.time()
     s = now - since
@@ -625,42 +669,35 @@ def timeSince(since, percent):
 # of examples, time so far, estimated time) and average loss.
 #
 
-def trainIters(encoder, decoder, n_iters, print_every=1000, plot_every=100, learning_rate=0.01):
+def train(train_dataloader, encoder, decoder, n_epochs, learning_rate=0.001,
+               print_every=100, plot_every=100):
     start = time.time()
     plot_losses = []
     print_loss_total = 0  # Reset every print_every
     plot_loss_total = 0  # Reset every plot_every
 
-    encoder_optimizer = optim.SGD(encoder.parameters(), lr=learning_rate)
-    decoder_optimizer = optim.SGD(decoder.parameters(), lr=learning_rate)
-    training_pairs = [tensorsFromPair(random.choice(pairs))
-                      for i in range(n_iters)]
+    encoder_optimizer = optim.Adam(encoder.parameters(), lr=learning_rate)
+    decoder_optimizer = optim.Adam(decoder.parameters(), lr=learning_rate)
     criterion = nn.NLLLoss()
 
-    for iter in range(1, n_iters + 1):
-        training_pair = training_pairs[iter - 1]
-        input_tensor = training_pair[0]
-        target_tensor = training_pair[1]
-
-        loss = train(input_tensor, target_tensor, encoder,
-                     decoder, encoder_optimizer, decoder_optimizer, criterion)
+    for epoch in range(1, n_epochs + 1):
+        loss = train_epoch(train_dataloader, encoder, decoder, encoder_optimizer, decoder_optimizer, criterion)
         print_loss_total += loss
         plot_loss_total += loss
 
-        if iter % print_every == 0:
+        if epoch % print_every == 0:
             print_loss_avg = print_loss_total / print_every
             print_loss_total = 0
-            print('%s (%d %d%%) %.4f' % (timeSince(start, iter / n_iters),
-                                         iter, iter / n_iters * 100, print_loss_avg))
+            print('%s (%d %d%%) %.4f' % (timeSince(start, epoch / n_epochs),
+                                        epoch, epoch / n_epochs * 100, print_loss_avg))
 
-        if iter % plot_every == 0:
+        if epoch % plot_every == 0:
             plot_loss_avg = plot_loss_total / plot_every
             plot_losses.append(plot_loss_avg)
             plot_loss_total = 0
 
     showPlot(plot_losses)
 
-
 ######################################################################
 # Plotting results
 # ----------------
@@ -674,7 +711,6 @@ def trainIters(encoder, decoder, n_iters, print_every=1000, plot_every=100, lear
 import matplotlib.ticker as ticker
 import numpy as np
 
-
 def showPlot(points):
     plt.figure()
     fig, ax = plt.subplots()
@@ -695,40 +731,23 @@ def showPlot(points):
 # attention outputs for display later.
 #
 
-def evaluate(encoder, decoder, sentence, max_length=MAX_LENGTH):
+def evaluate(encoder, decoder, sentence, input_lang, output_lang):
     with torch.no_grad():
         input_tensor = tensorFromSentence(input_lang, sentence)
-        input_length = input_tensor.size()[0]
-        encoder_hidden = encoder.initHidden()
-
-        encoder_outputs = torch.zeros(max_length, encoder.hidden_size, device=device)
 
-        for ei in range(input_length):
-            encoder_output, encoder_hidden = encoder(input_tensor[ei],
-                                                     encoder_hidden)
-            encoder_outputs[ei] += encoder_output[0, 0]
+        encoder_outputs, encoder_hidden = encoder(input_tensor)
+        decoder_outputs, decoder_hidden, decoder_attn = decoder(encoder_outputs, encoder_hidden)
 
-        decoder_input = torch.tensor([[SOS_token]], device=device)  # SOS
-
-        decoder_hidden = encoder_hidden
+        _, topi = decoder_outputs.topk(1)
+        decoded_ids = topi.squeeze()
 
         decoded_words = []
-        decoder_attentions = torch.zeros(max_length, max_length)
-
-        for di in range(max_length):
-            decoder_output, decoder_hidden, decoder_attention = decoder(
-                decoder_input, decoder_hidden, encoder_outputs)
-            decoder_attentions[di] = decoder_attention.data
-            topv, topi = decoder_output.data.topk(1)
-            if topi.item() == EOS_token:
+        for idx in decoded_ids:
+            if idx.item() == EOS_token:
                 decoded_words.append('<EOS>')
                 break
-            else:
-                decoded_words.append(output_lang.index2word[topi.item()])
-
-            decoder_input = topi.squeeze().detach()
-
-        return decoded_words, decoder_attentions[:di + 1]
+            decoded_words.append(output_lang.index2word[idx.item()])
+    return decoded_words, decoder_attn
 
 
 ######################################################################
@@ -741,7 +760,7 @@ def evaluateRandomly(encoder, decoder, n=10):
         pair = random.choice(pairs)
         print('>', pair[0])
         print('=', pair[1])
-        output_words, attentions = evaluate(encoder, decoder, pair[0])
+        output_words, _ = evaluate(encoder, decoder, pair[0], input_lang, output_lang)
         output_sentence = ' '.join(output_words)
         print('<', output_sentence)
         print('')
@@ -760,22 +779,28 @@ def evaluateRandomly(encoder, decoder, n=10):
 # single GRU layer. After about 40 minutes on a MacBook CPU we'll get some
 # reasonable results.
 #
-# .. Note::
+# .. note::
 #    If you run this notebook you can train, interrupt the kernel,
 #    evaluate, and continue training later. Comment out the lines where the
 #    encoder and decoder are initialized and run ``trainIters`` again.
 #
 
-hidden_size = 256
-encoder1 = EncoderRNN(input_lang.n_words, hidden_size).to(device)
-attn_decoder1 = AttnDecoderRNN(hidden_size, output_lang.n_words, dropout_p=0.1).to(device)
+hidden_size = 128
+batch_size = 32
+
+input_lang, output_lang, train_dataloader = get_dataloader(batch_size)
 
-trainIters(encoder1, attn_decoder1, 75000, print_every=5000)
+encoder = EncoderRNN(input_lang.n_words, hidden_size).to(device)
+decoder = AttnDecoderRNN(hidden_size, output_lang.n_words).to(device)
+
+train(train_dataloader, encoder, decoder, 80, print_every=5, plot_every=5)
 
 ######################################################################
 #
-
-evaluateRandomly(encoder1, attn_decoder1)
+# Set dropout layers to ``eval`` mode
+encoder.eval()
+decoder.eval()
+evaluateRandomly(encoder, decoder)
 
 
 ######################################################################
@@ -788,25 +813,14 @@ def evaluateRandomly(encoder, decoder, n=10):
 # at each time step.
 #
 # You could simply run ``plt.matshow(attentions)`` to see attention output
-# displayed as a matrix, with the columns being input steps and rows being
-# output steps:
-#
-
-output_words, attentions = evaluate(
-    encoder1, attn_decoder1, "je suis trop froid .")
-plt.matshow(attentions.numpy())
-
-
-######################################################################
-# For a better viewing experience we will do the extra work of adding axes
-# and labels:
+# displayed as a matrix. For a better viewing experience we will do the
+# extra work of adding axes and labels:
 #
 
 def showAttention(input_sentence, output_words, attentions):
-    # Set up figure with colorbar
     fig = plt.figure()
     ax = fig.add_subplot(111)
-    cax = ax.matshow(attentions.numpy(), cmap='bone')
+    cax = ax.matshow(attentions.cpu().numpy(), cmap='bone')
     fig.colorbar(cax)
 
     # Set up axes
@@ -822,20 +836,19 @@ def showAttention(input_sentence, output_words, attentions):
 
 
 def evaluateAndShowAttention(input_sentence):
-    output_words, attentions = evaluate(
-        encoder1, attn_decoder1, input_sentence)
+    output_words, attentions = evaluate(encoder, decoder, input_sentence, input_lang, output_lang)
     print('input =', input_sentence)
     print('output =', ' '.join(output_words))
-    showAttention(input_sentence, output_words, attentions)
+    showAttention(input_sentence, output_words, attentions[0, :len(output_words), :])
 
 
-evaluateAndShowAttention("elle a cinq ans de moins que moi .")
+evaluateAndShowAttention('il n est pas aussi grand que son pere')
 
-evaluateAndShowAttention("elle est trop petit .")
+evaluateAndShowAttention('je suis trop fatigue pour conduire')
 
-evaluateAndShowAttention("je ne crains pas de mourir .")
+evaluateAndShowAttention('je suis desole si c est une question idiote')
 
-evaluateAndShowAttention("c est un jeune directeur plein de talent .")
+evaluateAndShowAttention('je suis reellement fiere de vous')
 
 
 ######################################################################
@@ -849,8 +862,8 @@ def evaluateAndShowAttention(input_sentence):
 #    -  Chat → Response
 #    -  Question → Answer
 #
-# -  Replace the embeddings with pre-trained word embeddings such as word2vec or
-#    GloVe
+# -  Replace the embeddings with pretrained word embeddings such as ``word2vec`` or
+#    ``GloVe``
 # -  Try with more layers, more hidden units, and more sentences. Compare
 #    the training time and results.
 # -  If you use a translation file where pairs have two of the same phrase
diff --git a/intermediate_source/spatial_transformer_tutorial.py b/intermediate_source/spatial_transformer_tutorial.py
index 9fa3317aac1..99efe41b39b 100644
--- a/intermediate_source/spatial_transformer_tutorial.py
+++ b/intermediate_source/spatial_transformer_tutorial.py
@@ -27,7 +27,6 @@
 # License: BSD
 # Author: Ghassen Hamrouni
 
-from __future__ import print_function
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
@@ -47,6 +46,11 @@
 # standard convolutional network augmented with a spatial transformer
 # network.
 
+from six.moves import urllib
+opener = urllib.request.build_opener()
+opener.addheaders = [('User-agent', 'Mozilla/5.0')]
+urllib.request.install_opener(opener)
+
 device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 
 # Training dataset
@@ -80,7 +84,7 @@
 #
 # .. figure:: /_static/img/stn/stn-arch.png
 #
-# .. Note::
+# .. note::
 #    We need the latest version of PyTorch that contains
 #    affine_grid and grid_sample modules.
 #
@@ -171,7 +175,7 @@ def train(epoch):
                 epoch, batch_idx * len(data), len(train_loader.dataset),
                 100. * batch_idx / len(train_loader), loss.item()))
 #
-# A simple test procedure to measure STN the performances on MNIST.
+# A simple test procedure to measure the STN performances on MNIST.
 #
 
 
diff --git a/intermediate_source/speech_recognition_pipeline_tutorial.rst b/intermediate_source/speech_recognition_pipeline_tutorial.rst
new file mode 100644
index 00000000000..4ec497b3bd8
--- /dev/null
+++ b/intermediate_source/speech_recognition_pipeline_tutorial.rst
@@ -0,0 +1,10 @@
+Speech Recognition with Wav2Vec2
+================================
+
+This tutorial has been moved to https://pytorch.org/audio/stable/tutorials/speech_recognition_pipeline_tutorial.html
+
+It will redirect in 3 seconds.
+
+.. raw:: html
+
+   <meta http-equiv="Refresh" content="3; url='https://pytorch.org/audio/stable/tutorials/speech_recognition_pipeline_tutorial.html'" />
diff --git a/intermediate_source/tensorboard_profiler_tutorial.py b/intermediate_source/tensorboard_profiler_tutorial.py
new file mode 100644
index 00000000000..3782ced18d9
--- /dev/null
+++ b/intermediate_source/tensorboard_profiler_tutorial.py
@@ -0,0 +1,509 @@
+"""
+PyTorch Profiler With TensorBoard
+====================================
+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
+recording the CPU side operations as well as the CUDA kernel launches on the GPU side.
+The profiler can visualize this information
+in TensorBoard Plugin and provide analysis of the performance bottlenecks.
+
+In this tutorial, we will use a simple Resnet model to demonstrate how to
+use TensorBoard plugin to analyze model performance.
+
+Setup
+-----
+To install ``torch`` and ``torchvision`` use the following command:
+
+.. code-block::
+
+   pip install torch torchvision
+
+
+"""
+
+
+######################################################################
+# Steps
+# -----
+#
+# 1. Prepare the data and model
+# 2. Use profiler to record execution events
+# 3. Run the profiler
+# 4. Use TensorBoard to view results and analyze model performance
+# 5. Improve performance with the help of profiler
+# 6. Analyze performance with other advanced features
+# 7. Additional Practices: Profiling PyTorch on AMD GPUs 
+#
+# 1. Prepare the data and model
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# First, import all necessary libraries:
+#
+
+import torch
+import torch.nn
+import torch.optim
+import torch.profiler
+import torch.utils.data
+import torchvision.datasets
+import torchvision.models
+import torchvision.transforms as T
+
+######################################################################
+# Then prepare the input data. For this tutorial, we use the CIFAR10 dataset.
+# Transform it to the desired format and use ``DataLoader`` to load each batch.
+
+transform = T.Compose(
+    [T.Resize(224),
+     T.ToTensor(),
+     T.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
+train_set = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
+train_loader = torch.utils.data.DataLoader(train_set, batch_size=32, shuffle=True)
+
+######################################################################
+# Next, create Resnet model, loss function, and optimizer objects.
+# To run on GPU, move model and loss to GPU device.
+
+device = torch.device("cuda:0")
+model = torchvision.models.resnet18(weights='IMAGENET1K_V1').cuda(device)
+criterion = torch.nn.CrossEntropyLoss().cuda(device)
+optimizer = torch.optim.SGD(model.parameters(), lr=0.001, momentum=0.9)
+model.train()
+
+
+######################################################################
+# Define the training step for each batch of input data.
+
+def train(data):
+    inputs, labels = data[0].to(device=device), data[1].to(device=device)
+    outputs = model(inputs)
+    loss = criterion(outputs, labels)
+    optimizer.zero_grad()
+    loss.backward()
+    optimizer.step()
+
+
+######################################################################
+# 2. Use profiler to record execution events
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# The profiler is enabled through the context manager and accepts several parameters,
+# some of the most useful are:
+#
+# - ``schedule`` - callable that takes step (int) as a single parameter
+#   and returns the profiler action to perform at each step.
+#
+#   In this example with ``wait=1, warmup=1, active=3, repeat=1``,
+#   profiler will skip the first step/iteration,
+#   start warming up on the second,
+#   record the following three iterations,
+#   after which the trace will become available and on_trace_ready (when set) is called.
+#   In total, the cycle repeats once. Each cycle is called a "span" in TensorBoard plugin.
+#
+#   During ``wait`` steps, the profiler is disabled.
+#   During ``warmup`` steps, the profiler starts tracing but the results are discarded.
+#   This is for reducing the profiling overhead.
+#   The overhead at the beginning of profiling is high and easy to bring skew to the profiling result.
+#   During ``active`` steps, the profiler works and records events.
+# - ``on_trace_ready`` - callable that is called at the end of each cycle;
+#   In this example we use ``torch.profiler.tensorboard_trace_handler`` to generate result files for TensorBoard.
+#   After profiling, result files will be saved into the ``./log/resnet18`` directory.
+#   Specify this directory as a ``logdir`` parameter to analyze profile in TensorBoard.
+# - ``record_shapes`` - whether to record shapes of the operator inputs.
+# - ``profile_memory`` - Track tensor memory allocation/deallocation. Note, for old version of pytorch with version
+#   before 1.10, if you suffer long profiling time, please disable it or upgrade to new version.
+# - ``with_stack`` - Record source information (file and line number) for the ops.
+#   If the TensorBoard is launched in VS Code (`reference <https://code.visualstudio.com/docs/datascience/pytorch-support#_tensorboard-integration>`_),
+#   clicking a stack frame will navigate to the specific code line.
+
+with torch.profiler.profile(
+        schedule=torch.profiler.schedule(wait=1, warmup=1, active=3, repeat=1),
+        on_trace_ready=torch.profiler.tensorboard_trace_handler('./log/resnet18'),
+        record_shapes=True,
+        profile_memory=True,
+        with_stack=True
+) as prof:
+    for step, batch_data in enumerate(train_loader):
+        prof.step()  # Need to call this at each step to notify profiler of steps' boundary.
+        if step >= 1 + 1 + 3:
+            break
+        train(batch_data)
+
+######################################################################
+# Alternatively, the following non-context manager start/stop is supported as well.
+prof = torch.profiler.profile(
+        schedule=torch.profiler.schedule(wait=1, warmup=1, active=3, repeat=1),
+        on_trace_ready=torch.profiler.tensorboard_trace_handler('./log/resnet18'),
+        record_shapes=True,
+        with_stack=True)
+prof.start()
+for step, batch_data in enumerate(train_loader):
+    prof.step()
+    if step >= 1 + 1 + 3:
+        break
+    train(batch_data)
+prof.stop()
+
+######################################################################
+# 3. Run the profiler
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# Run the above code. The profiling result will be saved under ``./log/resnet18`` directory.
+
+
+######################################################################
+# 4. Use TensorBoard to view results and analyze model performance
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# .. note::
+#     TensorBoard Plugin support has been deprecated, so some of these functions may not
+#     work as previously. Please take a look at the replacement, `HTA <https://github.com/pytorch/kineto/tree/main#holistic-trace-analysis>`_.
+#
+# Install PyTorch Profiler TensorBoard Plugin.
+#
+# .. code-block::
+#
+#     pip install torch_tb_profiler
+#
+
+######################################################################
+# Launch the TensorBoard.
+#
+# .. code-block::
+#
+#     tensorboard --logdir=./log
+#
+
+######################################################################
+# Open the TensorBoard profile URL in Google Chrome browser or Microsoft Edge browser (**Safari is not supported**).
+#
+# .. code-block::
+#
+#     http://localhost:6006/#pytorch_profiler
+#
+
+######################################################################
+# You could see Profiler plugin page as shown below.
+#
+# - Overview
+# .. image:: ../../_static/img/profiler_overview1.png
+#    :scale: 25 %
+#
+# The overview shows a high-level summary of model performance.
+#
+# The "GPU Summary" panel shows the GPU configuration, GPU usage and Tensor Cores usage.
+# In this example, the GPU Utilization is low.
+# The details of these metrics are `here <https://github.com/pytorch/kineto/blob/main/tb_plugin/docs/gpu_utilization.md>`_.
+#
+# The "Step Time Breakdown" shows distribution of time spent in each step over different categories of execution.
+# In this example, you can see the ``DataLoader`` overhead is significant.
+#
+# The bottom "Performance Recommendation" uses the profiling data
+# to automatically highlight likely bottlenecks,
+# and gives you actionable optimization suggestions.
+#
+# You can change the view page in left "Views" dropdown list.
+#
+# .. image:: ../../_static/img/profiler_views_list.png
+#    :alt:
+#
+#
+# - Operator view
+# The operator view displays the performance of every PyTorch operator
+# that is executed either on the host or device.
+#
+# .. image:: ../../_static/img/profiler_operator_view.png
+#    :scale: 25 %
+# The "Self" duration does not include its child operators’ time.
+# The "Total" duration includes its child operators’ time.
+#
+# - View call stack
+# Click the ``View Callstack`` of an operator, the operators with same name but different call stacks will be shown.
+# Then click a ``View Callstack`` in this sub-table, the call stack frames will be shown.
+#
+# .. image:: ../../_static/img/profiler_callstack.png
+#    :scale: 25 %
+#
+# If the TensorBoard is launched inside VS Code
+# (`Launch Guide <https://devblogs.microsoft.com/python/python-in-visual-studio-code-february-2021-release/#tensorboard-integration>`_),
+# clicking a call stack frame will navigate to the specific code line.
+#
+# .. image:: ../../_static/img/profiler_vscode.png
+#    :scale: 25 %
+#
+#
+# - Kernel view
+# The GPU kernel view shows all kernels’ time spent on GPU.
+#
+# .. image:: ../../_static/img/profiler_kernel_view.png
+#    :scale: 25 %
+# Tensor Cores Used:
+# Whether this kernel uses Tensor Cores.
+#
+# Mean Blocks per SM:
+# Blocks per SM = Blocks of this kernel / SM number of this GPU.
+# If this number is less than 1, it indicates the GPU multiprocessors are not fully utilized.
+# "Mean Blocks per SM" is weighted average of all runs of this kernel name, using each run’s duration as weight.
+#
+# Mean Est. Achieved Occupancy:
+# Est. Achieved Occupancy is defined in this column’s tooltip.
+# For most cases such as memory bandwidth bounded kernels, the higher the better.
+# "Mean Est. Achieved Occupancy" is weighted average of all runs of this kernel name,
+# using each run’s duration as weight.
+#
+# - Trace view
+# The trace view shows timeline of profiled operators and GPU kernels.
+# You can select it to see details as below.
+#
+# .. image:: ../../_static/img/profiler_trace_view1.png
+#    :scale: 25 %
+#
+# You can move the graph and zoom in/out with the help of right side toolbar.
+# And keyboard can also be used to zoom and move around inside the timeline.
+# The ‘w’ and ‘s’ keys zoom in centered around the mouse,
+# and the ‘a’ and ‘d’ keys move the timeline left and right.
+# You can hit these keys multiple times until you see a readable representation.
+#
+# If a backward operator's "Incoming Flow" field is with value "forward correspond to backward",
+# you can click the text to get its launching forward operator.
+#
+# .. image:: ../../_static/img/profiler_trace_view_fwd_bwd.png
+#    :scale: 25 %
+#
+# In this example, we can see the event prefixed with ``enumerate(DataLoader)`` costs a lot of time.
+# And during most of this period, the GPU is idle.
+# Because this function is loading data and transforming data on host side,
+# during which the GPU resource is wasted.
+
+
+######################################################################
+# 5. Improve performance with the help of profiler
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# At the bottom of "Overview" page, the suggestion in "Performance Recommendation" hints the bottleneck is ``DataLoader``.
+# The PyTorch ``DataLoader`` uses single process by default.
+# User could enable multi-process data loading by setting the parameter ``num_workers``.
+# `Here <https://pytorch.org/docs/stable/data.html#single-and-multi-process-data-loading>`_ is more details.
+#
+# In this example, we follow the "Performance Recommendation" and set ``num_workers`` as below,
+# pass a different name such as ``./log/resnet18_4workers`` to ``tensorboard_trace_handler``, and run it again.
+#
+# .. code-block::
+#
+#     train_loader = torch.utils.data.DataLoader(train_set, batch_size=32, shuffle=True, num_workers=4)
+#
+
+######################################################################
+# Then let’s choose the recently profiled run in left "Runs" dropdown list.
+#
+# .. image:: ../../_static/img/profiler_overview2.png
+#    :scale: 25 %
+#
+# From the above view, we can find the step time is reduced to about 76ms comparing with previous run's 132ms,
+# and the time reduction of ``DataLoader`` mainly contributes.
+#
+# .. image:: ../../_static/img/profiler_trace_view2.png
+#    :scale: 25 %
+#
+# From the above view, we can see that the runtime of ``enumerate(DataLoader)`` is reduced,
+# and the GPU utilization is increased.
+
+######################################################################
+# 6. Analyze performance with other advanced features
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# - Memory view
+# To profile memory, ``profile_memory`` must be set to ``True`` in arguments of ``torch.profiler.profile``.
+#
+# You can try it by using existing example on Azure
+#
+# .. code-block::
+#
+#     pip install azure-storage-blob
+#     tensorboard --logdir=https://torchtbprofiler.blob.core.windows.net/torchtbprofiler/demo/memory_demo_1_10
+#
+# The profiler records all memory allocation/release events and allocator's internal state during profiling.
+# The memory view consists of three components as shown in the following.
+#
+# .. image:: ../../_static/img/profiler_memory_view.png
+#    :scale: 25 %
+#
+# The components are memory curve graph, memory events table and memory statistics table, from top to bottom, respectively.
+#
+# The memory type could be selected in "Device" selection box.
+# For example, "GPU0" means the following table only shows each operator's memory usage on GPU 0, not including CPU or other GPUs.
+#
+# The memory curve shows the trends of memory consumption. The "Allocated" curve shows the total memory that is actually
+# in use, e.g., tensors. In PyTorch, caching mechanism is employed in CUDA allocator and some other allocators. The
+# "Reserved" curve shows the total memory that is reserved by the allocator. You can left click and drag on the graph
+# to select events in the desired range:
+#
+# .. image:: ../../_static/img/profiler_memory_curve_selecting.png
+#    :scale: 25 %
+#
+# After selection, the three components will be updated for the restricted time range, so that you can gain more
+# information about it. By repeating this process, you can zoom into a very fine-grained detail. Right click on the graph
+# will reset the graph to the initial state.
+#
+# .. image:: ../../_static/img/profiler_memory_curve_single.png
+#    :scale: 25 %
+#
+# In the memory events table, the allocation and release events are paired into one entry. The "operator" column shows
+# the immediate ATen operator that is causing the allocation. Notice that in PyTorch, ATen operators commonly use
+# ``aten::empty`` to allocate memory. For example, ``aten::ones`` is implemented as ``aten::empty`` followed by an
+# ``aten::fill_``. Solely display the operator name as ``aten::empty`` is of little help. It will be shown as
+# ``aten::ones (aten::empty)`` in this special case. The "Allocation Time", "Release Time" and "Duration"
+# columns' data might be missing if the event occurs outside of the time range. 
+#
+# In the memory statistics table, the "Size Increase" column sums up all allocation size and minus all the memory
+# release size, that is, the net increase of memory usage after this operator. The "Self Size Increase" column is
+# similar to "Size Increase", but it does not count children operators' allocation. With regards to ATen operators'
+# implementation detail, some operators might call other operators, so memory allocations can happen at any level of the
+# call stack. That says, "Self Size Increase" only count the memory usage increase at current level of call stack.
+# Finally, the "Allocation Size" column sums up all allocation without considering the memory release.
+#
+# - Distributed view
+# The plugin now supports distributed view on profiling DDP with NCCL/GLOO as backend.
+#
+# You can try it by using existing example on Azure:
+#
+# .. code-block::
+#
+#     pip install azure-storage-blob
+#     tensorboard --logdir=https://torchtbprofiler.blob.core.windows.net/torchtbprofiler/demo/distributed_bert
+#
+# .. image:: ../../_static/img/profiler_distributed_view.png
+#    :scale: 25 %
+#
+# The "Computation/Communication Overview" shows computation/communication ratio and their overlapping degree.
+# From this view, User can figure out load balance issue among workers.
+# For example, if the computation + overlapping time of one worker is much larger than others,
+# there may be a problem of load balance or this worker may be a straggler.
+#
+# The "Synchronizing/Communication Overview" shows the efficiency of communication.
+# "Data Transfer Time" is the time for actual data exchanging.
+# "Synchronizing Time" is the time for waiting and synchronizing with other workers.
+#
+# If one worker’s "Synchronizing Time" is much shorter than that of other workers’,
+# this worker may be a straggler which may have more computation workload than other workers’.
+#
+# The "Communication Operations Stats" summarizes the detailed statistics of all communication ops in each worker.
+
+######################################################################
+# 7. Additional Practices: Profiling PyTorch on AMD GPUs
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+#  
+# The AMD ROCm Platform is an open-source software stack designed for GPU computation, consisting of drivers, development tools, and APIs. 
+# We can run the above mentioned steps on AMD GPUs. In this section, we will use Docker to install the ROCm base development image
+# before installing PyTorch.
+
+
+######################################################################
+# For the purpose of example, let's create a directory called ``profiler_tutorial``, and save the code in **Step 1** as ``test_cifar10.py`` in this directory. 
+# 
+# .. code-block::
+#
+#      mkdir ~/profiler_tutorial
+#      cd profiler_tutorial
+#      vi test_cifar10.py
+
+
+######################################################################
+# At the time of this writing, the Stable(``2.1.1``) Linux version of PyTorch on ROCm Platform is `ROCm 5.6 <https://pytorch.org/get-started/locally/>`_. 
+#
+#
+# - Obtain a base Docker image with the correct user-space ROCm version installed from `Docker Hub <https://hub.docker.com/repository/docker/rocm/dev-ubuntu-20.04>`_.
+#
+# It is ``rocm/dev-ubuntu-20.04:5.6``.
+#
+# - Start the ROCm base Docker container:
+#
+#
+# .. code-block::
+#
+#     docker run -it --network=host --device=/dev/kfd --device=/dev/dri --group-add=video --ipc=host --cap-add=SYS_PTRACE --security-opt seccomp=unconfined --shm-size 8G -v ~/profiler_tutorial:/profiler_tutorial rocm/dev-ubuntu-20.04:5.6
+#
+#
+# - Inside the container, install any dependencies needed for installing the wheels package.
+#
+# .. code-block::
+#
+#     sudo apt update
+#     sudo apt install libjpeg-dev python3-dev -y
+#     pip3 install wheel setuptools
+#     sudo apt install python-is-python3 
+#
+#
+# - Install the wheels:
+#
+# .. code-block::
+# 
+#     pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/rocm5.6
+#
+#
+# - Install the ``torch_tb_profiler``, and then, run the Python file ``test_cifar10.py``:
+# 
+# .. code-block::
+#
+#     pip install torch_tb_profiler
+#     cd /profiler_tutorial
+#     python test_cifar10.py
+#
+#     
+# Now, we have all the data needed to view in TensorBoard:
+# 
+# .. code-block::
+#
+#      tensorboard --logdir=./log
+#
+# Choose different views as described in **Step 4**. For example, below is the **Operator** View:
+#
+# .. image:: ../../_static/img/profiler_rocm_tensorboard_operartor_view.png
+#    :scale: 25 %
+
+
+######################################################################
+# At the time this section is written, **Trace** view does not work and it displays nothing. You can work around by typing ``chrome://tracing`` in your Chrome Browser.
+#
+# 
+# - Copy the ``trace.json`` file under ``~/profiler_tutorial/log/resnet18`` directory to the Windows.  
+# You may need to copy the file by using ``scp`` if the file is located in a remote location. 
+# 
+# - Click **Load** button to load the trace JSON file from the ``chrome://tracing`` page in the browser. 
+#
+# .. image:: ../../_static/img/profiler_rocm_chrome_trace_view.png
+#    :scale: 25 %
+
+
+######################################################################
+# As mentioned previously, you can move the graph and zoom in and out.
+# You can also use keyboard to zoom and move around inside the timeline.
+# The ``w`` and ``s`` keys zoom in centered around the mouse,
+# and the ``a`` and ``d`` keys move the timeline left and right.
+# You can hit these keys multiple times until you see a readable representation.
+
+
+
+######################################################################
+# Learn More
+# ----------
+#
+# Take a look at the following documents to continue your learning,
+# and feel free to open an issue `here <https://github.com/pytorch/kineto/issues>`_.
+#
+# -  `PyTorch TensorBoard Profiler Github <https://github.com/pytorch/kineto/tree/master/tb_plugin>`_
+# -  `torch.profiler API <https://pytorch.org/docs/master/profiler.html>`_
+# -  `HTA <https://github.com/pytorch/kineto/tree/main#holistic-trace-analysis>`_
diff --git a/intermediate_source/tensorboard_tutorial.rst b/intermediate_source/tensorboard_tutorial.rst
new file mode 100644
index 00000000000..d599dd098c5
--- /dev/null
+++ b/intermediate_source/tensorboard_tutorial.rst
@@ -0,0 +1,401 @@
+Visualizing Models, Data, and Training with TensorBoard
+=======================================================
+
+In the `60 Minute Blitz <https://pytorch.org/tutorials/beginner/deep_learning_60min_blitz.html>`_,
+we show you how to load in data,
+feed it through a model we define as a subclass of ``nn.Module``,
+train this model on training data, and test it on test data.
+To see what's happening, we print out some statistics as the model
+is training to get a sense for whether training is progressing.
+However, we can do much better than that: PyTorch integrates with
+TensorBoard, a tool designed for visualizing the results of neural
+network training runs. This tutorial illustrates some of its
+functionality, using the
+`Fashion-MNIST dataset <https://github.com/zalandoresearch/fashion-mnist>`__
+which can be read into PyTorch using `torchvision.datasets`.
+
+In this tutorial, we'll learn how to:
+
+    1. Read in data and with appropriate transforms (nearly identical to the prior tutorial).
+    2. Set up TensorBoard.
+    3. Write to TensorBoard.
+    4. Inspect a model architecture using TensorBoard.
+    5. Use TensorBoard to create interactive versions of the visualizations we created in last tutorial, with less code
+
+Specifically, on point #5, we'll see:
+
+    * A couple of ways to inspect our training data
+    * How to track our model's performance as it trains
+    * How to assess our model's performance once it is trained.
+
+We'll begin with similar boilerplate code as in the `CIFAR-10 tutorial <https://pytorch.org/tutorials/beginner/blitz/cifar10_tutorial.html>`__:
+
+.. code:: python
+
+    # imports
+    import matplotlib.pyplot as plt
+    import numpy as np
+
+    import torch
+    import torchvision
+    import torchvision.transforms as transforms
+
+    import torch.nn as nn
+    import torch.nn.functional as F
+    import torch.optim as optim
+
+    # transforms
+    transform = transforms.Compose(
+        [transforms.ToTensor(),
+        transforms.Normalize((0.5,), (0.5,))])
+
+    # datasets
+    trainset = torchvision.datasets.FashionMNIST('./data',
+        download=True,
+        train=True,
+        transform=transform)
+    testset = torchvision.datasets.FashionMNIST('./data',
+        download=True,
+        train=False,
+        transform=transform)
+
+    # dataloaders
+    trainloader = torch.utils.data.DataLoader(trainset, batch_size=4, shuffle=True)
+
+    testloader = torch.utils.data.DataLoader(testset, batch_size=4, shuffle=False)
+
+    # constant for classes
+    classes = ('T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat',
+            'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle Boot')
+
+    # helper function to show an image
+    # (used in the `plot_classes_preds` function below)
+    def matplotlib_imshow(img, one_channel=False):
+        if one_channel:
+            img = img.mean(dim=0)
+        img = img / 2 + 0.5     # unnormalize
+        npimg = img.numpy()
+        if one_channel:
+            plt.imshow(npimg, cmap="Greys")
+        else:
+            plt.imshow(np.transpose(npimg, (1, 2, 0)))
+
+We'll define a similar model architecture from that tutorial, making only
+minor modifications to account for the fact that the images are now
+one channel instead of three and 28x28 instead of 32x32:
+
+.. code:: python
+
+    class Net(nn.Module):
+        def __init__(self):
+            super(Net, self).__init__()
+            self.conv1 = nn.Conv2d(1, 6, 5)
+            self.pool = nn.MaxPool2d(2, 2)
+            self.conv2 = nn.Conv2d(6, 16, 5)
+            self.fc1 = nn.Linear(16 * 4 * 4, 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 * 4 * 4)
+            x = F.relu(self.fc1(x))
+            x = F.relu(self.fc2(x))
+            x = self.fc3(x)
+            return x
+
+
+    net = Net()
+
+We'll define the same ``optimizer`` and ``criterion`` from before:
+
+.. code:: python
+
+    criterion = nn.CrossEntropyLoss()
+    optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
+
+1. TensorBoard setup
+~~~~~~~~~~~~~~~~~~~~~
+
+Now we'll set up TensorBoard, importing ``tensorboard`` from ``torch.utils`` and defining a
+``SummaryWriter``, our key object for writing information to TensorBoard.
+
+.. code:: python
+
+    from torch.utils.tensorboard import SummaryWriter
+
+    # default `log_dir` is "runs" - we'll be more specific here
+    writer = SummaryWriter('runs/fashion_mnist_experiment_1')
+
+Note that this line alone creates a ``runs/fashion_mnist_experiment_1``
+folder.
+
+2. Writing to TensorBoard
+~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Now let's write an image to our TensorBoard - specifically, a grid -
+using `make_grid <https://pytorch.org/vision/stable/utils.html#torchvision.utils.make_grid>`__.
+
+.. code:: python
+
+    # get some random training images
+    dataiter = iter(trainloader)
+    images, labels = next(dataiter)
+
+    # create grid of images
+    img_grid = torchvision.utils.make_grid(images)
+
+    # show images
+    matplotlib_imshow(img_grid, one_channel=True)
+
+    # write to tensorboard
+    writer.add_image('four_fashion_mnist_images', img_grid)
+
+Now running
+
+::
+
+    PYTHONWARNINGS="ignore:pkg_resources is deprecated as an API:UserWarning" tensorboard --logdir=runs
+
+from the command line and then navigating to `http://localhost:6006 <http://localhost:6006>`_
+should show the following.
+
+.. image:: ../../_static/img/tensorboard_first_view.png
+
+Now you know how to use TensorBoard! This example, however, could be
+done in a Jupyter Notebook - where TensorBoard really excels is in
+creating interactive visualizations. We'll cover one of those next,
+and several more by the end of the tutorial.
+
+3. Inspect the model using TensorBoard
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+One of TensorBoard's strengths is its ability to visualize complex model
+structures. Let's visualize the model we built.
+
+.. code:: python
+
+    writer.add_graph(net, images)
+    writer.close()
+
+Now upon refreshing TensorBoard you should see a "Graphs" tab that
+looks like this:
+
+.. image:: ../../_static/img/tensorboard_model_viz.png
+
+Go ahead and double click on "Net" to see it expand, seeing a
+detailed view of the individual operations that make up the model.
+
+TensorBoard has a very handy feature for visualizing high dimensional
+data such as image data in a lower dimensional space; we'll cover this
+next.
+
+4. Adding a "Projector" to TensorBoard
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+We can visualize the lower dimensional representation of higher
+dimensional data via the `add_embedding <https://pytorch.org/docs/stable/tensorboard.html#torch.utils.tensorboard.writer.SummaryWriter.add_embedding>`__ method
+
+.. code:: python
+
+    # helper function
+    def select_n_random(data, labels, n=100):
+        '''
+        Selects n random datapoints and their corresponding labels from a dataset
+        '''
+        assert len(data) == len(labels)
+
+        perm = torch.randperm(len(data))
+        return data[perm][:n], labels[perm][:n]
+
+    # select random images and their target indices
+    images, labels = select_n_random(trainset.data, trainset.targets)
+
+    # get the class labels for each image
+    class_labels = [classes[lab] for lab in labels]
+
+    # log embeddings
+    features = images.view(-1, 28 * 28)
+    writer.add_embedding(features,
+                        metadata=class_labels,
+                        label_img=images.unsqueeze(1))
+    writer.close()
+
+Now in the "Projector" tab of TensorBoard, you can see these 100
+images - each of which is 784 dimensional - projected down into three
+dimensional space. Furthermore, this is interactive: you can click
+and drag to rotate the three dimensional projection. Finally, a couple
+of tips to make the visualization easier to see: select "color: label"
+on the top left, as well as enabling "night mode", which will make the
+images easier to see since their background is white:
+
+.. image:: ../../_static/img/tensorboard_projector.png
+
+Now we've thoroughly inspected our data, let's show how TensorBoard
+can make tracking model training and evaluation clearer, starting with
+training.
+
+5. Tracking model training with TensorBoard
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+In the previous example, we simply *printed* the model's running loss
+every 2000 iterations. Now, we'll instead log the running loss to
+TensorBoard, along with a view into the predictions the model is
+making via the ``plot_classes_preds`` function.
+
+.. code:: python
+
+    # helper functions
+
+    def images_to_probs(net, images):
+        '''
+        Generates predictions and corresponding probabilities from a trained
+        network and a list of images
+        '''
+        output = net(images)
+        # convert output probabilities to predicted class
+        _, preds_tensor = torch.max(output, 1)
+        preds = np.squeeze(preds_tensor.numpy())
+        return preds, [F.softmax(el, dim=0)[i].item() for i, el in zip(preds, output)]
+
+
+    def plot_classes_preds(net, images, labels):
+        '''
+        Generates matplotlib Figure using a trained network, along with images
+        and labels from a batch, that shows the network's top prediction along
+        with its probability, alongside the actual label, coloring this
+        information based on whether the prediction was correct or not.
+        Uses the "images_to_probs" function.
+        '''
+        preds, probs = images_to_probs(net, images)
+        # plot the images in the batch, along with predicted and true labels
+        fig = plt.figure(figsize=(12, 48))
+        for idx in np.arange(4):
+            ax = fig.add_subplot(1, 4, idx+1, xticks=[], yticks=[])
+            matplotlib_imshow(images[idx], one_channel=True)
+            ax.set_title("{0}, {1:.1f}%\n(label: {2})".format(
+                classes[preds[idx]],
+                probs[idx] * 100.0,
+                classes[labels[idx]]),
+                        color=("green" if preds[idx]==labels[idx].item() else "red"))
+        return fig
+
+Finally, let's train the model using the same model training code from
+the prior tutorial, but writing results to TensorBoard every 1000
+batches instead of printing to console; this is done using the
+`add_scalar <https://pytorch.org/docs/stable/tensorboard.html#torch.utils.tensorboard.writer.SummaryWriter.add_scalar>`__
+function.
+
+In addition, as we train, we'll generate an image showing the model's
+predictions vs. the actual results on the four images included in that
+batch.
+
+.. code:: python
+
+    running_loss = 0.0
+    for epoch in range(1):  # loop over the dataset multiple times
+
+        for i, data in enumerate(trainloader, 0):
+
+            # get the inputs; data is a list of [inputs, labels]
+            inputs, labels = data
+
+            # zero the parameter gradients
+            optimizer.zero_grad()
+
+            # forward + backward + optimize
+            outputs = net(inputs)
+            loss = criterion(outputs, labels)
+            loss.backward()
+            optimizer.step()
+
+            running_loss += loss.item()
+            if i % 1000 == 999:    # every 1000 mini-batches...
+
+                # ...log the running loss
+                writer.add_scalar('training loss',
+                                running_loss / 1000,
+                                epoch * len(trainloader) + i)
+
+                # ...log a Matplotlib Figure showing the model's predictions on a
+                # random mini-batch
+                writer.add_figure('predictions vs. actuals',
+                                plot_classes_preds(net, inputs, labels),
+                                global_step=epoch * len(trainloader) + i)
+                running_loss = 0.0
+    print('Finished Training')
+
+You can now look at the scalars tab to see the running loss plotted
+over the 15,000 iterations of training:
+
+.. image:: ../../_static/img/tensorboard_scalar_runs.png
+
+In addition, we can look at the predictions the model made on
+arbitrary batches throughout learning. See the "Images" tab and scroll
+down under the "predictions vs. actuals" visualization to see this;
+this shows us that, for example, after just 3000 training iterations,
+the model was already able to distinguish between visually distinct
+classes such as shirts, sneakers, and coats, though it isn't as
+confident as it becomes later on in training:
+
+.. image:: ../../_static/img/tensorboard_images.png
+
+In the prior tutorial, we looked at per-class accuracy once the model
+had been trained; here, we'll use TensorBoard to plot precision-recall
+curves (good explanation
+`here <https://www.scikit-yb.org/en/latest/api/classifier/prcurve.html>`__)
+for each class.
+
+6. Assessing trained models with TensorBoard
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. code:: python
+
+    # 1. gets the probability predictions in a test_size x num_classes Tensor
+    # 2. gets the preds in a test_size Tensor
+    # takes ~10 seconds to run
+    class_probs = []
+    class_label = []
+    with torch.no_grad():
+        for data in testloader:
+            images, labels = data
+            output = net(images)
+            class_probs_batch = [F.softmax(el, dim=0) for el in output]
+
+            class_probs.append(class_probs_batch)
+            class_label.append(labels)
+
+    test_probs = torch.cat([torch.stack(batch) for batch in class_probs])
+    test_label = torch.cat(class_label)
+
+    # helper function
+    def add_pr_curve_tensorboard(class_index, test_probs, test_label, global_step=0):
+        '''
+        Takes in a "class_index" from 0 to 9 and plots the corresponding
+        precision-recall curve
+        '''
+        tensorboard_truth = test_label == class_index
+        tensorboard_probs = test_probs[:, class_index]
+
+        writer.add_pr_curve(classes[class_index],
+                            tensorboard_truth,
+                            tensorboard_probs,
+                            global_step=global_step)
+        writer.close()
+
+    # plot all the pr curves
+    for i in range(len(classes)):
+        add_pr_curve_tensorboard(i, test_probs, test_label)
+
+You will now see a "PR Curves" tab that contains the precision-recall
+curves for each class. Go ahead and poke around; you'll see that on
+some classes the model has nearly 100% "area under the curve",
+whereas on others this area is lower:
+
+.. image:: ../../_static/img/tensorboard_pr_curves.png
+
+And that's an intro to TensorBoard and PyTorch's integration with it.
+Of course, you could do everything TensorBoard does in your Jupyter
+Notebook, but with TensorBoard, you gets visuals that are interactive
+by default.
diff --git a/intermediate_source/text_to_speech_with_torchaudio.rst b/intermediate_source/text_to_speech_with_torchaudio.rst
new file mode 100644
index 00000000000..bbb6d7f272d
--- /dev/null
+++ b/intermediate_source/text_to_speech_with_torchaudio.rst
@@ -0,0 +1,10 @@
+Text-to-speech with Tacotron2
+=============================
+
+This tutorial has been moved to https://pytorch.org/audio/stable/tutorials/tacotron2_pipeline_tutorial.html
+
+It will redirect in 3 seconds.
+
+.. raw:: html
+
+   <meta http-equiv="Refresh" content="3; url='https://pytorch.org/audio/stable/tutorials/tacotron2_pipeline_tutorial.html'" />
diff --git a/intermediate_source/torch_compile_conv_bn_fuser.py b/intermediate_source/torch_compile_conv_bn_fuser.py
new file mode 100644
index 00000000000..e057d145499
--- /dev/null
+++ b/intermediate_source/torch_compile_conv_bn_fuser.py
@@ -0,0 +1,292 @@
+# -*- coding: utf-8 -*-
+"""
+Building a Convolution/Batch Norm fuser with torch.compile
+===========================================================
+
+**Author:** `Horace He <https://github.com/chillee>`_, `Will Feng <https://github.com/yf225>`_
+
+.. grid:: 2
+
+    .. grid-item-card:: :octicon:`mortar-board;1em;` What you will learn
+       :class-card: card-prerequisites
+
+       * How to register custom fusion patterns with torch.compile's pattern matcher
+
+    .. grid-item-card:: :octicon:`list-unordered;1em;` Prerequisites
+       :class-card: card-prerequisites
+
+       * PyTorch v2.7.0
+
+.. note::
+   This optimization only works for models in inference mode (i.e. ``model.eval()``).
+   However, torch.compile's pattern matching system works for both training and inference.
+
+"""
+
+
+######################################################################
+# First, let's get some imports out of the way (we will be using all
+# of these later in the code).
+
+from typing import Type, Dict, Any, Tuple, Iterable
+import copy
+import torch
+import torch.nn as nn
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+######################################################################
+# For this tutorial, we are going to create a model consisting of convolutions
+# and batch norms. Note that this model has some tricky components - some of
+# the conv/batch norm patterns are hidden within Sequentials and one of the
+# ``BatchNorms`` is wrapped in another Module.
+
+class WrappedBatchNorm(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.mod = nn.BatchNorm2d(1)
+    def forward(self, x):
+        return self.mod(x)
+
+class M(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.conv1 = nn.Conv2d(1, 1, 1)
+        self.bn1 = nn.BatchNorm2d(1)
+        self.conv2 = nn.Conv2d(1, 1, 1)
+        self.nested = nn.Sequential(
+            nn.BatchNorm2d(1),
+            nn.Conv2d(1, 1, 1),
+        )
+        self.wrapped = WrappedBatchNorm()
+
+    def forward(self, x):
+        x = self.conv1(x)
+        x = self.bn1(x)
+        x = self.conv2(x)
+        x = self.nested(x)
+        x = self.wrapped(x)
+        return x
+
+model = M().to(device)
+model.eval()
+
+######################################################################
+# Fusing Convolution with Batch Norm
+# -----------------------------------------
+# One of the primary challenges with trying to automatically fuse convolution
+# and batch norm in PyTorch is that PyTorch does not provide an easy way of
+# accessing the computational graph. torch.compile resolves this problem by
+# capturing the computational graph during compilation, allowing us to apply
+# pattern-based optimizations across the entire model, including operations
+# nested within Sequential modules or wrapped in custom modules.
+import torch._inductor.pattern_matcher as pm
+from torch._inductor.pattern_matcher import register_replacement
+
+######################################################################
+# torch.compile will capture a graph representation of our model. During
+# compilation, modules hidden within Sequential containers and wrapped
+# modules are all inlined into the graph, making them available for
+# pattern matching and optimization.
+
+
+####################################
+# Fusing Convolution with Batch Norm
+# ----------------------------------
+# Unlike some other fusions, fusion of convolution with batch norm does not
+# require any new operators. Instead, as batch norm during inference
+# consists of a pointwise add and multiply, these operations can be "baked"
+# into the preceding convolution's weights. This allows us to remove the batch
+# norm entirely from our model! Read
+# https://nenadmarkus.com/p/fusing-batchnorm-and-conv/ for further details. The
+# code here is copied from
+# https://github.com/pytorch/pytorch/blob/orig/release/1.8/torch/nn/utils/fusion.py
+# clarity purposes.
+def fuse_conv_bn_eval(conv, bn):
+    """
+    Given a conv Module `A` and an batch_norm module `B`, returns a conv
+    module `C` such that C(x) == B(A(x)) in inference mode.
+    """
+    assert(not (conv.training or bn.training)), "Fusion only for eval!"
+    fused_conv = copy.deepcopy(conv)
+
+    fused_conv.weight, fused_conv.bias = \
+        fuse_conv_bn_weights(fused_conv.weight, fused_conv.bias,
+                             bn.running_mean, bn.running_var, bn.eps, bn.weight, bn.bias)
+
+    return fused_conv
+
+def fuse_conv_bn_weights(conv_w, conv_b, bn_rm, bn_rv, bn_eps, bn_w, bn_b):
+    if conv_b is None:
+        conv_b = torch.zeros_like(bn_rm)
+    if bn_w is None:
+        bn_w = torch.ones_like(bn_rm)
+    if bn_b is None:
+        bn_b = torch.zeros_like(bn_rm)
+    bn_var_rsqrt = torch.rsqrt(bn_rv + bn_eps)
+
+    conv_w = conv_w * (bn_w * bn_var_rsqrt).reshape([-1] + [1] * (len(conv_w.shape) - 1))
+    conv_b = (conv_b - bn_rm) * bn_var_rsqrt * bn_w + bn_b
+
+    return torch.nn.Parameter(conv_w), torch.nn.Parameter(conv_b)
+
+
+####################################
+# Pattern Matching with torch.compile
+# ------------------------------------
+# Now that we have our fusion logic, we need to register a pattern that
+# torch.compile's pattern matcher will recognize and replace during
+# compilation.
+
+# Define the pattern we want to match: conv2d followed by batch_norm
+def conv_bn_pattern(x, conv_weight, conv_bias, bn_mean, bn_var, bn_weight, bn_bias):
+    conv_out = torch.nn.functional.conv2d(x, conv_weight, conv_bias)
+    bn_out = torch.nn.functional.batch_norm(
+        conv_out, bn_mean, bn_var, bn_weight, bn_bias,
+        training=False, eps=1e-5
+    )
+    return bn_out
+
+def conv_bn_replacement(x, conv_weight, conv_bias, bn_mean, bn_var, bn_weight, bn_bias):
+    fused_weight, fused_bias = fuse_conv_bn_weights(
+        conv_weight, conv_bias, bn_mean, bn_var, 1e-5, bn_weight, bn_bias
+    )
+    return torch.nn.functional.conv2d(x, fused_weight, fused_bias)
+
+# Example inputs are needed to trace the pattern functions.
+# The inputs should match the function signatures of conv_bn_pattern and conv_bn_replacement.
+# These are used to trace the pattern functions to create the match template.
+# IMPORTANT: The pattern matcher is shape-agnostic! The specific shapes you use here
+# don't limit what shapes will be matched - any valid conv2d->batch_norm sequence
+# will be matched regardless of channels, kernel size, or spatial dimensions.
+# - x: input tensor (batch_size, channels, height, width)
+# - conv_weight: (out_channels, in_channels, kernel_h, kernel_w)
+# - conv_bias: (out_channels,)
+# - bn_mean, bn_var, bn_weight, bn_bias: all have shape (num_features,) matching out_channels
+example_inputs = [
+    torch.randn(1, 1, 4, 4).to(device),  # x: input tensor
+    torch.randn(1, 1, 1, 1).to(device),  # conv_weight: 1 output channel, 1 input channel, 1x1 kernel
+    torch.randn(1).to(device),           # conv_bias: 1 output channel
+    torch.randn(1).to(device),           # bn_mean: batch norm running mean
+    torch.randn(1).to(device),           # bn_var: batch norm running variance
+    torch.randn(1).to(device),           # bn_weight: batch norm weight (gamma)
+    torch.randn(1).to(device),           # bn_bias: batch norm bias (beta)
+]
+
+from torch._inductor.pattern_matcher import PatternMatcherPass
+from torch._inductor import config
+
+# Create a pattern matcher pass and register our pattern
+patterns = PatternMatcherPass()
+
+register_replacement(
+    conv_bn_pattern,
+    conv_bn_replacement,
+    example_inputs,
+    pm.fwd_only,
+    patterns,
+)
+
+# Create a custom pass function that applies our patterns
+def conv_bn_fusion_pass(graph):
+    return patterns.apply(graph)
+
+# Set our custom pass in the config
+config.post_grad_custom_post_pass = conv_bn_fusion_pass
+
+
+######################################################################
+# .. note::
+#       We make some simplifications here for demonstration purposes, such as only
+#       matching 2D convolutions. The pattern matcher in torch.compile
+#       can handle more complex patterns.
+
+######################################################################
+# Testing out our Fusion Pass
+# -----------------------------------------
+# We can now run this fusion pass on our initial toy model and verify that our
+# results are identical. In addition, we can print out the code for our fused
+# model and verify that there are no more batch norms.
+
+from torch._dynamo.utils import counters
+
+# Clear the counters before compilation
+counters.clear()
+
+# Ensure pattern matcher is enabled
+config.pattern_matcher = True
+
+fused_model = torch.compile(model, backend="inductor")
+inp = torch.randn(5, 1, 1, 1).to(device)
+
+# Run the model to trigger compilation and pattern matching
+with torch.no_grad():
+    output = fused_model(inp)
+    expected = model(inp)
+    torch.testing.assert_close(output, expected)
+
+# Check how many patterns were matched
+assert counters['inductor']['pattern_matcher_count'] == 3, "Expected 3 conv-bn patterns to be matched"
+
+# Create a model with different shapes than our example_inputs
+test_model_diff_shape = nn.Sequential(
+    nn.Conv2d(3, 16, 5),
+    nn.BatchNorm2d(16),
+    nn.ReLU(),
+    nn.Conv2d(16, 32, 7),
+    nn.BatchNorm2d(32),
+).to(device).eval()
+
+counters.clear()
+compiled_diff_shape = torch.compile(test_model_diff_shape, backend="inductor")
+test_input_diff_shape = torch.randn(1, 3, 28, 28).to(device)
+with torch.no_grad():
+    compiled_diff_shape(test_input_diff_shape)
+
+# Check how many patterns were matched
+assert counters['inductor']['pattern_matcher_count'] == 2, "Expected 2 conv-bn patterns to be matched"
+
+
+######################################################################
+# Benchmarking our Fusion on ResNet18
+# -----------------------------------
+# We can test our fusion pass on a larger model like ResNet18 and see how much
+# this pass improves inference performance.
+import torchvision.models as models
+import time
+
+rn18 = models.resnet18().to(device)
+rn18.eval()
+
+inp = torch.randn(10, 3, 224, 224).to(device)
+output = rn18(inp)
+
+def benchmark(model, iters=20):
+    with torch.no_grad():
+        for _ in range(10):
+            model(inp)
+        begin = time.time()
+        for _ in range(iters):
+            model(inp)
+        return str(time.time()-begin)
+
+# Benchmark original model
+print("Original model time: ", benchmark(rn18))
+
+# Compile with our custom pattern
+compiled_with_pattern_matching = torch.compile(rn18, backend="inductor")
+
+# Benchmark compiled model
+print("\ntorch.compile (with conv-bn pattern matching and other fusions): ", benchmark(compiled_with_pattern_matching))
+
+
+############
+# Conclusion
+# ----------
+# As we can see, torch.compile provides a powerful way to implement
+# graph transformations and optimizations through pattern matching.
+# By registering custom patterns, we can extend torch.compile's
+# optimization capabilities to handle domain-specific transformations.
+#
+# The conv-bn fusion demonstrated here is just one example of what's
+# possible with torch.compile's pattern matching system.
\ No newline at end of file
diff --git a/intermediate_source/torch_compile_tutorial.py b/intermediate_source/torch_compile_tutorial.py
new file mode 100644
index 00000000000..de31af04dc1
--- /dev/null
+++ b/intermediate_source/torch_compile_tutorial.py
@@ -0,0 +1,619 @@
+# -*- coding: utf-8 -*-
+
+"""
+Introduction to ``torch.compile``
+=================================
+**Author:** William Wen
+"""
+
+######################################################################
+# ``torch.compile`` is the latest method to speed up your PyTorch code!
+# ``torch.compile`` makes PyTorch code run faster by
+# JIT-compiling PyTorch code into optimized kernels,
+# all while requiring minimal code changes.
+#
+# In this tutorial, we cover basic ``torch.compile`` usage,
+# and demonstrate the advantages of ``torch.compile`` over
+# previous PyTorch compiler solutions, such as
+# `TorchScript <https://pytorch.org/docs/stable/jit.html>`__ and
+# `FX Tracing <https://pytorch.org/docs/stable/fx.html#torch.fx.symbolic_trace>`__.
+#
+# **Contents**
+#
+# .. contents::
+#     :local:
+#
+# **Required pip Dependencies**
+#
+# - ``torch >= 2.0``
+# - ``torchvision``
+# - ``numpy``
+# - ``scipy``
+# - ``tabulate``
+#
+# **System Requirements**
+# - A C++ compiler, such as ``g++``
+# - Python development package (``python-devel``/``python-dev``)
+
+######################################################################
+# NOTE: a modern NVIDIA GPU (H100, A100, or V100) is recommended for this tutorial in
+# order to reproduce the speedup numbers shown below and documented elsewhere.
+
+import torch
+import warnings
+
+gpu_ok = False
+if torch.cuda.is_available():
+    device_cap = torch.cuda.get_device_capability()
+    if device_cap in ((7, 0), (8, 0), (9, 0)):
+        gpu_ok = True
+
+if not gpu_ok:
+    warnings.warn(
+        "GPU is not NVIDIA V100, A100, or H100. Speedup numbers may be lower "
+        "than expected."
+    )
+
+######################################################################
+# Basic Usage
+# ------------
+#
+# ``torch.compile`` is included in the latest PyTorch.
+# Running TorchInductor on GPU requires Triton, which is included with the PyTorch 2.0 nightly
+# binary. If Triton is still missing, try installing ``torchtriton`` via pip
+# (``pip install torchtriton --extra-index-url "https://download.pytorch.org/whl/nightly/cu117"``
+# for CUDA 11.7).
+#
+# Arbitrary Python functions can be optimized by passing the callable to
+# ``torch.compile``. We can then call the returned optimized
+# function in place of the original function.
+
+def foo(x, y):
+    a = torch.sin(x)
+    b = torch.cos(y)
+    return a + b
+opt_foo1 = torch.compile(foo)
+print(opt_foo1(torch.randn(10, 10), torch.randn(10, 10)))
+
+######################################################################
+# Alternatively, we can decorate the function.
+t1 = torch.randn(10, 10)
+t2 = torch.randn(10, 10)
+
+@torch.compile
+def opt_foo2(x, y):
+    a = torch.sin(x)
+    b = torch.cos(y)
+    return a + b
+print(opt_foo2(t1, t2))
+
+######################################################################
+# We can also optimize ``torch.nn.Module`` instances.
+
+t = torch.randn(10, 100)
+
+class MyModule(torch.nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.lin = torch.nn.Linear(100, 10)
+
+    def forward(self, x):
+        return torch.nn.functional.relu(self.lin(x))
+
+mod = MyModule()
+mod.compile()
+print(mod(t))
+## or:
+# opt_mod = torch.compile(mod)
+# print(opt_mod(t))
+
+######################################################################
+# torch.compile and Nested Calls
+# ------------------------------
+# Nested function calls within the decorated function will also be compiled.
+
+def nested_function(x):
+    return torch.sin(x)
+
+@torch.compile
+def outer_function(x, y):
+    a = nested_function(x)
+    b = torch.cos(y)
+    return a + b
+
+print(outer_function(t1, t2))
+
+######################################################################
+# In the same fashion, when compiling a module all sub-modules and methods
+# within it, that are not in a skip list, are also compiled.
+
+class OuterModule(torch.nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.inner_module = MyModule()
+        self.outer_lin = torch.nn.Linear(10, 2)
+
+    def forward(self, x):
+        x = self.inner_module(x)
+        return torch.nn.functional.relu(self.outer_lin(x))
+
+outer_mod = OuterModule()
+outer_mod.compile()
+print(outer_mod(t))
+
+######################################################################
+# We can also disable some functions from being compiled by using
+# ``torch.compiler.disable``. Suppose you want to disable the tracing on just
+# the ``complex_function`` function, but want to continue the tracing back in
+# ``complex_conjugate``. In this case, you can use
+# ``torch.compiler.disable(recursive=False)`` option. Otherwise, the default is
+# ``recursive=True``.
+
+def complex_conjugate(z):
+    return torch.conj(z)
+
+@torch.compiler.disable(recursive=False)
+def complex_function(real, imag):
+    # Assuming this function cause problems in the compilation
+    z = torch.complex(real, imag)
+    return complex_conjugate(z)
+
+def outer_function():
+    real = torch.tensor([2, 3], dtype=torch.float32)
+    imag = torch.tensor([4, 5], dtype=torch.float32)
+    z = complex_function(real, imag)
+    return torch.abs(z)
+
+# Try to compile the outer_function
+try:
+    opt_outer_function = torch.compile(outer_function)
+    print(opt_outer_function())
+except Exception as e:
+    print("Compilation of outer_function failed:", e)
+
+######################################################################
+# Best Practices and Recommendations
+# ----------------------------------
+#
+# Behavior of ``torch.compile`` with Nested Modules and Function Calls
+#
+# When you use ``torch.compile``, the compiler will try to recursively compile
+# every function call inside the target function or module inside the target
+# function or module that is not in a skip list (such as built-ins, some functions in
+# the torch.* namespace).
+# 
+# **Best Practices:**
+#
+# 1. **Top-Level Compilation:** One approach is to compile at the highest level
+# possible (i.e., when the top-level module is initialized/called) and
+# selectively disable compilation when encountering excessive graph breaks or
+# errors. If there are still many compile issues, compile individual
+# subcomponents instead.
+#
+# 2. **Modular Testing:** Test individual functions and modules with ``torch.compile``
+# before integrating them into larger models to isolate potential issues.
+#
+# 3. **Disable Compilation Selectively:** If certain functions or sub-modules
+# cannot be handled by `torch.compile`, use the `torch.compiler.disable` context
+# managers to recursively exclude them from compilation.
+#
+# 4. **Compile Leaf Functions First:** In complex models with multiple nested
+# functions and modules, start by compiling the leaf functions or modules first.
+# For more information see `TorchDynamo APIs for fine-grained tracing <https://pytorch.org/docs/stable/torch.compiler_fine_grain_apis.html>`__.
+#
+# 5. **Prefer ``mod.compile()`` over ``torch.compile(mod)``:** Avoids ``_orig_`` prefix issues in ``state_dict``.
+#
+# 6. **Use ``fullgraph=True`` to catch graph breaks:** Helps ensure end-to-end compilation, maximizing speedup
+# and compatibility with ``torch.export``.
+
+
+######################################################################
+# Demonstrating Speedups
+# -----------------------
+#
+# Let's now demonstrate that using ``torch.compile`` can speed
+# up real models. We will compare standard eager mode and
+# ``torch.compile`` by evaluating and training a ``torchvision`` model on random data.
+#
+# Before we start, we need to define some utility functions.
+
+# Returns the result of running `fn()` and the time it took for `fn()` to run,
+# in seconds. We use CUDA events and synchronization for the most accurate
+# measurements.
+def timed(fn):
+    start = torch.cuda.Event(enable_timing=True)
+    end = torch.cuda.Event(enable_timing=True)
+    start.record()
+    result = fn()
+    end.record()
+    torch.cuda.synchronize()
+    return result, start.elapsed_time(end) / 1000
+
+# Generates random input and targets data for the model, where `b` is
+# batch size.
+def generate_data(b):
+    return (
+        torch.randn(b, 3, 128, 128).to(torch.float32).cuda(),
+        torch.randint(1000, (b,)).cuda(),
+    )
+
+N_ITERS = 10
+
+from torchvision.models import densenet121
+def init_model():
+    return densenet121().to(torch.float32).cuda()
+
+######################################################################
+# First, let's compare inference.
+#
+# Note that in the call to ``torch.compile``, we have the additional
+# ``mode`` argument, which we will discuss below.
+
+model = init_model()
+
+# Reset since we are using a different mode.
+import torch._dynamo
+torch._dynamo.reset()
+
+model_opt = torch.compile(model, mode="reduce-overhead")
+
+inp = generate_data(16)[0]
+with torch.no_grad():
+    print("eager:", timed(lambda: model(inp))[1])
+    print("compile:", timed(lambda: model_opt(inp))[1])
+
+######################################################################
+# Notice that ``torch.compile`` takes a lot longer to complete
+# compared to eager. This is because ``torch.compile`` compiles
+# the model into optimized kernels as it executes. In our example, the
+# structure of the model doesn't change, and so recompilation is not
+# needed. So if we run our optimized model several more times, we should
+# see a significant improvement compared to eager.
+
+eager_times = []
+for i in range(N_ITERS):
+    inp = generate_data(16)[0]
+    with torch.no_grad():
+        _, eager_time = timed(lambda: model(inp))
+    eager_times.append(eager_time)
+    print(f"eager eval time {i}: {eager_time}")
+
+print("~" * 10)
+
+compile_times = []
+for i in range(N_ITERS):
+    inp = generate_data(16)[0]
+    with torch.no_grad():
+        _, compile_time = timed(lambda: model_opt(inp))
+    compile_times.append(compile_time)
+    print(f"compile eval time {i}: {compile_time}")
+print("~" * 10)
+
+import numpy as np
+eager_med = np.median(eager_times)
+compile_med = np.median(compile_times)
+speedup = eager_med / compile_med
+assert(speedup > 1)
+print(f"(eval) eager median: {eager_med}, compile median: {compile_med}, speedup: {speedup}x")
+print("~" * 10)
+
+######################################################################
+# And indeed, we can see that running our model with ``torch.compile``
+# results in a significant speedup. Speedup mainly comes from reducing Python overhead and
+# GPU read/writes, and so the observed speedup may vary on factors such as model
+# architecture and batch size. For example, if a model's architecture is simple
+# and the amount of data is large, then the bottleneck would be
+# GPU compute and the observed speedup may be less significant.
+#
+# You may also see different speedup results depending on the chosen ``mode``
+# argument. The ``"reduce-overhead"`` mode uses CUDA graphs to further reduce
+# the overhead of Python. For your own models,
+# you may need to experiment with different modes to maximize speedup. You can
+# read more about modes `here <https://pytorch.org/get-started/pytorch-2.0/#user-experience>`__.
+#
+# You may might also notice that the second time we run our model with ``torch.compile`` is significantly
+# slower than the other runs, although it is much faster than the first run. This is because the ``"reduce-overhead"``
+# mode runs a few warm-up iterations for CUDA graphs.
+#
+# For general PyTorch benchmarking, you can try using ``torch.utils.benchmark`` instead of the ``timed``
+# function we defined above. We wrote our own timing function in this tutorial to show
+# ``torch.compile``'s compilation latency.
+#
+# Now, let's consider comparing training.
+
+model = init_model()
+opt = torch.optim.Adam(model.parameters())
+
+def train(mod, data):
+    opt.zero_grad(True)
+    pred = mod(data[0])
+    loss = torch.nn.CrossEntropyLoss()(pred, data[1])
+    loss.backward()
+    opt.step()
+
+eager_times = []
+for i in range(N_ITERS):
+    inp = generate_data(16)
+    _, eager_time = timed(lambda: train(model, inp))
+    eager_times.append(eager_time)
+    print(f"eager train time {i}: {eager_time}")
+print("~" * 10)
+
+model = init_model()
+opt = torch.optim.Adam(model.parameters())
+train_opt = torch.compile(train, mode="reduce-overhead")
+
+compile_times = []
+for i in range(N_ITERS):
+    inp = generate_data(16)
+    _, compile_time = timed(lambda: train_opt(model, inp))
+    compile_times.append(compile_time)
+    print(f"compile train time {i}: {compile_time}")
+print("~" * 10)
+
+eager_med = np.median(eager_times)
+compile_med = np.median(compile_times)
+speedup = eager_med / compile_med
+assert(speedup > 1)
+print(f"(train) eager median: {eager_med}, compile median: {compile_med}, speedup: {speedup}x")
+print("~" * 10)
+
+######################################################################
+# Again, we can see that ``torch.compile`` takes longer in the first
+# iteration, as it must compile the model, but in subsequent iterations, we see
+# significant speedups compared to eager.
+#
+# We remark that the speedup numbers presented in this tutorial are for
+# demonstration purposes only. Official speedup values can be seen at the
+# `TorchInductor performance dashboard <https://hud.pytorch.org/benchmark/compilers>`__.
+
+######################################################################
+# Comparison to TorchScript and FX Tracing
+# -----------------------------------------
+#
+# We have seen that ``torch.compile`` can speed up PyTorch code.
+# Why else should we use ``torch.compile`` over existing PyTorch
+# compiler solutions, such as TorchScript or FX Tracing? Primarily, the
+# advantage of ``torch.compile`` lies in its ability to handle
+# arbitrary Python code with minimal changes to existing code.
+#
+# One case that ``torch.compile`` can handle that other compiler
+# solutions struggle with is data-dependent control flow (the
+# ``if x.sum() < 0:`` line below).
+
+def f1(x, y):
+    if x.sum() < 0:
+        return -y
+    return y
+
+# Test that `fn1` and `fn2` return the same result, given
+# the same arguments `args`. Typically, `fn1` will be an eager function
+# while `fn2` will be a compiled function (torch.compile, TorchScript, or FX graph).
+def test_fns(fn1, fn2, args):
+    out1 = fn1(*args)
+    out2 = fn2(*args)
+    return torch.allclose(out1, out2)
+
+inp1 = torch.randn(5, 5)
+inp2 = torch.randn(5, 5)
+
+######################################################################
+# TorchScript tracing ``f1`` results in
+# silently incorrect results, since only the actual control flow path
+# is traced.
+
+traced_f1 = torch.jit.trace(f1, (inp1, inp2))
+print("traced 1, 1:", test_fns(f1, traced_f1, (inp1, inp2)))
+print("traced 1, 2:", test_fns(f1, traced_f1, (-inp1, inp2)))
+
+######################################################################
+# FX tracing ``f1`` results in an error due to the presence of
+# data-dependent control flow.
+
+import traceback as tb
+try:
+    torch.fx.symbolic_trace(f1)
+except:
+    tb.print_exc()
+
+######################################################################
+# If we provide a value for ``x`` as we try to FX trace ``f1``, then
+# we run into the same problem as TorchScript tracing, as the data-dependent
+# control flow is removed in the traced function.
+
+fx_f1 = torch.fx.symbolic_trace(f1, concrete_args={"x": inp1})
+print("fx 1, 1:", test_fns(f1, fx_f1, (inp1, inp2)))
+print("fx 1, 2:", test_fns(f1, fx_f1, (-inp1, inp2)))
+
+######################################################################
+# Now we can see that ``torch.compile`` correctly handles
+# data-dependent control flow.
+
+# Reset since we are using a different mode.
+torch._dynamo.reset()
+
+compile_f1 = torch.compile(f1)
+print("compile 1, 1:", test_fns(f1, compile_f1, (inp1, inp2)))
+print("compile 1, 2:", test_fns(f1, compile_f1, (-inp1, inp2)))
+print("~" * 10)
+
+######################################################################
+# TorchScript scripting can handle data-dependent control flow, but this
+# solution comes with its own set of problems. Namely, TorchScript scripting
+# can require major code changes and will raise errors when unsupported Python
+# is used.
+#
+# In the example below, we forget TorchScript type annotations and we receive
+# a TorchScript error because the input type for argument ``y``, an ``int``,
+# does not match with the default argument type, ``torch.Tensor``.
+
+def f2(x, y):
+    return x + y
+
+inp1 = torch.randn(5, 5)
+inp2 = 3
+
+script_f2 = torch.jit.script(f2)
+try:
+    script_f2(inp1, inp2)
+except:
+    tb.print_exc()
+
+######################################################################
+# However, ``torch.compile`` is easily able to handle ``f2``.
+
+compile_f2 = torch.compile(f2)
+print("compile 2:", test_fns(f2, compile_f2, (inp1, inp2)))
+print("~" * 10)
+
+######################################################################
+# Another case that ``torch.compile`` handles well compared to
+# previous compilers solutions is the usage of non-PyTorch functions.
+
+import scipy
+def f3(x):
+    x = x * 2
+    x = scipy.fft.dct(x.numpy())
+    x = torch.from_numpy(x)
+    x = x * 2
+    return x
+
+######################################################################
+# TorchScript tracing treats results from non-PyTorch function calls
+# as constants, and so our results can be silently wrong.
+
+inp1 = torch.randn(5, 5)
+inp2 = torch.randn(5, 5)
+traced_f3 = torch.jit.trace(f3, (inp1,))
+print("traced 3:", test_fns(f3, traced_f3, (inp2,)))
+
+######################################################################
+# TorchScript scripting and FX tracing disallow non-PyTorch function calls.
+
+try:
+    torch.jit.script(f3)
+except:
+    tb.print_exc()
+
+try:
+    torch.fx.symbolic_trace(f3)
+except:
+    tb.print_exc()
+
+######################################################################
+# In comparison, ``torch.compile`` is easily able to handle
+# the non-PyTorch function call.
+
+compile_f3 = torch.compile(f3)
+print("compile 3:", test_fns(f3, compile_f3, (inp2,)))
+
+######################################################################
+# TorchDynamo and FX Graphs
+# --------------------------
+#
+# One important component of ``torch.compile`` is TorchDynamo.
+# TorchDynamo is responsible for JIT compiling arbitrary Python code into
+# `FX graphs <https://pytorch.org/docs/stable/fx.html#torch.fx.Graph>`__, which can
+# then be further optimized. TorchDynamo extracts FX graphs by analyzing Python bytecode
+# during runtime and detecting calls to PyTorch operations.
+#
+# Normally, TorchInductor, another component of ``torch.compile``,
+# further compiles the FX graphs into optimized kernels,
+# but TorchDynamo allows for different backends to be used. In order to inspect
+# the FX graphs that TorchDynamo outputs, let us create a custom backend that
+# outputs the FX graph and simply returns the graph's unoptimized forward method.
+
+from typing import List
+def custom_backend(gm: torch.fx.GraphModule, example_inputs: List[torch.Tensor]):
+    print("custom backend called with FX graph:")
+    gm.graph.print_tabular()
+    return gm.forward
+
+# Reset since we are using a different backend.
+torch._dynamo.reset()
+
+opt_model = torch.compile(init_model(), backend=custom_backend)
+opt_model(generate_data(16)[0])
+
+######################################################################
+# Using our custom backend, we can now see how TorchDynamo is able to handle
+# data-dependent control flow. Consider the function below, where the line
+# ``if b.sum() < 0`` is the source of data-dependent control flow.
+
+def bar(a, b):
+    x = a / (torch.abs(a) + 1)
+    if b.sum() < 0:
+        b = b * -1
+    return x * b
+
+opt_bar = torch.compile(bar, backend=custom_backend)
+inp1 = torch.randn(10)
+inp2 = torch.randn(10)
+opt_bar(inp1, inp2)
+opt_bar(inp1, -inp2)
+
+######################################################################
+# The output reveals that TorchDynamo extracted 3 different FX graphs
+# corresponding the following code (order may differ from the output above):
+#
+# 1. ``x = a / (torch.abs(a) + 1)``
+# 2. ``b = b * -1; return x * b``
+# 3. ``return x * b``
+#
+# When TorchDynamo encounters unsupported Python features, such as data-dependent
+# control flow, it breaks the computation graph, lets the default Python
+# interpreter handle the unsupported code, then resumes capturing the graph.
+#
+# Let's investigate by example how TorchDynamo would step through ``bar``.
+# If ``b.sum() < 0``, then TorchDynamo would run graph 1, let
+# Python determine the result of the conditional, then run
+# graph 2. On the other hand, if ``not b.sum() < 0``, then TorchDynamo
+# would run graph 1, let Python determine the result of the conditional, then
+# run graph 3.
+#
+# This highlights a major difference between TorchDynamo and previous PyTorch
+# compiler solutions. When encountering unsupported Python features,
+# previous solutions either raise an error or silently fail.
+# TorchDynamo, on the other hand, will break the computation graph.
+#
+# We can see where TorchDynamo breaks the graph by using ``torch._dynamo.explain``:
+
+# Reset since we are using a different backend.
+torch._dynamo.reset()
+explain_output = torch._dynamo.explain(bar)(torch.randn(10), torch.randn(10))
+print(explain_output)
+
+######################################################################
+# In order to maximize speedup, graph breaks should be limited.
+# We can force TorchDynamo to raise an error upon the first graph
+# break encountered by using ``fullgraph=True``:
+
+opt_bar = torch.compile(bar, fullgraph=True)
+try:
+    opt_bar(torch.randn(10), torch.randn(10))
+except:
+    tb.print_exc()
+
+######################################################################
+# And below, we demonstrate that TorchDynamo does not break the graph on
+# the model we used above for demonstrating speedups.
+
+opt_model = torch.compile(init_model(), fullgraph=True)
+print(opt_model(generate_data(16)[0]))
+
+######################################################################
+# We can use ``torch.export`` (from PyTorch 2.1+) to extract a single, exportable
+# FX graph from the input PyTorch program. The exported graph is intended to be
+# run on different (i.e. Python-less) environments. One important restriction
+# is that the ``torch.export`` does not support graph breaks. Please check
+# `this tutorial <https://pytorch.org/tutorials/intermediate/torch_export_tutorial.html>`__
+# for more details on ``torch.export``.
+
+######################################################################
+# Conclusion
+# ------------
+#
+# In this tutorial, we introduced ``torch.compile`` by covering
+# basic usage, demonstrating speedups over eager mode, comparing to previous
+# PyTorch compiler solutions, and briefly investigating TorchDynamo and its interactions
+# with FX graphs. We hope that you will give ``torch.compile`` a try!
diff --git a/intermediate_source/torch_export_nightly_tutorial.rst b/intermediate_source/torch_export_nightly_tutorial.rst
new file mode 100644
index 00000000000..e7ef2e88153
--- /dev/null
+++ b/intermediate_source/torch_export_nightly_tutorial.rst
@@ -0,0 +1,10 @@
+torch.export Nightly Tutorial
+=============================
+
+This tutorial has been moved to https://pytorch.org/tutorials/intermediate/torch_export_tutorial.html
+
+It will redirect in 3 seconds.
+
+.. raw:: html
+
+   <meta http-equiv="Refresh" content="3; url='https://pytorch.org/tutorials/intermediate/torch_export_tutorial.html'" />
diff --git a/intermediate_source/torch_export_tutorial.py b/intermediate_source/torch_export_tutorial.py
new file mode 100644
index 00000000000..3ca6d09a52f
--- /dev/null
+++ b/intermediate_source/torch_export_tutorial.py
@@ -0,0 +1,1010 @@
+# -*- coding: utf-8 -*-
+
+"""
+torch.export Tutorial
+===================================================
+**Author:** William Wen, Zhengxu Chen, Angela Yi, Pian Pawakapan
+"""
+
+######################################################################
+#
+# .. warning::
+#
+#     ``torch.export`` and its related features are in prototype status and are subject to backwards compatibility
+#     breaking changes. This tutorial provides a snapshot of ``torch.export`` usage as of PyTorch 2.5.
+#
+# :func:`torch.export` is the PyTorch 2.X way to export PyTorch models into
+# standardized model representations, intended
+# to be run on different (i.e. Python-less) environments. The official
+# documentation can be found `here <https://pytorch.org/docs/main/export.html>`__.
+#
+# In this tutorial, you will learn how to use :func:`torch.export` to extract
+# ``ExportedProgram``'s (i.e. single-graph representations) from PyTorch programs.
+# We also detail some considerations/modifications that you may need
+# to make in order to make your model compatible with ``torch.export``.
+#
+# **Contents**
+#
+# .. contents::
+#     :local:
+
+######################################################################
+# Basic Usage
+# -----------
+#
+# ``torch.export`` extracts single-graph representations from PyTorch programs
+# by tracing the target function, given example inputs.
+# ``torch.export.export()`` is the main entry point for ``torch.export``.
+#
+# In this tutorial, ``torch.export`` and ``torch.export.export()`` are practically synonymous,
+# though ``torch.export`` generally refers to the PyTorch 2.X export process, and ``torch.export.export()``
+# generally refers to the actual function call.
+#
+# The signature of ``torch.export.export()`` is:
+#
+# .. code-block:: python
+#
+#     export(
+#         mod: torch.nn.Module,
+#         args: Tuple[Any, ...],
+#         kwargs: Optional[Dict[str, Any]] = None,
+#         *,
+#         dynamic_shapes: Optional[Dict[str, Dict[int, Dim]]] = None
+#     ) -> ExportedProgram
+#
+# ``torch.export.export()`` traces the tensor computation graph from calling ``mod(*args, **kwargs)``
+# and wraps it in an ``ExportedProgram``, which can be serialized or executed later with
+# different inputs. To execute the ``ExportedProgram`` we can call ``.module()``
+# on it to return a ``torch.nn.Module`` which is callable, just like the
+# original program.
+# We will detail the ``dynamic_shapes`` argument later in the tutorial.
+
+import torch
+from torch.export import export
+
+class MyModule(torch.nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.lin = torch.nn.Linear(100, 10)
+
+    def forward(self, x, y):
+        return torch.nn.functional.relu(self.lin(x + y), inplace=True)
+
+mod = MyModule()
+exported_mod = export(mod, (torch.randn(8, 100), torch.randn(8, 100)))
+print(type(exported_mod))
+print(exported_mod.module()(torch.randn(8, 100), torch.randn(8, 100)))
+
+
+######################################################################
+# Let's review some attributes of ``ExportedProgram`` that are of interest.
+#
+# The ``graph`` attribute is an `FX graph <https://pytorch.org/docs/stable/fx.html#torch.fx.Graph>`__
+# traced from the function we exported, that is, the computation graph of all PyTorch operations.
+# The FX graph is in "ATen IR" meaning that it contains only "ATen-level" operations.
+#
+# The ``graph_signature`` attribute gives a more detailed description of the
+# input and output nodes in the exported graph, describing which ones are
+# parameters, buffers, user inputs, or user outputs.
+#
+# The ``range_constraints`` attributes will be covered later.
+
+print(exported_mod)
+
+######################################################################
+# See the ``torch.export`` `documentation <https://pytorch.org/docs/main/export.html#torch.export.export>`__
+# for more details.
+
+######################################################################
+# Graph Breaks
+# ------------
+#
+# Although ``torch.export`` shares components with ``torch.compile``,
+# the key limitation of ``torch.export``, especially when compared to
+# ``torch.compile``, is that it does not support graph breaks. This is because
+# handling graph breaks involves interpreting the unsupported operation with
+# default Python evaluation, which is incompatible with the export use case.
+# Therefore, in order to make your model code compatible with ``torch.export``,
+# you will need to modify your code to remove graph breaks.
+#
+# A graph break is necessary in cases such as:
+#
+# - data-dependent control flow
+
+class Bad1(torch.nn.Module):
+    def forward(self, x):
+        if x.sum() > 0:
+            return torch.sin(x)
+        return torch.cos(x)
+
+import traceback as tb
+try:
+    export(Bad1(), (torch.randn(3, 3),))
+except Exception:
+    tb.print_exc()
+
+######################################################################
+# - accessing tensor data with ``.data``
+
+class Bad2(torch.nn.Module):
+    def forward(self, x):
+        x.data[0, 0] = 3
+        return x
+
+try:
+    export(Bad2(), (torch.randn(3, 3),))
+except Exception:
+    tb.print_exc()
+
+######################################################################
+# - calling unsupported functions (such as many built-in functions)
+
+class Bad3(torch.nn.Module):
+    def forward(self, x):
+        x = x + 1
+        return x + id(x)
+
+try:
+    export(Bad3(), (torch.randn(3, 3),))
+except Exception:
+    tb.print_exc()
+
+
+######################################################################
+# Non-Strict Export
+# -----------------
+#
+# To trace the program, ``torch.export`` uses TorchDynamo by default, a byte
+# code analysis engine, to symbolically analyze the Python code and build a
+# graph based on the results. This analysis allows ``torch.export`` to provide
+# stronger guarantees about safety, but not all Python code is supported,
+# causing these graph breaks.
+#
+# To address this issue, in PyTorch 2.3, we introduced a new mode of
+# exporting called non-strict mode, where we trace through the program using the
+# Python interpreter executing it exactly as it would in eager mode, allowing us
+# to skip over unsupported Python features. This is done through adding a
+# ``strict=False`` flag.
+#
+# Looking at some of the previous examples which resulted in graph breaks:
+
+######################################################################
+# - Calling unsupported functions (such as many built-in functions) traces
+# through, but in this case, ``id(x)`` gets specialized as a constant integer in
+# the graph. This is because ``id(x)`` is not a tensor operation, so the
+# operation is not recorded in the graph.
+
+class Bad3(torch.nn.Module):
+    def forward(self, x):
+        x = x + 1
+        return x + id(x)
+
+bad3_nonstrict = export(Bad3(), (torch.randn(3, 3),), strict=False)
+print(bad3_nonstrict)
+print(bad3_nonstrict.module()(torch.ones(3, 3)))
+
+
+######################################################################
+# However, there are still some features that require rewrites to the original
+# module:
+
+######################################################################
+# Control Flow Ops
+# ----------------
+#
+# ``torch.export`` actually does support data-dependent control flow.
+# But these need to be expressed using control flow ops. For example,
+# we can fix the control flow example above using the ``cond`` op, like so:
+
+class Bad1Fixed(torch.nn.Module):
+    def forward(self, x):
+        def true_fn(x):
+            return torch.sin(x)
+        def false_fn(x):
+            return torch.cos(x)
+        return torch.cond(x.sum() > 0, true_fn, false_fn, [x])
+
+exported_bad1_fixed = export(Bad1Fixed(), (torch.randn(3, 3),))
+print(exported_bad1_fixed)
+print(exported_bad1_fixed.module()(torch.ones(3, 3)))
+print(exported_bad1_fixed.module()(-torch.ones(3, 3)))
+
+######################################################################
+# There are limitations to ``cond`` that one should be aware of:
+#
+# - The predicate (i.e. ``x.sum() > 0``) must result in a boolean or a single-element tensor.
+# - The operands (i.e. ``[x]``) must be tensors.
+# - The branch function (i.e. ``true_fn`` and ``false_fn``) signature must match with the
+#   operands and they must both return a single tensor with the same metadata (for example, ``dtype``, ``shape``, etc.).
+# - Branch functions cannot mutate input or global variables.
+# - Branch functions cannot access closure variables, except for ``self`` if the function is
+#   defined in the scope of a method.
+#
+# For more details about ``cond``, check out the `cond documentation <https://pytorch.org/docs/main/cond.html>`__.
+
+######################################################################
+# We can also use ``map``, which applies a function across the first dimension
+# of the first tensor argument.
+
+from torch._higher_order_ops.map import map as torch_map
+
+class MapModule(torch.nn.Module):
+    def forward(self, xs, y, z):
+        def body(x, y, z):
+            return x + y + z
+
+        return torch_map(body, xs, y, z)
+
+inps = (torch.ones(6, 4), torch.tensor(5), torch.tensor(4))
+exported_map_example = export(MapModule(), inps)
+print(exported_map_example)
+print(exported_map_example.module()(*inps))
+
+######################################################################
+# Other control flow ops include ``while_loop``, ``associative_scan``, and
+# ``scan``. For more documentation on each operator, please refer to
+# `this page <https://github.com/pytorch/pytorch/tree/main/torch/_higher_order_ops>`__.
+
+######################################################################
+# Constraints/Dynamic Shapes
+# --------------------------
+#
+# This section covers dynamic behavior and representation of exported programs. Dynamic behavior is
+# subjective to the particular model being exported, so for the most part of this tutorial, we'll focus
+# on this particular toy model (with the resulting tensor shapes annotated):
+
+class DynamicModel(torch.nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.l = torch.nn.Linear(5, 3)
+
+    def forward(
+        self,
+        w: torch.Tensor,  # [6, 5]
+        x: torch.Tensor,  # [4]
+        y: torch.Tensor,  # [8, 4]
+        z: torch.Tensor,  # [32]
+    ):
+        x0 = x + y  # [8, 4]
+        x1 = self.l(w)  # [6, 3]
+        x2 = x0.flatten()  # [32]
+        x3 = x2 + z  # [32]
+        return x1, x3
+
+######################################################################
+# By default, ``torch.export`` produces a static program. One consequence of this is that at runtime,
+# the program won't work on inputs with different shapes, even if they're valid in eager mode.
+
+w = torch.randn(6, 5)
+x = torch.randn(4)
+y = torch.randn(8, 4)
+z = torch.randn(32)
+model = DynamicModel()
+ep = export(model, (w, x, y, z))
+model(w, x, torch.randn(3, 4), torch.randn(12))
+try:
+    ep.module()(w, x, torch.randn(3, 4), torch.randn(12))
+except Exception:
+    tb.print_exc()
+
+######################################################################
+# Basic concepts: symbols and guards
+# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#
+# To enable dynamism, ``export()`` provides a ``dynamic_shapes`` argument. The easiest way to work with
+# dynamic shapes is using ``Dim.AUTO`` and looking at the program that's returned. Dynamic behavior is specified
+# at a input dimension-level; for each input we can specify a tuple of values:
+
+from torch.export.dynamic_shapes import Dim
+
+dynamic_shapes = {
+    "w": (Dim.AUTO, Dim.AUTO),
+    "x": (Dim.AUTO,),
+    "y": (Dim.AUTO, Dim.AUTO),
+    "z": (Dim.AUTO,),
+}
+ep = export(model, (w, x, y, z), dynamic_shapes=dynamic_shapes)
+
+######################################################################
+# Before we look at the program that's produced, let's understand what specifying ``dynamic_shapes`` entails,
+# and how that interacts with export. For every input dimension where a ``Dim`` object is specified, a symbol is
+# `allocated <https://pytorch.org/docs/main/export.programming_model.html#basics-of-symbolic-shapes>`_,
+# taking on a range of ``[2, inf]`` (why not ``[0, inf]`` or ``[1, inf]``? we'll explain later in the
+# 0/1 specialization section).
+#
+# Export then runs model tracing, looking at each operation that's performed by the model. Each individual operation can emit
+# what's called "guards"; basically boolean condition that are required to be true for the program to be valid.
+# When guards involve symbols allocated for input dimensions, the program contains restrictions on what input shapes are valid;
+# i.e. the program's dynamic behavior. The symbolic shapes subsystem is the part responsible for taking in all the emitted guards
+# and producing a final program representation that adheres to all of these guards. Before we see this "final representation" in
+# an ``ExportedProgram``, let's look at the guards emitted by the toy model we're tracing.
+#
+# Here, each forward input tensor is annotated with the symbol allocated at the start of tracing:
+
+class DynamicModel(torch.nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.l = torch.nn.Linear(5, 3)
+
+    def forward(
+        self,
+        w: torch.Tensor,  # [s0, s1]
+        x: torch.Tensor,  # [s2]
+        y: torch.Tensor,  # [s3, s4]
+        z: torch.Tensor,  # [s5]
+    ):
+        x0 = x + y  # guard: s2 == s4
+        x1 = self.l(w)  # guard: s1 == 5
+        x2 = x0.flatten()  # no guard added here
+        x3 = x2 + z  # guard: s3 * s4 == s5
+        return x1, x3
+
+######################################################################
+# Let's understand each of the operations and the emitted guards:
+#
+# - ``x0 = x + y``: This is an element-wise add with broadcasting, since ``x`` is a 1-d tensor and ``y`` a 2-d tensor. ``x`` is broadcasted along the last dimension of ``y``, emitting the guard ``s2 == s4``.
+# - ``x1 = self.l(w)``: Calling ``nn.Linear()`` performs a matrix multiplication with model parameters. In export, parameters, buffers, and constants are considered program state, which is considered static, and so this is a matmul between a dynamic input (``w: [s0, s1]``), and a statically-shaped tensor. This emits the guard ``s1 == 5``.
+# - ``x2 = x0.flatten()``: This call actually doesn't emit any guards! (at least none relevant to input shapes)
+# - ``x3 = x2 + z``: ``x2`` has shape ``[s3*s4]`` after flattening, and this element-wise add emits ``s3 * s4 == s5``.
+#
+# Writing all of these guards down and summarizing is almost like a mathematical proof, which is what the symbolic shapes
+# subsystem tries to do! In summary, we can conclude that the program must have the following input shapes to be valid:
+#
+# - ``w: [s0, 5]``
+# - ``x: [s2]``
+# - ``y: [s3, s2]``
+# - ``z: [s2*s3]``
+#
+# And when we do finally print out the exported program to see our result, those shapes are what we see annotated on the
+# corresponding inputs:
+
+print(ep)
+
+######################################################################
+# Another feature to notice is the range_constraints field above, which contains a valid range for each symbol. This isn't
+# so interesting currently, since this export call doesn't emit any guards related to symbol bounds and each base symbol has
+# a generic bound, but this will come up later.
+#
+# So far, because we've been exporting this toy model, this experience has not been representative of how hard
+# it typically is to debug dynamic shapes guards & issues. In most cases it isn't obvious what guards are being emitted,
+# and which operations and parts of user code are responsible. For this toy model we pinpoint the exact lines, and the guards
+# are rather intuitive.
+#
+# In more complicated cases, a helpful first step is always to enable verbose logging. This can be done either with the environment
+# variable ``TORCH_LOGS="+dynamic"``, or interactively with ``torch._logging.set_logs(dynamic=10)``:
+
+torch._logging.set_logs(dynamic=10)
+ep = export(model, (w, x, y, z), dynamic_shapes=dynamic_shapes)
+
+######################################################################
+# This spits out quite a handful, even with this simple toy model. The log lines here have been cut short at front and end
+# to ignore unnecessary info, but looking through the logs we can see the lines relevant to what we described above;
+# e.g. the allocation of symbols:
+
+"""
+create_symbol s0 = 6 for L['w'].size()[0] [2, int_oo] (_dynamo/variables/builder.py:2841 in <lambda>)
+create_symbol s1 = 5 for L['w'].size()[1] [2, int_oo] (_dynamo/variables/builder.py:2841 in <lambda>)
+runtime_assert True == True [statically known]
+create_symbol s2 = 4 for L['x'].size()[0] [2, int_oo] (_dynamo/variables/builder.py:2841 in <lambda>)
+create_symbol s3 = 8 for L['y'].size()[0] [2, int_oo] (_dynamo/variables/builder.py:2841 in <lambda>)
+create_symbol s4 = 4 for L['y'].size()[1] [2, int_oo] (_dynamo/variables/builder.py:2841 in <lambda>)
+create_symbol s5 = 32 for L['z'].size()[0] [2, int_oo] (_dynamo/variables/builder.py:2841 in <lambda>)
+"""
+
+######################################################################
+# The lines with `create_symbol` show when a new symbol has been allocated, and the logs also identify the tensor variable names
+# and dimensions they've been allocated for. In other lines we can also see the guards emitted:
+
+"""
+runtime_assert Eq(s2, s4) [guard added] x0 = x + y  # output shape: [8, 4]  # dynamic_shapes_tutorial.py:16 in forward (_subclasses/fake_impls.py:845 in infer_size), for more info run with TORCHDYNAMO_EXTENDED_DEBUG_GUARD_ADDED="Eq(s2, s4)"
+runtime_assert Eq(s1, 5) [guard added] x1 = self.l(w)  # [6, 3]  # dynamic_shapes_tutorial.py:17 in forward (_meta_registrations.py:2127 in meta_mm), for more info run with TORCHDYNAMO_EXTENDED_DEBUG_GUARD_ADDED="Eq(s1, 5)"
+runtime_assert Eq(s2*s3, s5) [guard added] x3 = x2 + z  # [32]  # dynamic_shapes_tutorial.py:19 in forward (_subclasses/fake_impls.py:845 in infer_size), for more info run with TORCHDYNAMO_EXTENDED_DEBUG_GUARD_ADDED="Eq(s2*s3, s5)"
+"""
+
+######################################################################
+# Next to the ``[guard added]`` messages, we also see the responsible user lines of code - luckily here the model is simple enough.
+# In many real-world cases it's not so straightforward: high-level torch operations can have complicated fake-kernel implementations
+# or operator decompositions that complicate where and what guards are emitted. In such cases the best way to dig deeper and investigate
+# is to follow the logs' suggestion, and re-run with environment variable ``TORCHDYNAMO_EXTENDED_DEBUG_GUARD_ADDED="..."``, to further
+# attribute the guard of interest.
+#
+# ``Dim.AUTO`` is just one of the available options for interacting with ``dynamic_shapes``; as of writing this 2 other options are available:
+# ``Dim.DYNAMIC``, and ``Dim.STATIC``. ``Dim.STATIC`` simply marks a dimension static, while ``Dim.DYNAMIC`` is similar to ``Dim.AUTO`` in all
+# ways except one: it raises an error when specializing to a constant; this is designed to maintain dynamism. See for example what happens when a
+# static guard is emitted on a dynamically-marked dimension:
+
+dynamic_shapes["w"] = (Dim.AUTO, Dim.DYNAMIC)
+try:
+    export(model, (w, x, y, z), dynamic_shapes=dynamic_shapes)
+except Exception:
+    tb.print_exc()
+
+######################################################################
+# Static guards also aren't always inherent to the model; they can also come from user specifications. In fact, a common pitfall leading to shape
+# specializations is when the user specifies conflicting markers for equivalent dimensions; one dynamic and another static. The same error type is
+# raised when this is the case for ``x.shape[0]`` and ``y.shape[1]``:
+
+dynamic_shapes["w"] = (Dim.AUTO, Dim.AUTO)
+dynamic_shapes["x"] = (Dim.STATIC,)
+dynamic_shapes["y"] = (Dim.AUTO, Dim.DYNAMIC)
+try:
+    export(model, (w, x, y, z), dynamic_shapes=dynamic_shapes)
+except Exception:
+    tb.print_exc()
+
+######################################################################
+# Here you might ask why export "specializes", i.e. why we resolve this static/dynamic conflict by going with the static route. The answer is because
+# of the symbolic shapes system described above, of symbols and guards. When ``x.shape[0]`` is marked static, we don't allocate a symbol, and compile
+# treating this shape as a concrete integer 4. A symbol is allocated for ``y.shape[1]``, and so we finally emit the guard ``s3 == 4``, leading to
+# specialization.
+#
+# One feature of export is that during tracing, statements like asserts, ``torch._check()``, and ``if/else`` conditions will also emit guards.
+# See what happens when we augment the existing model with such statements:
+
+class DynamicModel(torch.nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.l = torch.nn.Linear(5, 3)
+
+    def forward(self, w, x, y, z):
+        assert w.shape[0] <= 512
+        torch._check(x.shape[0] >= 4)
+        if w.shape[0] == x.shape[0] + 2:
+            x0 = x + y
+            x1 = self.l(w)
+            x2 = x0.flatten()
+            x3 = x2 + z
+            return x1, x3
+        else:
+            return w
+
+dynamic_shapes = {
+    "w": (Dim.AUTO, Dim.AUTO),
+    "x": (Dim.AUTO,),
+    "y": (Dim.AUTO, Dim.AUTO),
+    "z": (Dim.AUTO,),
+}
+try:
+    ep = export(DynamicModel(), (w, x, y, z), dynamic_shapes=dynamic_shapes)
+except Exception:
+    tb.print_exc()
+
+######################################################################
+# Each of these statements emits an additional guard, and the exported program shows the changes; ``s0`` is eliminated in favor of ``s2 + 2``,
+# and ``s2`` now contains lower and upper bounds, reflected in ``range_constraints``.
+#
+# For the if/else condition, you might ask why the True branch was taken, and why it wasn't the ``w.shape[0] != x.shape[0] + 2`` guard that
+# got emitted from tracing. The answer is that export is guided by the sample inputs provided by tracing, and specializes on the branches taken.
+# If different sample input shapes were provided that fail the ``if`` condition, export would trace and emit guards corresponding to the ``else`` branch.
+# Additionally, you might ask why we traced only the ``if`` branch, and if it's possible to maintain control-flow in your program and keep both branches
+# alive. For that, refer to rewriting your model code following the ``Control Flow Ops`` section above.
+
+######################################################################
+# 0/1 specialization
+# ^^^^^^^^^^^^^^^^^^
+#
+# Since we're talking about guards and specializations, it's a good time to talk about the 0/1 specialization issue we brought up earlier.
+# The bottom line is that export will specialize on sample input dimensions with value 0 or 1, because these shapes have trace-time properties that
+# don't generalize to other shapes. For example, size 1 tensors can broadcast while other sizes fail; and size 0 ... . This just means that you should
+# specify 0/1 sample inputs when you'd like your program to hardcode them, and non-0/1 sample inputs when dynamic behavior is desirable. See what happens
+# at runtime when we export this linear layer:
+
+ep = export(
+    torch.nn.Linear(4, 3),
+    (torch.randn(1, 4),),
+    dynamic_shapes={
+        "input": (Dim.AUTO, Dim.STATIC),
+    },
+)
+try:
+    ep.module()(torch.randn(2, 4))
+except Exception:
+    tb.print_exc()
+
+######################################################################
+# Named Dims
+# ^^^^^^^^^^
+#
+# So far we've only been talking about 3 ways to specify dynamic shapes: ``Dim.AUTO``, ``Dim.DYNAMIC``, and ``Dim.STATIC``. The attraction of these is the
+# low-friction user experience; all the guards emitted during model tracing are adhered to, and dynamic behavior like min/max ranges, relations, and static/dynamic
+# dimensions are automatically figured out underneath export. The dynamic shapes subsystem essentially acts as a "discovery" process, summarizing these guards
+# and presenting what export believes is the overall dynamic behavior of the program. The drawback of this design appears once the user has stronger expectations or
+# beliefs about the dynamic behavior of these models - maybe there is a strong desire on dynamism and specializations on particular dimensions are to be avoided at
+# all costs, or maybe we just want to catch changes in dynamic behavior with changes to the original model code, or possibly underlying decompositions or meta-kernels.
+# These changes won't be detected and the ``export()`` call will most likely succeed, unless tests are in place that check the resulting ``ExportedProgram`` representation.
+#
+# For such cases, our stance is to recommend the "traditional" way of specifying dynamic shapes, which longer-term users of export might be familiar with: named ``Dims``:
+
+dx = Dim("dx", min=4, max=256)
+dh = Dim("dh", max=512)
+dynamic_shapes = {
+    "x": (dx, None),
+    "y": (2 * dx, dh),
+}
+
+######################################################################
+# This style of dynamic shapes allows the user to specify what symbols are allocated for input dimensions, min/max bounds on those symbols, and places restrictions on the
+# dynamic behavior of the ``ExportedProgram`` produced; ``ConstraintViolation`` errors will be raised if model tracing emits guards that conflict with the relations or static/dynamic
+# specifications given. For example, in the above specification, the following is asserted:
+#
+# - ``x.shape[0]`` is to have range ``[4, 256]``, and related to ``y.shape[0]`` by ``y.shape[0] == 2 * x.shape[0]``.
+# - ``x.shape[1]`` is static.
+# - ``y.shape[1]`` has range ``[2, 512]``, and is unrelated to any other dimension.
+#
+# In this design, we allow relations between dimensions to be specified with univariate linear expressions: ``A * dim + B`` can be specified for any dimension. This allows users
+# to specify more complex constraints like integer divisibility for dynamic dimensions:
+
+dx = Dim("dx", min=4, max=512)
+dynamic_shapes = {
+    "x": (4 * dx, None)  # x.shape[0] has range [16, 2048], and is divisible by 4.
+}
+
+######################################################################
+# Constraint violations, suggested fixes
+# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#
+# One common issue with this specification style (before ``Dim.AUTO`` was introduced), is that the specification would often be mismatched with what was produced by model tracing.
+# That would lead to ``ConstraintViolation`` errors and export suggested fixes - see for example with this model & specification, where the model inherently requires equality between
+# dimensions 0 of ``x`` and ``y``, and requires dimension 1 to be static.
+
+class Foo(torch.nn.Module):
+    def forward(self, x, y):
+        w = x + y
+        return w + torch.ones(4)
+
+dx, dy, d1 = torch.export.dims("dx", "dy", "d1")
+try:
+    ep = export(
+        Foo(),
+        (torch.randn(6, 4), torch.randn(6, 4)),
+        dynamic_shapes={
+            "x": (dx, d1),
+            "y": (dy, d1),
+        },
+    )
+except Exception:
+    tb.print_exc()
+
+######################################################################
+# The expectation with suggested fixes is that the user can interactively copy-paste the changes into their dynamic shapes specification, and successfully export afterwards.
+#
+# Lastly, there's couple nice-to-knows about the options for specification:
+#
+# - ``None`` is a good option for static behavior:
+#   - ``dynamic_shapes=None`` (default) exports with the entire model being static.
+#   - specifying ``None`` at an input-level exports with all tensor dimensions static, and is also required for non-tensor inputs.
+#   - specifying ``None`` at a dimension-level specializes that dimension, though this is deprecated in favor of ``Dim.STATIC``.
+# - specifying per-dimension integer values also produces static behavior, and will additionally check that the provided sample input matches the specification.
+#
+# These options are combined in the inputs & dynamic shapes spec below:
+
+inputs = (
+    torch.randn(4, 4),
+    torch.randn(3, 3),
+    16,
+    False,
+)
+dynamic_shapes = {
+    "tensor_0": (Dim.AUTO, None),
+    "tensor_1": None,
+    "int_val": None,
+    "bool_val": None,
+}
+
+######################################################################
+# Data-dependent errors
+# ---------------------
+#
+# While trying to export models, you have may have encountered errors like "Could not guard on data-dependent expression", or Could not extract specialized integer from data-dependent expression".
+# These errors exist because ``torch.export()`` compiles programs using FakeTensors, which symbolically represent their real tensor counterparts. While these have equivalent symbolic properties
+# (e.g. sizes, strides, dtypes), they diverge in that FakeTensors do not contain any data values. While this avoids unnecessary memory usage and expensive computation, it does mean that export may be
+# unable to out-of-the-box compile parts of user code where compilation relies on data values. In short, if the compiler requires a concrete, data-dependent value in order to proceed, it will error out,
+# complaining that the value is not available.
+#
+# Data-dependent values appear in many places, and common sources are calls like ``item()``, ``tolist()``, or ``torch.unbind()`` that extract scalar values from tensors.
+# How are these values represented in the exported program? In the `Constraints/Dynamic Shapes <https://pytorch.org/tutorials/intermediate/torch_export_tutorial.html#constraints-dynamic-shapes>`_
+# section, we talked about allocating symbols to represent dynamic input dimensions.
+# The same happens here: we allocate symbols for every data-dependent value that appears in the program. The important distinction is that these are "unbacked" symbols,
+# in contrast to the "backed" symbols allocated for input dimensions. The `"backed/unbacked" <https://pytorch.org/docs/main/export.programming_model.html#basics-of-symbolic-shapes>`_
+# nomenclature refers to the presence/absence of a "hint" for the symbol: a concrete value backing the symbol, that can inform the compiler on how to proceed.
+#
+# In the input shape symbol case (backed symbols), these hints are simply the sample input shapes provided, which explains why control-flow branching is determined by the sample input properties.
+# For data-dependent values, the symbols are taken from FakeTensor "data" during tracing, and so the compiler doesn't know the actual values (hints) that these symbols would take on.
+#
+# Let's see how these show up in exported programs:
+
+class Foo(torch.nn.Module):
+    def forward(self, x, y):
+        a = x.item()
+        b = y.tolist()
+        return b + [a]
+
+inps = (
+    torch.tensor(1),
+    torch.tensor([2, 3]),
+)
+ep = export(Foo(), inps)
+print(ep)
+
+######################################################################
+# The result is that 3 unbacked symbols (notice they're prefixed with "u", instead of the usual "s" for input shape/backed symbols) are allocated and returned:
+# 1 for the ``item()`` call, and 1 for each of the elements of ``y`` with the ``tolist()`` call.
+# Note from the range constraints field that these take on ranges of ``[-int_oo, int_oo]``, not the default ``[0, int_oo]`` range allocated to input shape symbols,
+# since we have no information on what these values are - they don't represent sizes, so don't necessarily have positive values.
+
+######################################################################
+# Guards, torch._check()
+# ^^^^^^^^^^^^^^^^^^^^^^
+#
+# But the case above is easy to export, because the concrete values of these symbols aren't used in any compiler decision-making; all that's relevant is that the return values are unbacked symbols.
+# The data-dependent errors highlighted in this section are cases like the following, where `data-dependent guards <https://pytorch.org/docs/main/export.programming_model.html#control-flow-static-vs-dynamic>`_ are encountered:
+
+class Foo(torch.nn.Module):
+    def forward(self, x, y):
+        a = x.item()
+        if a // 2 >= 5:
+            return y + 2
+        else:
+            return y * 5
+
+######################################################################
+# Here we actually need the "hint", or the concrete value of ``a`` for the compiler to decide whether to trace ``return y + 2`` or ``return y * 5`` as the output.
+# Because we trace with FakeTensors, we don't know what ``a // 2 >= 5`` actually evaluates to, and export errors out with "Could not guard on data-dependent expression ``u0 // 2 >= 5 (unhinted)``".
+#
+# So how do we export this toy model? Unlike ``torch.compile()``, export requires full graph compilation, and we can't just graph break on this. Here are some basic options:
+#
+# 1. Manual specialization: we could intervene by selecting the branch to trace, either by removing the control-flow code to contain only the specialized branch, or using ``torch.compiler.is_compiling()`` to guard what's traced at compile-time.
+# 2. ``torch.cond()``: we could rewrite the control-flow code to use ``torch.cond()`` so we don't specialize on a branch.
+#
+# While these options are valid, they have their pitfalls. Option 1 sometimes requires drastic, invasive rewrites of the model code to specialize, and ``torch.cond()`` is not a comprehensive system for handling data-dependent errors.
+# As we will see, there are data-dependent errors that do not involve control-flow.
+#
+# The generally recommended approach is to start with ``torch._check()`` calls. While these give the impression of purely being assert statements, they are in fact a system of informing the compiler on properties of symbols.
+# While a ``torch._check()`` call does act as an assertion at runtime, when traced at compile-time, the checked expression is sent to the symbolic shapes subsystem for reasoning, and any symbol properties that follow from the expression being true,
+# are stored as symbol properties (provided it's smart enough to infer those properties). So even if unbacked symbols don't have hints, if we're able to communicate properties that are generally true for these symbols via
+# ``torch._check()`` calls, we can potentially bypass data-dependent guards without rewriting the offending model code.
+#
+# For example in the model above, inserting ``torch._check(a >= 10)`` would tell the compiler that ``y + 2`` can always be returned, and ``torch._check(a == 4)`` tells it to return ``y * 5``.
+# See what happens when we re-export this model.
+
+class Foo(torch.nn.Module):
+    def forward(self, x, y):
+        a = x.item()
+        torch._check(a >= 10)
+        torch._check(a <= 60)
+        if a // 2 >= 5:
+            return y + 2
+        else:
+            return y * 5
+
+inps = (
+    torch.tensor(32),
+    torch.randn(4),
+)
+ep = export(Foo(), inps)
+print(ep)
+
+######################################################################
+# Export succeeds, and note from the range constraints field that ``u0`` takes on a range of ``[10, 60]``.
+#
+# So what information do ``torch._check()`` calls actually communicate? This varies as the symbolic shapes subsystem gets smarter, but at a fundamental level, these are generally true:
+#
+# 1. Equality with non-data-dependent expressions: ``torch._check()`` calls that communicate equalities like ``u0 == s0 + 4`` or ``u0 == 5``.
+# 2. Range refinement: calls that provide lower or upper bounds for symbols, like the above.
+# 3. Some basic reasoning around more complicated expressions: inserting ``torch._check(a < 4)`` will typically tell the compiler that ``a >= 4`` is false. Checks on complex expressions like ``torch._check(a ** 2 - 3 * a <= 10)`` will typically get you past identical guards.
+#
+# As mentioned previously, ``torch._check()`` calls have applicability outside of data-dependent control flow. For example, here's a model where ``torch._check()`` insertion
+# prevails while manual specialization & ``torch.cond()`` do not:
+
+class Foo(torch.nn.Module):
+    def forward(self, x, y):
+        a = x.item()
+        return y[a]
+
+inps = (
+    torch.tensor(32),
+    torch.randn(60),
+)
+try:
+    export(Foo(), inps)
+except Exception:
+    tb.print_exc()
+
+######################################################################
+# Here is a scenario where ``torch._check()`` insertion is required simply to prevent an operation from failing. The export call will fail with
+# "Could not guard on data-dependent expression ``-u0 > 60``", implying that the compiler doesn't know if this is a valid indexing operation -
+# if the value of ``x`` is out-of-bounds for ``y`` or not. Here, manual specialization is too prohibitive, and ``torch.cond()`` has no place.
+# Instead, informing the compiler of ``u0``'s range is sufficient:
+
+class Foo(torch.nn.Module):
+    def forward(self, x, y):
+        a = x.item()
+        torch._check(a >= 0)
+        torch._check(a < y.shape[0])
+        return y[a]
+
+inps = (
+    torch.tensor(32),
+    torch.randn(60),
+)
+ep = export(Foo(), inps)
+print(ep)
+
+######################################################################
+# Specialized values
+# ^^^^^^^^^^^^^^^^^^
+#
+# Another category of data-dependent error happens when the program attempts to extract a concrete data-dependent integer/float value
+# while tracing. This looks something like "Could not extract specialized integer from data-dependent expression", and is analogous to
+# the previous class of errors - if these occur when attempting to evaluate concrete integer/float values, data-dependent guard errors arise
+# with evaluating concrete boolean values.
+#
+# This error typically occurs when there is an explicit or implicit ``int()`` cast on a data-dependent expression. For example, this list comprehension
+# has a `range()` call that implicitly does an ``int()`` cast on the size of the list:
+
+class Foo(torch.nn.Module):
+    def forward(self, x, y):
+        a = x.item()
+        b = torch.cat([y for y in range(a)], dim=0)
+        return b + int(a)
+
+inps = (
+    torch.tensor(32),
+    torch.randn(60),
+)
+try:
+    export(Foo(), inps, strict=False)
+except Exception:
+    tb.print_exc()
+
+######################################################################
+# For these errors, some basic options you have are:
+#
+# 1. Avoid unnecessary ``int()`` cast calls, in this case the ``int(a)`` in the return statement.
+# 2. Use ``torch._check()`` calls; unfortunately all you may be able to do in this case is specialize (with ``torch._check(a == 60)``).
+# 3. Rewrite the offending code at a higher level. For example, the list comprehension is semantically a ``repeat()`` op, which doesn't involve an ``int()`` cast. The following rewrite avoids data-dependent errors:
+
+class Foo(torch.nn.Module):
+    def forward(self, x, y):
+        a = x.item()
+        b = y.unsqueeze(0).repeat(a, 1)
+        return b + a
+
+inps = (
+    torch.tensor(32),
+    torch.randn(60),
+)
+ep = export(Foo(), inps, strict=False)
+print(ep)
+
+######################################################################
+# Data-dependent errors can be much more involved, and there are many more options in your toolkit to deal with them: ``torch._check_is_size()``, ``guard_size_oblivious()``, or real-tensor tracing, as starters.
+# For more in-depth guides, please refer to the `Export Programming Model <https://pytorch.org/docs/main/export.programming_model.html>`_,
+# or `Dealing with GuardOnDataDependentSymNode errors <https://docs.google.com/document/d/1HSuTTVvYH1pTew89Rtpeu84Ht3nQEFTYhAX3Ypa_xJs>`_.
+
+######################################################################
+# Custom Ops
+# ----------
+#
+# ``torch.export`` can export PyTorch programs with custom operators. Please
+# refer to `this page <https://pytorch.org/tutorials/advanced/custom_ops_landing_page.html>`__
+# on how to author a custom operator in either C++ or Python.
+#
+# The following is an example of registering a custom operator in python to be
+# used by ``torch.export``. The important thing to note is that the custom op
+# must have a `FakeTensor kernel <https://docs.google.com/document/d/1_W62p8WJOQQUzPsJYa7s701JXt0qf2OfLub2sbkHOaU/edit?tab=t.0#heading=h.xvrg7clz290>`__.
+
+@torch.library.custom_op("my_custom_library::custom_op", mutates_args={})
+def custom_op(x: torch.Tensor) -> torch.Tensor:
+    print("custom_op called!")
+    return torch.relu(x)
+
+@custom_op.register_fake
+def custom_op_meta(x):
+    # Returns an empty tensor with the same shape as the expected output
+    return torch.empty_like(x)
+
+######################################################################
+# Here is an example of exporting a program with the custom op.
+
+class CustomOpExample(torch.nn.Module):
+    def forward(self, x):
+        x = torch.sin(x)
+        x = torch.ops.my_custom_library.custom_op(x)
+        x = torch.cos(x)
+        return x
+
+exported_custom_op_example = export(CustomOpExample(), (torch.randn(3, 3),))
+print(exported_custom_op_example)
+print(exported_custom_op_example.module()(torch.randn(3, 3)))
+
+######################################################################
+# Note that in the ``ExportedProgram``, the custom operator is included in the graph.
+
+######################################################################
+# IR/Decompositions
+# -----------------
+#
+# The graph produced by ``torch.export`` returns a graph containing only
+# `ATen operators <https://pytorch.org/cppdocs/#aten>`__, which are the
+# basic unit of computation in PyTorch. As there are over 3000 ATen operators,
+# export provides a way to narrow down the operator set used in the graph based
+# on certain characteristics, creating different IRs.
+#
+# By default, export produces the most generic IR which contains all ATen
+# operators, including both functional and non-functional operators. A functional
+# operator is one that does not contain any mutations or aliasing of the inputs.
+# You can find a list of all ATen operators
+# `here <https://github.com/pytorch/pytorch/blob/main/aten/src/ATen/native/native_functions.yaml>`__
+# and you can inspect if an operator is functional by checking
+# ``op._schema.is_mutable``, for example:
+
+print(torch.ops.aten.add.Tensor._schema.is_mutable)
+print(torch.ops.aten.add_.Tensor._schema.is_mutable)
+
+######################################################################
+# This generic IR can be used to train in eager PyTorch Autograd. This IR can be
+# more explicitly reached through the API ``torch.export.export_for_training``,
+# which was introduced in PyTorch 2.5, but calling ``torch.export.export``
+# should produce the same graph as of PyTorch 2.6.
+
+class DecompExample(torch.nn.Module):
+    def __init__(self) -> None:
+        super().__init__()
+        self.conv = torch.nn.Conv2d(1, 3, 1, 1)
+        self.bn = torch.nn.BatchNorm2d(3)
+
+    def forward(self, x):
+        x = self.conv(x)
+        x = self.bn(x)
+        return (x,)
+
+ep_for_training = torch.export.export_for_training(DecompExample(), (torch.randn(1, 1, 3, 3),))
+print(ep_for_training.graph)
+
+######################################################################
+# We can then lower this exported program to an operator set which only contains
+# functional ATen operators through the API ``run_decompositions``, which
+# decomposes the ATen operators into the ones specified in the decomposition
+# table, and functionalizes the graph. By specifying an empty set, we're only
+# performing functionalization, and does not do any additional decompositions.
+# This results in an IR which contains ~2000 operators (instead of the 3000
+# operators above), and is ideal for inference cases.
+
+ep_for_inference = ep_for_training.run_decompositions(decomp_table={})
+print(ep_for_inference.graph)
+
+######################################################################
+# As we can see, the previously mutable operator,
+# ``torch.ops.aten.add_.default`` has now been replaced with
+# ``torch.ops.aten.add.default``, a l operator.
+
+######################################################################
+# We can also further lower this exported program to an operator set which only
+# contains the
+# `Core ATen Operator Set <https://pytorch.org/docs/main/torch.compiler_ir.html#core-aten-ir>`__,
+# which is a collection of only ~180 operators. This IR is optimal for backends
+# who do not want to reimplement all ATen operators.
+
+from torch.export import default_decompositions
+
+core_aten_decomp_table = default_decompositions()
+core_aten_ep = ep_for_training.run_decompositions(decomp_table=core_aten_decomp_table)
+print(core_aten_ep.graph)
+
+######################################################################
+# We now see that ``torch.ops.aten.conv2d.default`` has been decomposed
+# into ``torch.ops.aten.convolution.default``. This is because ``convolution``
+# is a more "core" operator, as operations like ``conv1d`` and ``conv2d`` can be
+# implemented using the same op.
+
+######################################################################
+# We can also specify our own decomposition behaviors:
+
+my_decomp_table = torch.export.default_decompositions()
+
+def my_awesome_custom_conv2d_function(x, weight, bias, stride=[1, 1], padding=[0, 0], dilation=[1, 1], groups=1):
+    return 2 * torch.ops.aten.convolution(x, weight, bias, stride, padding, dilation, False, [0, 0], groups)
+
+my_decomp_table[torch.ops.aten.conv2d.default] = my_awesome_custom_conv2d_function
+my_ep = ep_for_training.run_decompositions(my_decomp_table)
+print(my_ep.graph)
+
+######################################################################
+# Notice that instead of ``torch.ops.aten.conv2d.default`` being decomposed
+# into ``torch.ops.aten.convolution.default``, it is now decomposed into
+# ``torch.ops.aten.convolution.default`` and ``torch.ops.aten.mul.Tensor``,
+# which matches our custom decomposition rule.
+
+######################################################################
+# ExportDB
+# --------
+#
+# ``torch.export`` will only ever export a single computation graph from a PyTorch program. Because of this requirement,
+# there will be Python or PyTorch features that are not compatible with ``torch.export``, which will require users to
+# rewrite parts of their model code. We have seen examples of this earlier in the tutorial -- for example, rewriting
+# if-statements using ``cond``.
+#
+# `ExportDB <https://pytorch.org/docs/main/generated/exportdb/index.html>`__ is the standard reference that documents
+# supported and unsupported Python/PyTorch features for ``torch.export``. It is essentially a list a program samples, each
+# of which represents the usage of one particular Python/PyTorch feature and its interaction with ``torch.export``.
+# Examples are also tagged by category so that they can be more easily searched.
+#
+# For example, let's use ExportDB to get a better understanding of how the predicate works in the ``cond`` operator.
+# We can look at the example called ``cond_predicate``, which has a ``torch.cond`` tag. The example code looks like:
+
+def cond_predicate(x):
+    """
+    The conditional statement (aka predicate) passed to ``cond()`` must be one of the following:
+    - ``torch.Tensor`` with a single element
+    - boolean expression
+    NOTE: If the `pred` is test on a dim with batch size < 2, it will be specialized.
+    """
+    pred = x.dim() > 2 and x.shape[2] > 10
+    return cond(pred, lambda x: x.cos(), lambda y: y.sin(), [x])
+
+######################################################################
+# More generally, ExportDB can be used as a reference when one of the following occurs:
+#
+# 1. Before attempting ``torch.export``, you know ahead of time that your model uses some tricky Python/PyTorch features
+#    and you want to know if ``torch.export`` covers that feature.
+# 2. When attempting ``torch.export``, there is a failure and it's unclear how to work around it.
+#
+# ExportDB is not exhaustive, but is intended to cover all use cases found in typical PyTorch code. Feel free to reach
+# out if there is an important Python/PyTorch feature that should be added to ExportDB or supported by ``torch.export``.
+
+######################################################################
+# Running the Exported Program
+# ----------------------------
+#
+# As ``torch.export`` is only a graph capturing mechanism, calling the artifact
+# produced by ``torch.export`` eagerly will be equivalent to running the eager
+# module. To optimize the execution of the Exported Program, we can pass this
+# exported artifact to backends such as Inductor through ``torch.compile``,
+# `AOTInductor <https://pytorch.org/docs/main/torch.compiler_aot_inductor.html>`__,
+# or `TensorRT <https://pytorch.org/TensorRT/dynamo/dynamo_export.html>`__.
+
+class M(torch.nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.linear = torch.nn.Linear(3, 3)
+
+    def forward(self, x):
+        x = self.linear(x)
+        return x
+
+inp = torch.randn(2, 3, device="cuda")
+m = M().to(device="cuda")
+ep = torch.export.export(m, (inp,))
+
+# Run it eagerly
+res = ep.module()(inp)
+print(res)
+
+# Run it with torch.compile
+res = torch.compile(ep.module(), backend="inductor")(inp)
+print(res)
+
+######################################################################
+# .. code-block:: python
+#
+#    import torch._inductor
+#
+#    # Note: these APIs are subject to change
+#    # Compile the exported program to a PT2 archive using ``AOTInductor``
+#    with torch.no_grad():
+#        pt2_path = torch._inductor.aoti_compile_and_package(ep)
+#
+#    # Load and run the .so file in Python.
+#    # To load and run it in a C++ environment, see:
+#    # https://pytorch.org/docs/main/torch.compiler_aot_inductor.html
+#    aoti_compiled = torch._inductor.aoti_load_package(pt2_path)
+#    res = aoti_compiled(inp)
+
+######################################################################
+# Conclusion
+# ----------
+#
+# We introduced ``torch.export``, the new PyTorch 2.X way to export single computation
+# graphs from PyTorch programs. In particular, we demonstrate several code modifications
+# and considerations (control flow ops, constraints, etc.) that need to be made in order to export a graph.
diff --git a/intermediate_source/torchrec_intro_tutorial.py b/intermediate_source/torchrec_intro_tutorial.py
new file mode 100644
index 00000000000..81b7663c110
--- /dev/null
+++ b/intermediate_source/torchrec_intro_tutorial.py
@@ -0,0 +1,950 @@
+"""
+Introduction to TorchRec
+==================================
+
+**TorchRec** is a PyTorch library tailored for building scalable and efficient recommendation systems using embeddings.
+This tutorial guides you through the installation process, introduces the concept of embeddings, and highlights their importance in
+recommendation systems. It offers practical demonstrations on implementing embeddings with PyTorch
+and TorchRec, focusing on handling large embedding tables through distributed training and advanced optimizations.
+
+.. grid:: 2
+
+    .. grid-item-card:: :octicon:`mortar-board;1em;` What you will learn
+       :class-card: card-prerequisites
+
+       * Fundamentals of embeddings and their role in recommendation systems
+       * How to set up TorchRec to manage and implement embeddings in PyTorch environments
+       * Explore advanced techniques for distributing large embedding tables across multiple GPUs
+
+    .. grid-item-card:: :octicon:`list-unordered;1em;` Prerequisites
+       :class-card: card-prerequisites
+
+       * PyTorch v2.5 or later with CUDA 11.8 or later
+       * Python 3.9 or later
+       * `FBGEMM <https://github.com/pytorch/fbgemm>`__
+
+
+"""
+
+###############################################
+# Install Dependencies
+# ^^^^^^^^^^^^^^^^^^^^
+#
+# Before running this tutorial in Google Colab, make sure to install the
+# following dependencies:
+#
+# .. code-block:: sh
+#
+#    !pip3 install --pre torch --index-url https://download.pytorch.org/whl/cu121 -U
+#    !pip3 install fbgemm_gpu --index-url https://download.pytorch.org/whl/cu121
+#    !pip3 install torchmetrics==1.0.3
+#    !pip3 install torchrec --index-url https://download.pytorch.org/whl/cu121
+#
+# .. note::
+#    If you are running this in Google Colab, make sure to switch to a GPU runtime type.
+#    For more information,
+#    see `Enabling CUDA <https://pytorch.org/tutorials/beginner/colab#enabling-cuda>`__
+#
+
+
+######################################################################
+# Embeddings
+# ~~~~~~~~~~
+#
+# When building recommendation systems, categorical features typically
+# have massive cardinality, posts, users, ads, and so on.
+#
+# In order to represent these entities and model these relationships,
+# **embeddings** are used. In machine learning, **embeddings are a vectors
+# of real numbers in a high-dimensional space used to represent meaning in
+# complex data like words, images, or users**.
+#
+# Embeddings in RecSys
+# ~~~~~~~~~~~~~~~~~~~~
+#
+# Now you might wonder, how are these embeddings generated in the first
+# place? Well, embeddings are represented as individual rows in an
+# **Embedding Table**, also referred to as embedding weights. The reason
+# for this is that embeddings or embedding table weights are trained just
+# like all of the other weights of the model via gradient descent!
+#
+# Embedding tables are simply a large matrix for storing embeddings, with
+# two dimensions (B, N), where:
+#
+# * B is the number of embeddings stored by the table
+# * N is the number of dimensions per embedding (N-dimensional embedding).
+#
+# The inputs to embedding tables represent embedding lookups to retrieve
+# the embedding for a specific index or row. In recommendation systems, such
+# as those used in many large systems, unique IDs are not only used for
+# specific users, but also across entities like posts and ads to serve as
+# lookup indices to respective embedding tables!
+#
+# Embeddings are trained in RecSys through the following process:
+#
+# * **Input/lookup indices are fed into the model, as unique IDs**. IDs are
+#   hashed to the total size of the embedding table to prevent issues when
+#   the ID > number of rows
+#
+# * Embeddings are then retrieved and **pooled, such as taking the sum or
+#   mean of the embeddings**. This is required as there can be a variable number of
+#   embeddings per example while the model expects consistent shapes.
+#
+# * The **embeddings are used in conjunction with the rest of the model to
+#   produce a prediction**, such as `Click-Through Rate
+#   (CTR) <https://support.google.com/google-ads/answer/2615875?hl=en>`__
+#   for an ad.
+#
+# * The loss is calculated with the prediction and the label
+#   for an example, and **all weights of the model are updated through
+#   gradient descent and backpropagation, including the embedding weights**
+#   that were associated with the example.
+#
+# These embeddings are crucial for representing categorical features, such
+# as users, posts, and ads, in order to capture relationships and make
+# good recommendations. The `Deep learning recommendation
+# model <https://arxiv.org/abs/1906.00091>`__ (DLRM) paper talks more
+# about the technical details of using embedding tables in RecSys.
+#
+# This tutorial introduces the concept of embeddings, showcase
+# TorchRec specific modules and data types, and depict how distributed training
+# works with TorchRec.
+#
+
+import torch
+
+
+######################################################################
+# Embeddings in PyTorch
+# ---------------------
+#
+# In PyTorch, we have the following types of embeddings:
+#
+# * :class:`torch.nn.Embedding`: An embedding table where forward pass returns the
+#   embeddings themselves as is.
+#
+# * :class:`torch.nn.EmbeddingBag`: Embedding table where forward pass returns
+#   embeddings that are then pooled, for example, sum or mean, otherwise known
+#   as **Pooled Embeddings**.
+#
+# In this section, we will go over a very brief introduction to performing
+# embedding lookups by passing in indices into the table.
+#
+
+num_embeddings, embedding_dim = 10, 4
+
+# Initialize our embedding table
+weights = torch.rand(num_embeddings, embedding_dim)
+print("Weights:", weights)
+
+# Pass in pre-generated weights just for example, typically weights are randomly initialized
+embedding_collection = torch.nn.Embedding(
+    num_embeddings, embedding_dim, _weight=weights
+)
+embedding_bag_collection = torch.nn.EmbeddingBag(
+    num_embeddings, embedding_dim, _weight=weights
+)
+
+# Print out the tables, we should see the same weights as above
+print("Embedding Collection Table: ", embedding_collection.weight)
+print("Embedding Bag Collection Table: ", embedding_bag_collection.weight)
+
+# Lookup rows (ids for embedding ids) from the embedding tables
+# 2D tensor with shape (batch_size, ids for each batch)
+ids = torch.tensor([[1, 3]])
+print("Input row IDS: ", ids)
+
+embeddings = embedding_collection(ids)
+
+# Print out the embedding lookups
+# You should see the specific embeddings be the same as the rows (ids) of the embedding tables above
+print("Embedding Collection Results: ")
+print(embeddings)
+print("Shape: ", embeddings.shape)
+
+# ``nn.EmbeddingBag`` default pooling is mean, so should be mean of batch dimension of values above
+pooled_embeddings = embedding_bag_collection(ids)
+
+print("Embedding Bag Collection Results: ")
+print(pooled_embeddings)
+print("Shape: ", pooled_embeddings.shape)
+
+# ``nn.EmbeddingBag`` is the same as ``nn.Embedding`` but just with pooling (mean, sum, and so on)
+# We can see that the mean of the embeddings of embedding_collection is the same as the output of the embedding_bag_collection
+print("Mean: ", torch.mean(embedding_collection(ids), dim=1))
+
+
+######################################################################
+# Congratulations! Now you have a basic understanding of how to use
+# embedding tables --- one of the foundations of modern recommendation
+# systems! These tables represent entities and their relationships. For
+# example, the relationship between a given user and the pages and posts
+# they have liked.
+#
+
+
+######################################################################
+# TorchRec Features Overview
+# ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#
+# In the section above we've learned how to use embedding tables, one of the foundations of
+# modern recommendation systems! These tables represent entities and
+# relationships, such as users, pages, posts, etc. Given that these
+# entities are always increasing, a **hash** function is typically applied
+# to make sure the IDs are within the bounds of a certain embedding table.
+# However, in order to represent a vast amount of entities and reduce hash
+# collisions, these tables can become quite massive (think about the number of ads
+# for example). In fact, these tables can become so massive that they
+# won't be able to fit on 1 GPU, even with 80G of memory.
+#
+# In order to train models with massive embedding tables, sharding these
+# tables across GPUs is required, which then introduces a whole new set of
+# problems and opportunities in parallelism and optimization. Luckily, we have
+# the TorchRec library <https://docs.pytorch.org/torchrec/overview.html>`__ that has encountered, consolidated, and addressed
+# many of these concerns. TorchRec serves as a **library that provides
+# primitives for large scale distributed embeddings**.
+#
+# Next, we will explore the major features of the TorchRec
+# library. We will start with ``torch.nn.Embedding`` and will extend that to
+# custom TorchRec modules, explore distributed training environment with
+# generating a sharding plan for embeddings, look at inherent TorchRec
+# optimizations, and extend the model to be ready for inference in C++.
+# Below is a quick outline of what this section consists of:
+#
+# * TorchRec Modules and Data Types
+# * Distributed Training, Sharding, and Optimizations
+#
+# Let's begin with importing TorchRec:
+
+import torchrec
+
+
+######################################################################
+# TorchRec Modules and Data Types
+# ----------------------------------
+#
+# This section goes over TorchRec Modules and data types including such
+# entities as ``EmbeddingCollection`` and ``EmbeddingBagCollection``,
+# ``JaggedTensor``, ``KeyedJaggedTensor``, ``KeyedTensor`` and more.
+#
+# From ``EmbeddingBag`` to ``EmbeddingBagCollection``
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# We have already explored :class:`torch.nn.Embedding` and :class:`torch.nn.EmbeddingBag`.
+# TorchRec extends these modules by creating collections of embeddings, in
+# other words modules that can have multiple embedding tables, with
+# ``EmbeddingCollection`` and ``EmbeddingBagCollection``
+# We will use ``EmbeddingBagCollection`` to represent a group of
+# embedding bags.
+#
+# In the example code below, we create an ``EmbeddingBagCollection`` (EBC)
+# with two embedding bags, 1 representing **products** and 1 representing **users**.
+# Each table, ``product_table`` and ``user_table``, is represented by a 64 dimension
+# embedding of size 4096.
+#
+
+ebc = torchrec.EmbeddingBagCollection(
+    device="cpu",
+    tables=[
+        torchrec.EmbeddingBagConfig(
+            name="product_table",
+            embedding_dim=64,
+            num_embeddings=4096,
+            feature_names=["product"],
+            pooling=torchrec.PoolingType.SUM,
+        ),
+        torchrec.EmbeddingBagConfig(
+            name="user_table",
+            embedding_dim=64,
+            num_embeddings=4096,
+            feature_names=["user"],
+            pooling=torchrec.PoolingType.SUM,
+        ),
+    ],
+)
+print(ebc.embedding_bags)
+
+
+######################################################################
+# Let’s inspect the forward method for ``EmbeddingBagCollection`` and the
+# module’s inputs and outputs:
+#
+
+import inspect
+
+# Let's look at the ``EmbeddingBagCollection`` forward method
+# What is a ``KeyedJaggedTensor`` and ``KeyedTensor``?
+print(inspect.getsource(ebc.forward))
+
+
+######################################################################
+# TorchRec Input/Output Data Types
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# TorchRec has distinct data types for input and output of its modules:
+# ``JaggedTensor``, ``KeyedJaggedTensor``, and ``KeyedTensor``. Now you
+# might ask, why create new data types to represent sparse features? To
+# answer that question, we must understand how sparse features are
+# represented in code.
+#
+# Sparse features are otherwise known as ``id_list_feature`` and
+# ``id_score_list_feature``, and are the **IDs** that will be used as
+# indices to an embedding table to retrieve the embedding for that ID. To
+# give a very simple example, imagine a single sparse feature being Ads
+# that a user interacted with. The input itself would be a set of Ad IDs
+# that a user interacted with, and the embeddings retrieved would be a
+# semantic representation of those Ads. The tricky part of representing
+# these features in code is that in each input example, **the number of
+# IDs is variable**. One day a user might have interacted with only one ad
+# while the next day they interact with three.
+#
+# A simple representation is shown below, where we have a ``lengths``
+# tensor denoting how many indices are in an example for a batch and a
+# ``values`` tensor containing the indices themselves.
+#
+
+# Batch Size 2
+# 1 ID in example 1, 2 IDs in example 2
+id_list_feature_lengths = torch.tensor([1, 2])
+
+# Values (IDs) tensor: ID 5 is in example 1, ID 7, 1 is in example 2
+id_list_feature_values = torch.tensor([5, 7, 1])
+
+
+######################################################################
+# Next, let's look at the offsets as well as what is contained in each batch
+#
+
+# Lengths can be converted to offsets for easy indexing of values
+id_list_feature_offsets = torch.cumsum(id_list_feature_lengths, dim=0)
+
+print("Offsets: ", id_list_feature_offsets)
+print("First Batch: ", id_list_feature_values[: id_list_feature_offsets[0]])
+print(
+    "Second Batch: ",
+    id_list_feature_values[id_list_feature_offsets[0] : id_list_feature_offsets[1]],
+)
+
+from torchrec import JaggedTensor
+
+# ``JaggedTensor`` is just a wrapper around lengths/offsets and values tensors!
+jt = JaggedTensor(values=id_list_feature_values, lengths=id_list_feature_lengths)
+
+# Automatically compute offsets from lengths
+print("Offsets: ", jt.offsets())
+
+# Convert to list of values
+print("List of Values: ", jt.to_dense())
+
+# ``__str__`` representation
+print(jt)
+
+from torchrec import KeyedJaggedTensor
+
+# ``JaggedTensor`` represents IDs for 1 feature, but we have multiple features in an ``EmbeddingBagCollection``
+# That's where ``KeyedJaggedTensor`` comes in! ``KeyedJaggedTensor`` is just multiple ``JaggedTensors`` for multiple id_list_feature_offsets
+# From before, we have our two features "product" and "user". Let's create ``JaggedTensors`` for both!
+
+product_jt = JaggedTensor(
+    values=torch.tensor([1, 2, 1, 5]), lengths=torch.tensor([3, 1])
+)
+user_jt = JaggedTensor(values=torch.tensor([2, 3, 4, 1]), lengths=torch.tensor([2, 2]))
+
+# Q1: How many batches are there, and which values are in the first batch for ``product_jt`` and ``user_jt``?
+kjt = KeyedJaggedTensor.from_jt_dict({"product": product_jt, "user": user_jt})
+
+# Look at our feature keys for the ``KeyedJaggedTensor``
+print("Keys: ", kjt.keys())
+
+# Look at the overall lengths for the ``KeyedJaggedTensor``
+print("Lengths: ", kjt.lengths())
+
+# Look at all values for ``KeyedJaggedTensor``
+print("Values: ", kjt.values())
+
+# Can convert ``KeyedJaggedTensor`` to dictionary representation
+print("to_dict: ", kjt.to_dict())
+
+# ``KeyedJaggedTensor`` string representation
+print(kjt)
+
+# Q2: What are the offsets for the ``KeyedJaggedTensor``?
+
+# Now we can run a forward pass on our ``EmbeddingBagCollection`` from before
+result = ebc(kjt)
+result
+
+# Result is a ``KeyedTensor``, which contains a list of the feature names and the embedding results
+print(result.keys())
+
+# The results shape is [2, 128], as batch size of 2. Reread previous section if you need a refresher on how the batch size is determined
+# 128 for dimension of embedding. If you look at where we initialized the ``EmbeddingBagCollection``, we have two tables "product" and "user" of dimension 64 each
+# meaning embeddings for both features are of size 64. 64 + 64 = 128
+print(result.values().shape)
+
+# Nice to_dict method to determine the embeddings that belong to each feature
+result_dict = result.to_dict()
+for key, embedding in result_dict.items():
+    print(key, embedding.shape)
+
+
+######################################################################
+# Congrats! You now understand TorchRec modules and data types.
+# Give yourself a pat on the back for making it this far. Next, we will
+# learn about distributed training and sharding.
+#
+
+
+######################################################################
+# Distributed Training and Sharding
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# Now that we have a grasp on TorchRec modules and data types, it's time
+# to take it to the next level.
+#
+# Remember, the main purpose of TorchRec is to provide primitives for
+# distributed embeddings. So far, we've only worked with embedding tables
+# on a single device. This has been possible given how small the embedding tables
+# have been, but in a production setting this isn't generally the case.
+# Embedding tables often get massive, where one table can't fit on a single
+# GPU, creating the requirement for multiple devices and a distributed
+# environment.
+#
+# In this section, we will explore setting up a distributed environment,
+# exactly how actual production training is done, and explore sharding
+# embedding tables, all with TorchRec.
+#
+# **This section will also only use 1 GPU, though it will be treated in a
+# distributed fashion. This is only a limitation for training, as training
+# has a process per GPU. Inference does not run into this requirement**
+#
+# In the example code below, we set up our PyTorch distributed environment.
+#
+# .. warning::
+#    If you are running this in Google Colab, you can only call this cell once,
+#    calling it again will cause an error as you can only initialize the process
+#    group once.
+
+import os
+
+import torch.distributed as dist
+
+# Set up environment variables for distributed training
+# RANK is which GPU we are on, default 0
+os.environ["RANK"] = "0"
+# How many devices in our "world", colab notebook can only handle 1 process
+os.environ["WORLD_SIZE"] = "1"
+# Localhost as we are training locally
+os.environ["MASTER_ADDR"] = "localhost"
+# Port for distributed training
+os.environ["MASTER_PORT"] = "29500"
+
+# nccl backend is for GPUs, gloo is for CPUs
+dist.init_process_group(backend="gloo")
+
+print(f"Distributed environment initialized: {dist}")
+
+
+######################################################################
+# Distributed Embeddings
+# ~~~~~~~~~~~~~~~~~~~~~~
+#
+# We have already worked with the main TorchRec module:
+# ``EmbeddingBagCollection``. We have examined how it works along with how
+# data is represented in TorchRec. However, we have not yet explored one
+# of the main parts of TorchRec, which is **distributed embeddings**.
+#
+# GPUs are the most popular choice for ML workloads by far today, as they
+# are able to do magnitudes more floating point operations/s
+# (`FLOPs <https://en.wikipedia.org/wiki/FLOPS>`__) than CPU. However,
+# GPUs come with the limitation of scarce fast memory (HBM which is
+# analogous to RAM for CPU), typically, ~10s of GBs.
+#
+# A RecSys model can contain embedding tables that far exceed the memory
+# limit for 1 GPU, hence the need for distribution of the embedding tables
+# across multiple GPUs, otherwise known as **model parallel**. On the
+# other hand, **data parallel** is where the entire model is replicated on
+# each GPU, which each GPU taking in a distinct batch of data for
+# training, syncing gradients on the backwards pass.
+#
+# Parts of the model that **require less compute but more memory
+# (embeddings) are distributed with model parallel** while parts that
+# **require more compute and less memory (dense layers, MLP, etc.) are
+# distributed with data parallel**.
+#
+# Sharding
+# ~~~~~~~~
+#
+# In order to distribute an embedding table, we split up the embedding
+# table into parts and place those parts onto different devices, also
+# known as “sharding”.
+#
+# There are many ways to shard embedding tables. The most common ways are:
+#
+# * Table-Wise: the table is placed entirely onto one device
+# * Column-Wise: columns of embedding tables are sharded
+# * Row-Wise: rows of embedding tables are sharded
+#
+# Sharded Modules
+# ~~~~~~~~~~~~~~~
+#
+# While all of this seems like a lot to deal with and implement, you're in
+# luck. **TorchRec provides all the primitives for easy distributed
+# training and inference**! In fact, TorchRec modules have two corresponding
+# classes for working with any TorchRec module in a distributed
+# environment:
+#
+# * **The module sharder**: This class exposes a ``shard`` API
+#   that handles sharding a TorchRec Module, producing a sharded module.
+#   * For ``EmbeddingBagCollection``, the sharder is `EmbeddingBagCollectionSharder `
+# * **Sharded module**: This class is a sharded variant of a TorchRec module.
+#   It has the same input/output as a the regular TorchRec module, but much
+#   more optimized and works in a distributed environment.
+#   * For ``EmbeddingBagCollection``, the sharded variant is `ShardedEmbeddingBagCollection`
+#
+# Every TorchRec module has an unsharded and sharded variant.
+#
+# * The unsharded version is meant to be prototyped and experimented with.
+# * The sharded version is meant to be used in a distributed environment for
+#   distributed training and inference.
+#
+# The sharded versions of TorchRec modules, for example
+# ``EmbeddingBagCollection``, will handle everything that is needed for Model
+# Parallelism, such as communication between GPUs for distributing
+# embeddings to the correct GPUs.
+#
+# Refresher of our ``EmbeddingBagCollection`` module
+ebc
+
+from torchrec.distributed.embeddingbag import EmbeddingBagCollectionSharder
+from torchrec.distributed.planner import EmbeddingShardingPlanner, Topology
+from torchrec.distributed.types import ShardingEnv
+
+# Corresponding sharder for ``EmbeddingBagCollection`` module
+sharder = EmbeddingBagCollectionSharder()
+
+# ``ProcessGroup`` from torch.distributed initialized 2 cells above
+pg = dist.GroupMember.WORLD
+assert pg is not None, "Process group is not initialized"
+
+print(f"Process Group: {pg}")
+
+
+######################################################################
+# Planner
+# ~~~~~~~
+#
+# Before we can show how sharding works, we must know about the
+# **planner**, which helps us determine the best sharding configuration.
+#
+# Given a number of embedding tables and a number of ranks, there are many
+# different sharding configurations that are possible. For example, given
+# 2 embedding tables and 2 GPUs, you can:
+#
+# * Place 1 table on each GPU
+# * Place both tables on a single GPU and no tables on the other
+# * Place certain rows and columns on each GPU
+#
+# Given all of these possibilities, we typically want a sharding
+# configuration that is optimal for performance.
+#
+# That is where the planner comes in. The planner is able to determine
+# given the number of embedding tables and the number of GPUs, what is the optimal
+# configuration. Turns out, this is incredibly difficult to do manually,
+# with tons of factors that engineers have to consider to ensure an
+# optimal sharding plan. Luckily, TorchRec provides an auto planner when
+# the planner is used.
+#
+# The TorchRec planner:
+#
+# * Assesses memory constraints of hardware
+# * Estimates compute based on memory fetches as embedding lookups
+# * Addresses data specific factors
+# * Considers other hardware specifics like bandwidth to generate an optimal sharding plan
+#
+# In order to take into consideration all these variables, The TorchRec
+# planner can take in `various amounts of data for embedding tables,
+# constraints, hardware information, and
+# topology <https://github.com/pytorch/torchrec/blob/main/torchrec/distributed/planner/planners.py#L147-L155>`__
+# to aid in generating the optimal sharding plan for a model, which is
+# routinely provided across stacks.
+#
+# To learn more about sharding, see our `sharding
+# tutorial <https://pytorch.org/tutorials/advanced/sharding.html>`__.
+#
+
+# In our case, 1 GPU and compute on CUDA device
+planner = EmbeddingShardingPlanner(
+    topology=Topology(
+        world_size=1,
+        compute_device="cuda",
+    )
+)
+
+# Run planner to get plan for sharding
+plan = planner.collective_plan(ebc, [sharder], pg)
+
+print(f"Sharding Plan generated: {plan}")
+
+
+######################################################################
+# Planner Result
+# ~~~~~~~~~~~~~~
+#
+# As you can see above, when running the planner there is quite a bit of output.
+# We can see a lot of stats being calculated along with where our
+# tables end up being placed.
+#
+# The result of running the planner is a static plan, which can be reused
+# for sharding! This allows sharding to be static for production models
+# instead of determining a new sharding plan everytime. Below, we use the
+# sharding plan to finally generate our ``ShardedEmbeddingBagCollection``.
+#
+
+# The static plan that was generated
+plan
+
+env = ShardingEnv.from_process_group(pg)
+
+# Shard the ``EmbeddingBagCollection`` module using the ``EmbeddingBagCollectionSharder``
+sharded_ebc = sharder.shard(ebc, plan.plan[""], env, torch.device("cuda"))
+
+print(f"Sharded EBC Module: {sharded_ebc}")
+
+
+######################################################################
+# GPU Training with ``LazyAwaitable``
+# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#
+# Remember that TorchRec is a highly optimized library for distributed
+# embeddings. A concept that TorchRec introduces to enable higher
+# performance for training on GPU is a
+# `LazyAwaitable `.
+# You will see ``LazyAwaitable`` types as outputs of various sharded
+# TorchRec modules. All a ``LazyAwaitable`` type does is delay calculating some
+# result as long as possible, and it does it by acting like an async type.
+#
+
+from typing import List
+
+from torchrec.distributed.types import LazyAwaitable
+
+
+# Demonstrate a ``LazyAwaitable`` type:
+class ExampleAwaitable(LazyAwaitable[torch.Tensor]):
+    def __init__(self, size: List[int]) -> None:
+        super().__init__()
+        self._size = size
+
+    def _wait_impl(self) -> torch.Tensor:
+        return torch.ones(self._size)
+
+
+awaitable = ExampleAwaitable([3, 2])
+awaitable.wait()
+
+kjt = kjt.to("cuda")
+output = sharded_ebc(kjt)
+# The output of our sharded ``EmbeddingBagCollection`` module is an `Awaitable`?
+print(output)
+
+kt = output.wait()
+# Now we have our ``KeyedTensor`` after calling ``.wait()``
+# If you are confused as to why we have a ``KeyedTensor ``output,
+# give yourself a refresher on the unsharded ``EmbeddingBagCollection`` module
+print(type(kt))
+
+print(kt.keys())
+
+print(kt.values().shape)
+
+# Same output format as unsharded ``EmbeddingBagCollection``
+result_dict = kt.to_dict()
+for key, embedding in result_dict.items():
+    print(key, embedding.shape)
+
+
+######################################################################
+# Anatomy of Sharded TorchRec modules
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# We have now successfully sharded an ``EmbeddingBagCollection`` given a
+# sharding plan that we generated! The sharded module has common APIs from
+# TorchRec which abstract away distributed communication/compute amongst
+# multiple GPUs. In fact, these APIs are highly optimized for performance
+# in training and inference. **Below are the three common APIs for
+# distributed training/inference** that are provided by TorchRec:
+#
+# * ``input_dist``: Handles distributing inputs from GPU to GPU.
+# * ``lookups``: Does the actual embedding lookup in an optimized,
+#   batched manner using FBGEMM TBE (more on this later).
+# * ``output_dist``: Handles distributing outputs from GPU to GPU.
+#
+# The distribution of inputs and outputs is done through `NCCL
+# Collectives <https://docs.nvidia.com/deeplearning/nccl/user-guide/docs/overview.html>`__,
+# namely
+# `All-to-Alls <https://docs.nvidia.com/deeplearning/nccl/user-guide/docs/usage/p2p.html#all-to-all>`__,
+# which is where all GPUs send and receive data to and from one another.
+# TorchRec interfaces with PyTorch distributed for collectives and
+# provides clean abstractions to the end users, removing the concern for
+# the lower level details.
+#
+# The backwards pass does all of these collectives but in the reverse
+# order for distribution of gradients. ``input_dist``, ``lookup``, and
+# ``output_dist`` all depend on the sharding scheme. Since we sharded in a
+# table-wise fashion, these APIs are modules that are constructed by
+# `TwPooledEmbeddingSharding`.
+#
+
+sharded_ebc
+
+# Distribute input KJTs to all other GPUs and receive KJTs
+sharded_ebc._input_dists
+
+# Distribute output embeddings to all other GPUs and receive embeddings
+sharded_ebc._output_dists
+
+
+######################################################################
+# Optimizing Embedding Lookups
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# In performing lookups for a collection of embedding tables, a trivial
+# solution would be to iterate through all the ``nn.EmbeddingBags`` and do
+# a lookup per table. This is exactly what the standard, unsharded
+# ``EmbeddingBagCollection`` does. However, while this solution
+# is simple, it is extremely slow.
+#
+# `FBGEMM <https://github.com/pytorch/FBGEMM/tree/main/fbgemm_gpu>`__ is a
+# library that provides GPU operators (otherwise known as kernels) that
+# are very optimized. One of these operators is known as **Table Batched
+# Embedding** (TBE), provides two major optimizations:
+#
+# -  Table batching, which allows you to look up multiple embeddings with
+#    one kernel call.
+# -  Optimizer Fusion, which allows the module to update itself given the
+#    canonical pytorch optimizers and arguments.
+#
+# The ``ShardedEmbeddingBagCollection`` uses the FBGEMM TBE as the lookup
+# instead of traditional ``nn.EmbeddingBags`` for optimized embedding
+# lookups.
+#
+
+sharded_ebc._lookups
+
+
+######################################################################
+# ``DistributedModelParallel``
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# We have now explored sharding a single ``EmbeddingBagCollection``! We were
+# able to take the ``EmbeddingBagCollectionSharder`` and use the unsharded
+# ``EmbeddingBagCollection`` to generate a
+# ``ShardedEmbeddingBagCollection`` module. This workflow is fine, but
+# typically when implementing model parallel,
+# `DistributedModelParallel`
+# (DMP) is used as the standard interface. When wrapping your model (in
+# our case ``ebc``), with DMP, the following will occur:
+#
+# 1. Decide how to shard the model. DMP will collect the available
+#    sharders and come up with a plan of the optimal way to shard the
+#    embedding table(s) (for example, ``EmbeddingBagCollection``)
+# 2. Actually shard the model. This includes allocating memory for each
+#    embedding table on the appropriate device(s).
+#
+# DMP takes in everything that we've just experimented with, like a static
+# sharding plan, a list of sharders, etc. However, it also has some nice
+# defaults to seamlessly shard a TorchRec model. In this toy example,
+# since we have two embedding tables and one GPU, TorchRec will place both
+# on the single GPU.
+#
+
+ebc
+
+model = torchrec.distributed.DistributedModelParallel(ebc, device=torch.device("cuda"))
+
+out = model(kjt)
+out.wait()
+
+model
+
+
+from fbgemm_gpu.split_embedding_configs import EmbOptimType
+
+######################################################################
+# Sharding Best Practices
+# ~~~~~~~~~~~~~~~~~~~~~~~
+#
+# Currently, our configuration is only sharding on 1 GPU (or rank), which
+# is trivial: just place all the tables on 1 GPUs memory. However, in real
+# production use cases, embedding tables are **typically sharded on
+# hundreds of GPUs**, with different sharding methods such as table-wise,
+# row-wise, and column-wise. It is incredibly important to determine a
+# proper sharding configuration (to prevent out of memory issues) while
+# keeping it balanced not only in terms of memory but also compute for
+# optimal performance.
+#
+
+
+######################################################################
+# Adding in the Optimizer
+# ~~~~~~~~~~~~~~~~~~~~~~~
+#
+# Remember that TorchRec modules are hyperoptimized for large scale
+# distributed training. An important optimization is in regards to the
+# optimizer.
+#
+# TorchRec modules provide a seamless API to fuse the
+# backwards pass and optimize step in training, providing a significant
+# optimization in performance and decreasing the memory used, alongside
+# granularity in assigning distinct optimizers to distinct model
+# parameters.
+#
+# Optimizer Classes
+# ^^^^^^^^^^^^^^^^^
+#
+# TorchRec uses ``CombinedOptimizer``, which contains a collection of
+# ``KeyedOptimizers``. A ``CombinedOptimizer`` effectively makes it easy
+# to handle multiple optimizers for various sub groups in the model. A
+# ``KeyedOptimizer`` extends the ``torch.optim.Optimizer`` and is
+# initialized through a dictionary of parameters exposes the parameters.
+# Each ``TBE`` module in a ``EmbeddingBagCollection`` will have it's own
+# ``KeyedOptimizer`` which combines into one ``CombinedOptimizer``.
+#
+# Fused optimizer in TorchRec
+# ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#
+# Using ``DistributedModelParallel``, the **optimizer is fused, which
+# means that the optimizer update is done in the backward**. This is an
+# optimization in TorchRec and FBGEMM, where the optimizer embedding
+# gradients are not materialized and applied directly to the parameters.
+# This brings significant memory savings as embedding gradients are
+# typically size of the parameters themselves.
+#
+# You can, however, choose to make the optimizer ``dense`` which does not
+# apply this optimization and let's you inspect the embedding gradients or
+# apply computations to it as you wish. A dense optimizer in this case
+# would be your `canonical PyTorch model training loop with
+# optimizer. <https://pytorch.org/tutorials/beginner/basics/optimization_tutorial.html>`__
+#
+# Once the optimizer is created through ``DistributedModelParallel``, you
+# still need to manage an optimizer for the other parameters not
+# associated with TorchRec embedding modules. To find the other
+# parameters,
+# use ``in_backward_optimizer_filter(model.named_parameters())``.
+# Apply an optimizer to those parameters as you would a normal Torch
+# optimizer and combine this and the ``model.fused_optimizer`` into one
+# ``CombinedOptimizer`` that you can use in your training loop to
+# ``zero_grad`` and ``step`` through.
+#
+# Adding an Optimizer to ``EmbeddingBagCollection``
+# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#
+# We will do this in two ways, which are equivalent, but give you options
+# depending on your preferences:
+#
+# 1. Passing optimizer kwargs through ``fused_params`` in sharder.
+# 2. Through ``apply_optimizer_in_backward``, which converts the optimizer
+#    parameters to ``fused_params`` to pass to the ``TBE`` in the ``EmbeddingBagCollection`` or ``EmbeddingCollection``.
+#
+
+# Option 1: Passing optimizer kwargs through fused parameters
+from torchrec.optim.optimizers import in_backward_optimizer_filter
+
+
+# We initialize the sharder with
+fused_params = {
+    "optimizer": EmbOptimType.EXACT_ROWWISE_ADAGRAD,
+    "learning_rate": 0.02,
+    "eps": 0.002,
+}
+
+# Initialize sharder with ``fused_params``
+sharder_with_fused_params = EmbeddingBagCollectionSharder(fused_params=fused_params)
+
+# We'll use same plan and unsharded EBC as before but this time with our new sharder
+sharded_ebc_fused_params = sharder_with_fused_params.shard(
+    ebc, plan.plan[""], env, torch.device("cuda")
+)
+
+# Looking at the optimizer of each, we can see that the learning rate changed, which indicates our optimizer has been applied correctly.
+# If seen, we can also look at the TBE logs of the cell to see that our new optimizer is indeed being applied
+print(f"Original Sharded EBC fused optimizer: {sharded_ebc.fused_optimizer}")
+print(
+    f"Sharded EBC with fused parameters fused optimizer: {sharded_ebc_fused_params.fused_optimizer}"
+)
+
+print(f"Type of optimizer: {type(sharded_ebc_fused_params.fused_optimizer)}")
+
+import copy
+
+from torch.distributed.optim import (
+    _apply_optimizer_in_backward as apply_optimizer_in_backward,
+)
+
+# Option 2: Applying optimizer through apply_optimizer_in_backward
+# Note: we need to call apply_optimizer_in_backward on unsharded model first and then shard it
+
+# We can achieve the same result as we did in the previous
+ebc_apply_opt = copy.deepcopy(ebc)
+optimizer_kwargs = {"lr": 0.5}
+
+for name, param in ebc_apply_opt.named_parameters():
+    print(f"{name=}")
+    apply_optimizer_in_backward(torch.optim.SGD, [param], optimizer_kwargs)
+
+sharded_ebc_apply_opt = sharder.shard(
+    ebc_apply_opt, plan.plan[""], env, torch.device("cuda")
+)
+
+# Now when we print the optimizer, we will see our new learning rate, you can verify momentum through the TBE logs as well if outputted
+print(sharded_ebc_apply_opt.fused_optimizer)
+print(type(sharded_ebc_apply_opt.fused_optimizer))
+
+# We can also check through the filter other parameters that aren't associated with the "fused" optimizer(s)
+# Practically, just non TorchRec module parameters. Since our module is just a TorchRec EBC
+# there are no other parameters that aren't associated with TorchRec
+print("Non Fused Model Parameters:")
+print(
+    dict(
+        in_backward_optimizer_filter(sharded_ebc_fused_params.named_parameters())
+    ).keys()
+)
+
+# Here we do a dummy backwards call and see that parameter updates for fused
+# optimizers happen as a result of the backward pass
+
+ebc_output = sharded_ebc_fused_params(kjt).wait().values()
+loss = torch.sum(torch.ones_like(ebc_output) - ebc_output)
+print(f"First Iteration Loss: {loss}")
+
+loss.backward()
+
+ebc_output = sharded_ebc_fused_params(kjt).wait().values()
+loss = torch.sum(torch.ones_like(ebc_output) - ebc_output)
+# We don't call an optimizer.step(), so for the loss to have changed here,
+# that means that the gradients were somehow updated, which is what the
+# fused optimizer automatically handles for us
+print(f"Second Iteration Loss: {loss}")
+
+
+######################################################################
+# Conclusion
+# ^^^^^^^^^^
+# In this tutorial, you have done training a distributed RecSys model
+# If you are interested in the inference the `TorchRec repo
+# <https://github.com/pytorch/torchrec/tree/main/torchrec/inference>`__ has a
+# full example of how to run the TorchRec in Inference mode.
+#
+
+
+######################################################################
+# See Also
+# --------------
+#
+# For more information, please see our
+# `dlrm <https://github.com/facebookresearch/dlrm/tree/main/torchrec_dlrm/>`__
+# example, which includes multinode training on the Criteo 1TB
+# dataset using the methods described in `Deep Learning Recommendation Model
+# for Personalization and Recommendation Systems <https://arxiv.org/abs/1906.00091>`__.
+#
diff --git a/intermediate_source/torchrec_tutorial.rst b/intermediate_source/torchrec_tutorial.rst
new file mode 100644
index 00000000000..883ca11087a
--- /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/intermediate_source/torchvision_tutorial.py b/intermediate_source/torchvision_tutorial.py
new file mode 100644
index 00000000000..a19d3930436
--- /dev/null
+++ b/intermediate_source/torchvision_tutorial.py
@@ -0,0 +1,534 @@
+# -*- coding: utf-8 -*-
+"""
+TorchVision Object Detection Finetuning Tutorial
+====================================================
+"""
+
+######################################################################
+#
+# For this tutorial, we will be finetuning a pre-trained `Mask
+# R-CNN <https://arxiv.org/abs/1703.06870>`_ model on the `Penn-Fudan
+# Database for Pedestrian Detection and
+# Segmentation <https://www.cis.upenn.edu/~jshi/ped_html/>`_. It contains
+# 170 images with 345 instances of pedestrians, and we will use it to
+# illustrate how to use the new features in torchvision in order to train
+# an object detection and instance segmentation model on a custom dataset.
+#
+#
+# .. note ::
+#
+#     This tutorial works only with torchvision version >=0.16 or nightly.
+#     If you're using torchvision<=0.15, please follow
+#     `this tutorial instead <https://github.com/pytorch/tutorials/blob/d686b662932a380a58b7683425faa00c06bcf502/intermediate_source/torchvision_tutorial.rst>`_.
+#
+#
+# Defining the Dataset
+# --------------------
+#
+# The reference scripts for training object detection, instance
+# segmentation and person keypoint detection allows for easily supporting
+# adding new custom datasets. The dataset should inherit from the standard
+# :class:`torch.utils.data.Dataset` class, and implement ``__len__`` and
+# ``__getitem__``.
+#
+# The only specificity that we require is that the dataset ``__getitem__``
+# should return a tuple:
+#
+# -  image: :class:`torchvision.tv_tensors.Image` of shape ``[3, H, W]``, a pure tensor, or a PIL Image of size ``(H, W)``
+# -  target: a dict containing the following fields
+#
+#    -  ``boxes``, :class:`torchvision.tv_tensors.BoundingBoxes` of shape ``[N, 4]``:
+#       the coordinates of the ``N`` bounding boxes in ``[x0, y0, x1, y1]`` format, ranging from ``0``
+#       to ``W`` and ``0`` to ``H``
+#    -  ``labels``, integer :class:`torch.Tensor` of shape ``[N]``: the label for each bounding box.
+#       ``0`` represents always the background class.
+#    -  ``image_id``, int: an image identifier. It should be
+#       unique between all the images in the dataset, and is used during
+#       evaluation
+#    -  ``area``, float :class:`torch.Tensor` of shape ``[N]``: the area of the bounding box. This is used
+#       during evaluation with the COCO metric, to separate the metric
+#       scores between small, medium and large boxes.
+#    -  ``iscrowd``, uint8 :class:`torch.Tensor` of shape ``[N]``: instances with ``iscrowd=True`` will be
+#       ignored during evaluation.
+#    -  (optionally) ``masks``, :class:`torchvision.tv_tensors.Mask` of shape ``[N, H, W]``: the segmentation
+#       masks for each one of the objects
+#
+# If your dataset is compliant with above requirements then it will work for both
+# training and evaluation codes from the reference script. Evaluation code will use scripts from
+# ``pycocotools`` which can be installed with ``pip install pycocotools``.
+#
+# .. note ::
+#   For Windows, please install ``pycocotools`` from `gautamchitnis <https://github.com/gautamchitnis/cocoapi>`_ with command
+#
+#   ``pip install git+https://github.com/gautamchitnis/cocoapi.git@cocodataset-master#subdirectory=PythonAPI``
+#
+# One note on the ``labels``. The model considers class ``0`` as background. If your dataset does not contain the background class,
+# you should not have ``0`` in your ``labels``. For example, assuming you have just two classes, *cat* and *dog*, you can
+# define ``1`` (not ``0``) to represent *cats* and ``2`` to represent *dogs*. So, for instance, if one of the images has both
+# classes, your ``labels`` tensor should look like ``[1, 2]``.
+#
+# Additionally, if you want to use aspect ratio grouping during training
+# (so that each batch only contains images with similar aspect ratios),
+# then it is recommended to also implement a ``get_height_and_width``
+# method, which returns the height and the width of the image. If this
+# method is not provided, we query all elements of the dataset via
+# ``__getitem__`` , which loads the image in memory and is slower than if
+# a custom method is provided.
+#
+# Writing a custom dataset for PennFudan
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# Let’s write a dataset for the PennFudan dataset. First, let's download the dataset and
+# extract the `zip file <https://www.cis.upenn.edu/~jshi/ped_html/PennFudanPed.zip>`_:
+#
+# .. code:: python
+#
+#     wget https://www.cis.upenn.edu/~jshi/ped_html/PennFudanPed.zip -P data
+#     cd data && unzip PennFudanPed.zip
+#
+#
+# We have the following folder structure:
+#
+# ::
+#
+#    PennFudanPed/
+#      PedMasks/
+#        FudanPed00001_mask.png
+#        FudanPed00002_mask.png
+#        FudanPed00003_mask.png
+#        FudanPed00004_mask.png
+#        ...
+#      PNGImages/
+#        FudanPed00001.png
+#        FudanPed00002.png
+#        FudanPed00003.png
+#        FudanPed00004.png
+#
+# Here is one example of a pair of images and segmentation masks
+
+import matplotlib.pyplot as plt
+from torchvision.io import read_image
+
+
+image = read_image("data/PennFudanPed/PNGImages/FudanPed00046.png")
+mask = read_image("data/PennFudanPed/PedMasks/FudanPed00046_mask.png")
+
+plt.figure(figsize=(16, 8))
+plt.subplot(121)
+plt.title("Image")
+plt.imshow(image.permute(1, 2, 0))
+plt.subplot(122)
+plt.title("Mask")
+plt.imshow(mask.permute(1, 2, 0))
+
+######################################################################
+# So each image has a corresponding
+# segmentation mask, where each color correspond to a different instance.
+# Let’s write a :class:`torch.utils.data.Dataset` class for this dataset.
+# In the code below, we are wrapping images, bounding boxes and masks into
+# :class:`torchvision.tv_tensors.TVTensor` classes so that we will be able to apply torchvision
+# built-in transformations (`new Transforms API <https://pytorch.org/vision/stable/transforms.html>`_)
+# for the given object detection and segmentation task.
+# Namely, image tensors will be wrapped by :class:`torchvision.tv_tensors.Image`, bounding boxes into
+# :class:`torchvision.tv_tensors.BoundingBoxes` and masks into :class:`torchvision.tv_tensors.Mask`.
+# As :class:`torchvision.tv_tensors.TVTensor` are :class:`torch.Tensor` subclasses, wrapped objects are also tensors and inherit the plain
+# :class:`torch.Tensor` API. For more information about torchvision ``tv_tensors`` see
+# `this documentation <https://pytorch.org/vision/main/auto_examples/transforms/plot_transforms_getting_started.html#what-are-tvtensors>`_.
+
+import os
+import torch
+
+from torchvision.io import read_image
+from torchvision.ops.boxes import masks_to_boxes
+from torchvision import tv_tensors
+from torchvision.transforms.v2 import functional as F
+
+
+class PennFudanDataset(torch.utils.data.Dataset):
+    def __init__(self, root, transforms):
+        self.root = root
+        self.transforms = transforms
+        # load all image files, sorting them to
+        # ensure that they are aligned
+        self.imgs = list(sorted(os.listdir(os.path.join(root, "PNGImages"))))
+        self.masks = list(sorted(os.listdir(os.path.join(root, "PedMasks"))))
+
+    def __getitem__(self, idx):
+        # load images and masks
+        img_path = os.path.join(self.root, "PNGImages", self.imgs[idx])
+        mask_path = os.path.join(self.root, "PedMasks", self.masks[idx])
+        img = read_image(img_path)
+        mask = read_image(mask_path)
+        # instances are encoded as different colors
+        obj_ids = torch.unique(mask)
+        # first id is the background, so remove it
+        obj_ids = obj_ids[1:]
+        num_objs = len(obj_ids)
+
+        # split the color-encoded mask into a set
+        # of binary masks
+        masks = (mask == obj_ids[:, None, None]).to(dtype=torch.uint8)
+
+        # get bounding box coordinates for each mask
+        boxes = masks_to_boxes(masks)
+
+        # there is only one class
+        labels = torch.ones((num_objs,), dtype=torch.int64)
+
+        image_id = idx
+        area = (boxes[:, 3] - boxes[:, 1]) * (boxes[:, 2] - boxes[:, 0])
+        # suppose all instances are not crowd
+        iscrowd = torch.zeros((num_objs,), dtype=torch.int64)
+
+        # Wrap sample and targets into torchvision tv_tensors:
+        img = tv_tensors.Image(img)
+
+        target = {}
+        target["boxes"] = tv_tensors.BoundingBoxes(boxes, format="XYXY", canvas_size=F.get_size(img))
+        target["masks"] = tv_tensors.Mask(masks)
+        target["labels"] = labels
+        target["image_id"] = image_id
+        target["area"] = area
+        target["iscrowd"] = iscrowd
+
+        if self.transforms is not None:
+            img, target = self.transforms(img, target)
+
+        return img, target
+
+    def __len__(self):
+        return len(self.imgs)
+
+######################################################################
+# That’s all for the dataset. Now let’s define a model that can perform
+# predictions on this dataset.
+#
+# Defining your model
+# -------------------
+#
+# In this tutorial, we will be using `Mask
+# R-CNN <https://arxiv.org/abs/1703.06870>`_, which is based on top of
+# `Faster R-CNN <https://arxiv.org/abs/1506.01497>`_. Faster R-CNN is a
+# model that predicts both bounding boxes and class scores for potential
+# objects in the image.
+#
+# .. image:: ../../_static/img/tv_tutorial/tv_image03.png
+#
+# Mask R-CNN adds an extra branch
+# into Faster R-CNN, which also predicts segmentation masks for each
+# instance.
+#
+# .. image:: ../../_static/img/tv_tutorial/tv_image04.png
+#
+# There are two common
+# situations where one might want
+# to modify one of the available models in TorchVision Model Zoo. The first
+# is when we want to start from a pre-trained model, and just finetune the
+# last layer. The other is when we want to replace the backbone of the
+# model with a different one (for faster predictions, for example).
+#
+# Let’s go see how we would do one or another in the following sections.
+#
+# 1 - Finetuning from a pretrained model
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# Let’s suppose that you want to start from a model pre-trained on COCO
+# and want to finetune it for your particular classes. Here is a possible
+# way of doing it:
+
+
+import torchvision
+from torchvision.models.detection.faster_rcnn import FastRCNNPredictor
+
+# load a model pre-trained on COCO
+model = torchvision.models.detection.fasterrcnn_resnet50_fpn(weights="DEFAULT")
+
+# replace the classifier with a new one, that has
+# num_classes which is user-defined
+num_classes = 2  # 1 class (person) + background
+# get number of input features for the classifier
+in_features = model.roi_heads.box_predictor.cls_score.in_features
+# replace the pre-trained head with a new one
+model.roi_heads.box_predictor = FastRCNNPredictor(in_features, num_classes)
+
+######################################################################
+# 2 - Modifying the model to add a different backbone
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+
+import torchvision
+from torchvision.models.detection import FasterRCNN
+from torchvision.models.detection.rpn import AnchorGenerator
+
+# load a pre-trained model for classification and return
+# only the features
+backbone = torchvision.models.mobilenet_v2(weights="DEFAULT").features
+# ``FasterRCNN`` needs to know the number of
+# output channels in a backbone. For mobilenet_v2, it's 1280
+# so we need to add it here
+backbone.out_channels = 1280
+
+# let's make the RPN generate 5 x 3 anchors per spatial
+# location, with 5 different sizes and 3 different aspect
+# ratios. We have a Tuple[Tuple[int]] because each feature
+# map could potentially have different sizes and
+# aspect ratios
+anchor_generator = AnchorGenerator(
+    sizes=((32, 64, 128, 256, 512),),
+    aspect_ratios=((0.5, 1.0, 2.0),)
+)
+
+# let's define what are the feature maps that we will
+# use to perform the region of interest cropping, as well as
+# the size of the crop after rescaling.
+# if your backbone returns a Tensor, featmap_names is expected to
+# be [0]. More generally, the backbone should return an
+# ``OrderedDict[Tensor]``, and in ``featmap_names`` you can choose which
+# feature maps to use.
+roi_pooler = torchvision.ops.MultiScaleRoIAlign(
+    featmap_names=['0'],
+    output_size=7,
+    sampling_ratio=2
+)
+
+# put the pieces together inside a Faster-RCNN model
+model = FasterRCNN(
+    backbone,
+    num_classes=2,
+    rpn_anchor_generator=anchor_generator,
+    box_roi_pool=roi_pooler
+)
+
+######################################################################
+# Object detection and instance segmentation model for PennFudan Dataset
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# In our case, we want to finetune from a pre-trained model, given that
+# our dataset is very small, so we will be following approach number 1.
+#
+# Here we want to also compute the instance segmentation masks, so we will
+# be using Mask R-CNN:
+
+
+import torchvision
+from torchvision.models.detection.faster_rcnn import FastRCNNPredictor
+from torchvision.models.detection.mask_rcnn import MaskRCNNPredictor
+
+
+def get_model_instance_segmentation(num_classes):
+    # load an instance segmentation model pre-trained on COCO
+    model = torchvision.models.detection.maskrcnn_resnet50_fpn(weights="DEFAULT")
+
+    # get number of input features for the classifier
+    in_features = model.roi_heads.box_predictor.cls_score.in_features
+    # replace the pre-trained head with a new one
+    model.roi_heads.box_predictor = FastRCNNPredictor(in_features, num_classes)
+
+    # now get the number of input features for the mask classifier
+    in_features_mask = model.roi_heads.mask_predictor.conv5_mask.in_channels
+    hidden_layer = 256
+    # and replace the mask predictor with a new one
+    model.roi_heads.mask_predictor = MaskRCNNPredictor(
+        in_features_mask,
+        hidden_layer,
+        num_classes
+    )
+
+    return model
+
+
+######################################################################
+# That’s it, this will make ``model`` be ready to be trained and evaluated
+# on your custom dataset.
+#
+# Putting everything together
+# ---------------------------
+#
+# In ``references/detection/``, we have a number of helper functions to
+# simplify training and evaluating detection models. Here, we will use
+# ``references/detection/engine.py`` and ``references/detection/utils.py``.
+# Just download everything under ``references/detection`` to your folder and use them here.
+# On Linux if you have ``wget``, you can download them using below commands:
+
+os.system("wget https://raw.githubusercontent.com/pytorch/vision/main/references/detection/engine.py")
+os.system("wget https://raw.githubusercontent.com/pytorch/vision/main/references/detection/utils.py")
+os.system("wget https://raw.githubusercontent.com/pytorch/vision/main/references/detection/coco_utils.py")
+os.system("wget https://raw.githubusercontent.com/pytorch/vision/main/references/detection/coco_eval.py")
+os.system("wget https://raw.githubusercontent.com/pytorch/vision/main/references/detection/transforms.py")
+
+######################################################################
+# Since v0.15.0 torchvision provides `new Transforms API <https://pytorch.org/vision/stable/transforms.html>`_
+# to easily write data augmentation pipelines for Object Detection and Segmentation tasks.
+#
+# Let’s write some helper functions for data augmentation /
+# transformation:
+
+from torchvision.transforms import v2 as T
+
+
+def get_transform(train):
+    transforms = []
+    if train:
+        transforms.append(T.RandomHorizontalFlip(0.5))
+    transforms.append(T.ToDtype(torch.float, scale=True))
+    transforms.append(T.ToPureTensor())
+    return T.Compose(transforms)
+
+######################################################################
+# Testing ``forward()`` method (Optional)
+# ---------------------------------------
+#
+# Before iterating over the dataset, it's good to see what the model
+# expects during training and inference time on sample data.
+import utils
+
+model = torchvision.models.detection.fasterrcnn_resnet50_fpn(weights="DEFAULT")
+dataset = PennFudanDataset('data/PennFudanPed', get_transform(train=True))
+data_loader = torch.utils.data.DataLoader(
+    dataset,
+    batch_size=2,
+    shuffle=True,
+    collate_fn=utils.collate_fn
+)
+
+# For Training
+images, targets = next(iter(data_loader))
+images = list(image for image in images)
+targets = [{k: v for k, v in t.items()} for t in targets]
+output = model(images, targets)  # Returns losses and detections
+print(output)
+
+# For inference
+model.eval()
+x = [torch.rand(3, 300, 400), torch.rand(3, 500, 400)]
+predictions = model(x)  # Returns predictions
+print(predictions[0])
+
+
+######################################################################
+# We want to be able to train our model on an `accelerator <https://pytorch.org/docs/stable/torch.html#accelerators>`_
+# such as CUDA, MPS, MTIA, or XPU. Let’s now write the main function which performs the training and the validation:
+
+
+from engine import train_one_epoch, evaluate
+
+# train on the accelerator or on the CPU, if an accelerator is not available
+device = torch.accelerator.current_accelerator() if torch.accelerator.is_available() else torch.device('cpu')
+
+# our dataset has two classes only - background and person
+num_classes = 2
+# use our dataset and defined transformations
+dataset = PennFudanDataset('data/PennFudanPed', get_transform(train=True))
+dataset_test = PennFudanDataset('data/PennFudanPed', get_transform(train=False))
+
+# split the dataset in train and test set
+indices = torch.randperm(len(dataset)).tolist()
+dataset = torch.utils.data.Subset(dataset, indices[:-50])
+dataset_test = torch.utils.data.Subset(dataset_test, indices[-50:])
+
+# define training and validation data loaders
+data_loader = torch.utils.data.DataLoader(
+    dataset,
+    batch_size=2,
+    shuffle=True,
+    collate_fn=utils.collate_fn
+)
+
+data_loader_test = torch.utils.data.DataLoader(
+    dataset_test,
+    batch_size=1,
+    shuffle=False,
+    collate_fn=utils.collate_fn
+)
+
+# get the model using our helper function
+model = get_model_instance_segmentation(num_classes)
+
+# move model to the right device
+model.to(device)
+
+# construct an optimizer
+params = [p for p in model.parameters() if p.requires_grad]
+optimizer = torch.optim.SGD(
+    params,
+    lr=0.005,
+    momentum=0.9,
+    weight_decay=0.0005
+)
+
+# and a learning rate scheduler
+lr_scheduler = torch.optim.lr_scheduler.StepLR(
+    optimizer,
+    step_size=3,
+    gamma=0.1
+)
+
+# let's train it just for 2 epochs
+num_epochs = 2
+
+for epoch in range(num_epochs):
+    # train for one epoch, printing every 10 iterations
+    train_one_epoch(model, optimizer, data_loader, device, epoch, print_freq=10)
+    # update the learning rate
+    lr_scheduler.step()
+    # evaluate on the test dataset
+    evaluate(model, data_loader_test, device=device)
+
+print("That's it!")
+
+
+
+######################################################################
+# So after one epoch of training, we obtain a COCO-style mAP > 50, and
+# a mask mAP of 65.
+#
+# But what do the predictions look like? Let’s take one image in the
+# dataset and verify
+#
+import matplotlib.pyplot as plt
+
+from torchvision.utils import draw_bounding_boxes, draw_segmentation_masks
+
+
+image = read_image("data/PennFudanPed/PNGImages/FudanPed00046.png")
+eval_transform = get_transform(train=False)
+
+model.eval()
+with torch.no_grad():
+    x = eval_transform(image)
+    # convert RGBA -> RGB and move to device
+    x = x[:3, ...].to(device)
+    predictions = model([x, ])
+    pred = predictions[0]
+
+
+image = (255.0 * (image - image.min()) / (image.max() - image.min())).to(torch.uint8)
+image = image[:3, ...]
+pred_labels = [f"pedestrian: {score:.3f}" for label, score in zip(pred["labels"], pred["scores"])]
+pred_boxes = pred["boxes"].long()
+output_image = draw_bounding_boxes(image, pred_boxes, pred_labels, colors="red")
+
+masks = (pred["masks"] > 0.7).squeeze(1)
+output_image = draw_segmentation_masks(output_image, masks, alpha=0.5, colors="blue")
+
+
+plt.figure(figsize=(12, 12))
+plt.imshow(output_image.permute(1, 2, 0))
+
+######################################################################
+# The results look good!
+#
+# Wrapping up
+# -----------
+#
+# In this tutorial, you have learned how to create your own training
+# pipeline for object detection models on a custom dataset. For
+# that, you wrote a :class:`torch.utils.data.Dataset` class that returns the
+# images and the ground truth boxes and segmentation masks. You also
+# leveraged a Mask R-CNN model pre-trained on COCO train2017 in order to
+# perform transfer learning on this new dataset.
+#
+# For a more complete example, which includes multi-machine / multi-GPU
+# training, check ``references/detection/train.py``, which is present in
+# the torchvision repository.
+#
diff --git a/intermediate_source/torchvision_tutorial.rst b/intermediate_source/torchvision_tutorial.rst
deleted file mode 100644
index 0975f8dda1d..00000000000
--- a/intermediate_source/torchvision_tutorial.rst
+++ /dev/null
@@ -1,505 +0,0 @@
-TorchVision 0.3 Object Detection Finetuning Tutorial
-====================================================
-
-.. tip::
-   To get the most of this tutorial, we suggest using this 
-   `Colab Version <https://colab.research.google.com/github/pytorch/vision/blob/temp-tutorial/tutorials/torchvision_finetuning_instance_segmentation.ipynb>`__. 
-   This will allow you to experiment with the information presented below. 
-
-For this tutorial, we will be finetuning a pre-trained `Mask
-R-CNN <https://arxiv.org/abs/1703.06870>`__ model in the `Penn-Fudan
-Database for Pedestrian Detection and
-Segmentation <https://www.cis.upenn.edu/~jshi/ped_html/>`__. It contains
-170 images with 345 instances of pedestrians, and we will use it to
-illustrate how to use the new features in torchvision in order to train
-an instance segmentation model on a custom dataset.
-
-Defining the Dataset
---------------------
-
-The reference scripts for training object detection, instance
-segmentation and person keypoint detection allows for easily supporting
-adding new custom datasets. The dataset should inherit from the standard
-``torch.utils.data.Dataset`` class, and implement ``__len__`` and
-``__getitem__``.
-
-The only specificity that we require is that the dataset ``__getitem__``
-should return:
-
--  image: a PIL Image of size ``(H, W)``
--  target: a dict containing the following fields
-
-   -  ``boxes (FloatTensor[N, 4])``: the coordinates of the ``N``
-      bounding boxes in ``[x0, y0, x1, y1]`` format, ranging from ``0``
-      to ``W`` and ``0`` to ``H``
-   -  ``labels (Int64Tensor[N])``: the label for each bounding box
-   -  ``image_id (Int64Tensor[1])``: an image identifier. It should be
-      unique between all the images in the dataset, and is used during
-      evaluation
-   -  ``area (Tensor[N])``: The area of the bounding box. This is used
-      during evaluation with the COCO metric, to separate the metric
-      scores between small, medium and large boxes.
-   -  ``iscrowd (UInt8Tensor[N])``: instances with iscrowd=True will be
-      ignored during evaluation.
-   -  (optionally) ``masks (UInt8Tensor[N, H, W])``: The segmentation
-      masks for each one of the objects
-   -  (optionally) ``keypoints (FloatTensor[N, K, 3])``: For each one of
-      the N objects, it contains the K keypoints in
-      ``[x, y, visibility]`` format, defining the object. visibility=0
-      means that the keypoint is not visible. Note that for data
-      augmentation, the notion of flipping a keypoint is dependent on
-      the data representation, and you should probably adapt
-      ``references/detection/transforms.py`` for your new keypoint
-      representation
-
-If your model returns the above methods, they will make it work for both
-training and evaluation, and will use the evaluation scripts from
-``pycocotools``.
-
-Additionally, if you want to use aspect ratio grouping during training
-(so that each batch only contains images with similar aspect ratio),
-then it is recommended to also implement a ``get_height_and_width``
-method, which returns the height and the width of the image. If this
-method is not provided, we query all elements of the dataset via
-``__getitem__`` , which loads the image in memory and is slower than if
-a custom method is provided.
-
-Writing a custom dataset for PennFudan
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Let’s write a dataset for the PennFudan dataset. After `downloading and
-extracting the zip
-file <https://www.cis.upenn.edu/~jshi/ped_html/PennFudanPed.zip>`__, we
-have the following folder structure:
-
-::
-
-   PennFudanPed/
-     PedMasks/
-       FudanPed00001_mask.png
-       FudanPed00002_mask.png
-       FudanPed00003_mask.png
-       FudanPed00004_mask.png
-       ...
-     PNGImages/
-       FudanPed00001.png
-       FudanPed00002.png
-       FudanPed00003.png
-       FudanPed00004.png
-
-Here is one example of a pair of images and segmentation masks 
-
-.. image:: ../../_static/img/tv_tutorial/tv_image01.png
-
-.. image:: ../../_static/img/tv_tutorial/tv_image02.png
-
-So each image has a corresponding
-segmentation mask, where each color correspond to a different instance.
-Let’s write a ``torch.utils.data.Dataset`` class for this dataset.
-
-.. code:: python
-
-   import os
-   import numpy as np
-   import torch
-   from PIL import Image
-
-
-   class PennFudanDataset(object):
-       def __init__(self, root, transforms):
-           self.root = root
-           self.transforms = transforms
-           # load all image files, sorting them to
-           # ensure that they are aligned
-           self.imgs = list(sorted(os.listdir(os.path.join(root, "PNGImages"))))
-           self.masks = list(sorted(os.listdir(os.path.join(root, "PedMasks"))))
-
-       def __getitem__(self, idx):
-           # load images ad masks
-           img_path = os.path.join(self.root, "PNGImages", self.imgs[idx])
-           mask_path = os.path.join(self.root, "PedMasks", self.masks[idx])
-           img = Image.open(img_path).convert("RGB")
-           # note that we haven't converted the mask to RGB,
-           # because each color corresponds to a different instance
-           # with 0 being background
-           mask = Image.open(mask_path)
-           # convert the PIL Image into a numpy array
-           mask = np.array(mask)
-           # instances are encoded as different colors
-           obj_ids = np.unique(mask)
-           # first id is the background, so remove it
-           obj_ids = obj_ids[1:]
-
-           # split the color-encoded mask into a set
-           # of binary masks
-           masks = mask == obj_ids[:, None, None]
-
-           # get bounding box coordinates for each mask
-           num_objs = len(obj_ids)
-           boxes = []
-           for i in range(num_objs):
-               pos = np.where(masks[i])
-               xmin = np.min(pos[1])
-               xmax = np.max(pos[1])
-               ymin = np.min(pos[0])
-               ymax = np.max(pos[0])
-               boxes.append([xmin, ymin, xmax, ymax])
-               
-           # convert everything into a torch.Tensor
-           boxes = torch.as_tensor(boxes, dtype=torch.float32)
-           # there is only one class
-           labels = torch.ones((num_objs,), dtype=torch.int64)
-           masks = torch.as_tensor(masks, dtype=torch.uint8)
-
-           image_id = torch.tensor([idx])
-           area = (boxes[:, 3] - boxes[:, 1]) * (boxes[:, 2] - boxes[:, 0])
-           # suppose all instances are not crowd
-           iscrowd = torch.zeros((num_objs,), dtype=torch.int64)
-
-           target = {}
-           target["boxes"] = boxes
-           target["labels"] = labels
-           target["masks"] = masks
-           target["image_id"] = image_id
-           target["area"] = area
-           target["iscrowd"] = iscrowd
-
-           if self.transforms is not None:
-               img, target = self.transforms(img, target)
-
-           return img, target
-
-       def __len__(self):
-           return len(self.imgs)
-
-That’s all for the dataset. Now let’s define a model that can perform
-predictions on this dataset.
-
-Defining your model
--------------------
-
-In this tutorial, we will be using `Mask
-R-CNN <https://arxiv.org/abs/1703.06870>`__, which is based on top of
-`Faster R-CNN <https://arxiv.org/abs/1506.01497>`__. Faster R-CNN is a
-model that predicts both bounding boxes and class scores for potential
-objects in the image. 
-
-.. image:: ../../_static/img/tv_tutorial/tv_image03.png
-
-Mask R-CNN adds an extra branch
-into Faster R-CNN, which also predicts segmentation masks for each
-instance.
-
-.. image:: ../../_static/img/tv_tutorial/tv_image04.png
-
-There are two common 
-situations where one might want
-to modify one of the available models in torchvision modelzoo. The first
-is when we want to start from a pre-trained model, and just finetune the
-last layer. The other is when we want to replace the backbone of the
-model with a different one (for faster predictions, for example).
-
-Let’s go see how we would do one or another in the following sections.
-
-1 - Finetuning from a pretrained model
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Let’s suppose that you want to start from a model pre-trained on COCO
-and want to finetune it for your particular classes. Here is a possible
-way of doing it:
-
-.. code:: python
-
-   import torchvision
-   from torchvision.models.detection.faster_rcnn import FastRCNNPredictor
-
-   # load a model pre-trained pre-trained on COCO
-   model = torchvision.models.detection.fasterrcnn_resnet50_fpn(pretrained=True)
-
-   # replace the classifier with a new one, that has
-   # num_classes which is user-defined
-   num_classes = 2  # 1 class (person) + background
-   # get number of input features for the classifier
-   in_features = model.roi_heads.box_predictor.cls_score.in_features
-   # replace the pre-trained head with a new one
-   model.roi_heads.box_predictor = FastRCNNPredictor(in_features, num_classes) 
-
-2 - Modifying the model to add a different backbone
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. code:: python
-
-   import torchvision
-   from torchvision.models.detection import FasterRCNN
-   from torchvision.models.detection.rpn import AnchorGenerator
-
-   # load a pre-trained model for classification and return
-   # only the features
-   backbone = torchvision.models.mobilenet_v2(pretrained=True).features
-   # FasterRCNN needs to know the number of
-   # output channels in a backbone. For mobilenet_v2, it's 1280
-   # so we need to add it here
-   backbone.out_channels = 1280
-
-   # let's make the RPN generate 5 x 3 anchors per spatial
-   # location, with 5 different sizes and 3 different aspect
-   # ratios. We have a Tuple[Tuple[int]] because each feature
-   # map could potentially have different sizes and
-   # aspect ratios 
-   anchor_generator = AnchorGenerator(sizes=((32, 64, 128, 256, 512),),
-                                      aspect_ratios=((0.5, 1.0, 2.0),))
-
-   # let's define what are the feature maps that we will
-   # use to perform the region of interest cropping, as well as
-   # the size of the crop after rescaling.
-   # if your backbone returns a Tensor, featmap_names is expected to
-   # be [0]. More generally, the backbone should return an
-   # OrderedDict[Tensor], and in featmap_names you can choose which
-   # feature maps to use.
-   roi_pooler = torchvision.ops.MultiScaleRoIAlign(featmap_names=[0],
-                                                   output_size=7,
-                                                   sampling_ratio=2)
-
-   # put the pieces together inside a FasterRCNN model
-   model = FasterRCNN(backbone,
-                      num_classes=2,
-                      rpn_anchor_generator=anchor_generator,
-                      box_roi_pool=roi_pooler)
-
-An Instance segmentation model for PennFudan Dataset
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-In our case, we want to fine-tune from a pre-trained model, given that
-our dataset is very small, so we will be following approach number 1.
-
-Here we want to also compute the instance segmentation masks, so we will
-be using Mask R-CNN:
-
-.. code:: python
-
-   import torchvision
-   from torchvision.models.detection.faster_rcnn import FastRCNNPredictor
-   from torchvision.models.detection.mask_rcnn import MaskRCNNPredictor
-
-
-   def get_model_instance_segmentation(num_classes):
-       # load an instance segmentation model pre-trained pre-trained on COCO
-       model = torchvision.models.detection.maskrcnn_resnet50_fpn(pretrained=True)
-
-       # get number of input features for the classifier
-       in_features = model.roi_heads.box_predictor.cls_score.in_features
-       # replace the pre-trained head with a new one
-       model.roi_heads.box_predictor = FastRCNNPredictor(in_features, num_classes)
-
-       # now get the number of input features for the mask classifier
-       in_features_mask = model.roi_heads.mask_predictor.conv5_mask.in_channels
-       hidden_layer = 256
-       # and replace the mask predictor with a new one
-       model.roi_heads.mask_predictor = MaskRCNNPredictor(in_features_mask,
-                                                          hidden_layer,
-                                                          num_classes)
-
-       return model
-
-That’s it, this will make ``model`` be ready to be trained and evaluated
-on your custom dataset.
-
-Putting everything together
----------------------------
-
-In ``references/detection/``, we have a number of helper functions to
-simplify training and evaluating detection models. Here, we will use
-``references/detection/engine.py``, ``references/detection/utils.py``
-and ``references/detection/transforms.py``. Just copy them to your
-folder and use them here.
-
-Let’s write some helper functions for data augmentation /
-transformation:
-
-.. code:: python
-
-   import transforms as T
-
-   def get_transform(train):
-       transforms = []
-       transforms.append(T.ToTensor())
-       if train:
-           transforms.append(T.RandomHorizontalFlip(0.5))
-       return T.Compose(transforms)
-
-Let’s now write the main function which performs the training and the
-validation:
-
-.. code:: python
-
-   from engine import train_one_epoch, evaluate
-   import utils
-
-
-   def main():
-       # train on the GPU or on the CPU, if a GPU is not available
-       device = torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu')
-
-       # our dataset has two classes only - background and person
-       num_classes = 2
-       # use our dataset and defined transformations
-       dataset = PennFudanDataset('PennFudanPed', get_transform(train=True))
-       dataset_test = PennFudanDataset('PennFudanPed', get_transform(train=False))
-
-       # split the dataset in train and test set
-       indices = torch.randperm(len(dataset)).tolist()
-       dataset = torch.utils.data.Subset(dataset, indices[:-50])
-       dataset_test = torch.utils.data.Subset(dataset_test, indices[-50:])
-
-       # define training and validation data loaders
-       data_loader = torch.utils.data.DataLoader(
-           dataset, batch_size=2, shuffle=True, num_workers=4,
-           collate_fn=utils.collate_fn)
-
-       data_loader_test = torch.utils.data.DataLoader(
-           dataset_test, batch_size=1, shuffle=False, num_workers=4,
-           collate_fn=utils.collate_fn)
-
-       # get the model using our helper function
-       model = get_model_instance_segmentation(num_classes)
-
-       # move model to the right device
-       model.to(device)
-
-       # construct an optimizer
-       params = [p for p in model.parameters() if p.requires_grad]
-       optimizer = torch.optim.SGD(params, lr=0.005,
-                                   momentum=0.9, weight_decay=0.0005)
-       # and a learning rate scheduler
-       lr_scheduler = torch.optim.lr_scheduler.StepLR(optimizer,
-                                                      step_size=3,
-                                                      gamma=0.1)
-
-       # let's train it for 10 epochs
-       num_epochs = 10
-
-       for epoch in range(num_epochs):
-           # train for one epoch, printing every 10 iterations
-           train_one_epoch(model, optimizer, data_loader, device, epoch, print_freq=10)
-           # update the learning rate
-           lr_scheduler.step()
-           # evaluate on the test dataset
-           evaluate(model, data_loader_test, device=device)
-
-       print("That's it!")
-
-You should get as output for the first epoch:
-
-::
-
-   Epoch: [0]  [ 0/60]  eta: 0:01:18  lr: 0.000090  loss: 2.5213 (2.5213)  loss_classifier: 0.8025 (0.8025)  loss_box_reg: 0.2634 (0.2634)  loss_mask: 1.4265 (1.4265)  loss_objectness: 0.0190 (0.0190)  loss_rpn_box_reg: 0.0099 (0.0099)  time: 1.3121  data: 0.3024  max mem: 3485
-   Epoch: [0]  [10/60]  eta: 0:00:20  lr: 0.000936  loss: 1.3007 (1.5313)  loss_classifier: 0.3979 (0.4719)  loss_box_reg: 0.2454 (0.2272)  loss_mask: 0.6089 (0.7953)  loss_objectness: 0.0197 (0.0228)  loss_rpn_box_reg: 0.0121 (0.0141)  time: 0.4198  data: 0.0298  max mem: 5081
-   Epoch: [0]  [20/60]  eta: 0:00:15  lr: 0.001783  loss: 0.7567 (1.1056)  loss_classifier: 0.2221 (0.3319)  loss_box_reg: 0.2002 (0.2106)  loss_mask: 0.2904 (0.5332)  loss_objectness: 0.0146 (0.0176)  loss_rpn_box_reg: 0.0094 (0.0123)  time: 0.3293  data: 0.0035  max mem: 5081
-   Epoch: [0]  [30/60]  eta: 0:00:11  lr: 0.002629  loss: 0.4705 (0.8935)  loss_classifier: 0.0991 (0.2517)  loss_box_reg: 0.1578 (0.1957)  loss_mask: 0.1970 (0.4204)  loss_objectness: 0.0061 (0.0140)  loss_rpn_box_reg: 0.0075 (0.0118)  time: 0.3403  data: 0.0044  max mem: 5081
-   Epoch: [0]  [40/60]  eta: 0:00:07  lr: 0.003476  loss: 0.3901 (0.7568)  loss_classifier: 0.0648 (0.2022)  loss_box_reg: 0.1207 (0.1736)  loss_mask: 0.1705 (0.3585)  loss_objectness: 0.0018 (0.0113)  loss_rpn_box_reg: 0.0075 (0.0112)  time: 0.3407  data: 0.0044  max mem: 5081
-   Epoch: [0]  [50/60]  eta: 0:00:03  lr: 0.004323  loss: 0.3237 (0.6703)  loss_classifier: 0.0474 (0.1731)  loss_box_reg: 0.1109 (0.1561)  loss_mask: 0.1658 (0.3201)  loss_objectness: 0.0015 (0.0093)  loss_rpn_box_reg: 0.0093 (0.0116)  time: 0.3379  data: 0.0043  max mem: 5081
-   Epoch: [0]  [59/60]  eta: 0:00:00  lr: 0.005000  loss: 0.2540 (0.6082)  loss_classifier: 0.0309 (0.1526)  loss_box_reg: 0.0463 (0.1405)  loss_mask: 0.1568 (0.2945)  loss_objectness: 0.0012 (0.0083)  loss_rpn_box_reg: 0.0093 (0.0123)  time: 0.3489  data: 0.0042  max mem: 5081
-   Epoch: [0] Total time: 0:00:21 (0.3570 s / it)
-   creating index...
-   index created!
-   Test:  [ 0/50]  eta: 0:00:19  model_time: 0.2152 (0.2152)  evaluator_time: 0.0133 (0.0133)  time: 0.4000  data: 0.1701  max mem: 5081
-   Test:  [49/50]  eta: 0:00:00  model_time: 0.0628 (0.0687)  evaluator_time: 0.0039 (0.0064)  time: 0.0735  data: 0.0022  max mem: 5081
-   Test: Total time: 0:00:04 (0.0828 s / it)
-   Averaged stats: model_time: 0.0628 (0.0687)  evaluator_time: 0.0039 (0.0064)
-   Accumulating evaluation results...
-   DONE (t=0.01s).
-   Accumulating evaluation results...
-   DONE (t=0.01s).
-   IoU metric: bbox
-    Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.606
-    Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.984
-    Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.780
-    Average Precision  (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.313
-    Average Precision  (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.582
-    Average Precision  (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.612
-    Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] = 0.270
-    Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] = 0.672
-    Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.672
-    Average Recall     (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.650
-    Average Recall     (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.755
-    Average Recall     (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.664
-   IoU metric: segm
-    Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.704
-    Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.979
-    Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.871
-    Average Precision  (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.325
-    Average Precision  (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.488
-    Average Precision  (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.727
-    Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] = 0.316
-    Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] = 0.748
-    Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.749
-    Average Recall     (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.650
-    Average Recall     (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.673
-    Average Recall     (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.758
-
-So after one epoch of training, we obtain a COCO-style mAP of 60.6, and
-a mask mAP of 70.4.
-
-After training for 10 epochs, I got the following metrics
-
-::
-
-   IoU metric: bbox
-    Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.799
-    Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.969
-    Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.935
-    Average Precision  (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.349
-    Average Precision  (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.592
-    Average Precision  (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.831
-    Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] = 0.324
-    Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] = 0.844
-    Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.844
-    Average Recall     (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.400
-    Average Recall     (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.777
-    Average Recall     (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.870
-   IoU metric: segm
-    Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.761
-    Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.969
-    Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.919
-    Average Precision  (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.341
-    Average Precision  (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.464
-    Average Precision  (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.788
-    Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=  1 ] = 0.303
-    Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets= 10 ] = 0.799
-    Average Recall     (AR) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.799
-    Average Recall     (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.400
-    Average Recall     (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.769
-    Average Recall     (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.818
-
-But what do the predictions look like? Let’s take one image in the
-dataset and verify 
-
-.. image:: ../../_static/img/tv_tutorial/tv_image05.png
-
-The trained model predicts 9
-instances of person in this image, let’s see a couple of them: 
-
-.. image:: ../../_static/img/tv_tutorial/tv_image06.png
-
-.. image:: ../../_static/img/tv_tutorial/tv_image07.png
-
-The results look pretty good!
-
-Wrapping up
------------
-
-In this tutorial, you have learned how to create your own training
-pipeline for instance segmentation models, on a custom dataset. For
-that, you wrote a ``torch.utils.data.Dataset`` class that returns the
-images and the ground truth boxes and segmentation masks. You also
-leveraged a Mask R-CNN model pre-trained on COCO train2017 in order to
-perform transfer learning on this new dataset.
-
-For a more complete example, which includes multi-machine / multi-gpu
-training, check ``references/detection/train.py``, which is present in
-the torchvision repo.
-
-You can download a full source file for this tutorial 
-`here <https://pytorch.org/tutorials/_static/tv-training-code.py>`__. 
-   
-
diff --git a/intermediate_source/transformer_building_blocks.py b/intermediate_source/transformer_building_blocks.py
new file mode 100644
index 00000000000..decaf0602f7
--- /dev/null
+++ b/intermediate_source/transformer_building_blocks.py
@@ -0,0 +1,846 @@
+"""
+.. meta::
+  :description: Learn how to optimize transformer models by replacing nn.Transformer with Nested Tensors and torch.compile() for significant performance gains in PyTorch.
+
+Accelerating PyTorch Transformers by replacing ``nn.Transformer`` with Nested Tensors and ``torch.compile()``
+=============================================================================================================
+**Author:** `Mikayla Gawarecki <https://github.com/mikaylagawarecki>`_
+
+
+.. grid:: 2
+
+    .. grid-item-card:: :octicon:`mortar-board;1em;` What you will learn
+       :class-card: card-prerequisites
+
+       * Learn about the low-level building blocks PyTorch provides to build custom transformer layers (
+         nested tensors, ``scaled_dot_product_attention``, ``torch.compile()``, and ``FlexAttention``)
+       * Discover how the above improve memory usage and performance using MultiHeadAttention as an example
+       * Explore advanced customizations using the aforementioned building blocks
+    
+    .. grid-item-card:: :octicon:`list-unordered;1em;` Prerequisites
+       :class-card: card-prerequisites
+
+       * PyTorch v.2.6.0 or later
+
+
+Over the past few years, the PyTorch team has developed various lower level
+features that, when composed, can create a variety of transformer variants. These
+include:
+
+*   Nested Tensors with the ``torch.jagged`` layout (AKA NJTs)
+*   ``scaled_dot_product_attention``
+*   ``torch.compile()``
+*   ``FlexAttention``
+
+This tutorial will give a brief overview of the above technologies and
+demonstrate how they can be composed to yield flexible and performant transformer \
+layers with improved user experience.
+
+One may observe that the ``torch.nn`` module currently provides various ``Transformer``-related layers.
+In particular, it includes ``TransformerEncoderLayer``, ``TransformerEncoder``, ``TransformerDecoderLayer``,
+``TransformerDecoder``, ``Transformer`` and ``MultiheadAttention``. This family
+of layers was initially implemented following the `Attention is All
+You Need <https://arxiv.org/abs/1706.03762>`_ paper. The components discussed in
+this tutorial provide improved user experience, flexibility and performance over
+the existing ``nn`` layers.
+
+
+Is this tutorial for me?
+========================
+
+If you are wondering about what building blocks the ``torch`` library provides
+for writing your own transformer layers and best practices, you are in the
+right place. Please keep reading!
+
+If you are looking for an out-of-the-box implementation of a popular transformer
+architecture, note that there are many open-source libraries that provide them,
+including:
+
+* `HuggingFace transformers <https://github.com/huggingface/transformers>`_
+* `xformers <https://github.com/facebookresearch/xformers>`_
+* `torchtune <https://github.com/pytorch/torchtune>`_
+
+If you are only interested in performant attention score modifications, please
+check out the `FlexAttention blog <https://pytorch.org/blog/flexattention/>`_ that
+contains a `gym of masks <https://github.com/meta-pytorch/attention-gym>`_.
+
+"""
+
+################################################################################
+# Introducing the Building Blocks
+# ===============================
+# First, we will briefly introduce the four technologies mentioned in the introduction
+#
+# * `torch.nested <https://pytorch.org/tutorials/unstable/nestedtensor.html>`_
+#
+# Nested tensors generalize the shape of regular dense tensors, allowing for
+# representation of ragged-sized data with the same tensor UX. In the context of
+# transformers, we can think of nested tensors as a tool for representing variable
+# sequence lengths. They eliminate the need for the bug-prone practices of explicit
+# padding and masking (think ``key_padding_mask`` in ``nn.MultiHeadAttention``).
+#
+# * `scaled_dot_product_attention <https://pytorch.org/tutorials/intermediate/scaled_dot_product_attention_tutorial.html>`_
+#
+# ``scaled_dot_product_attention`` is a primitive for
+# :math:`\text{softmax}(\frac{QK^T}{\sqrt{E}} + B)V` that dispatches into either fused
+# implementations of the operator or a fallback implementation. It works out of
+# the box in eager mode (i.e. the default mode of using PyTorch where operations
+# are executed on the fly as they are encountered) and also integrates seamlessly
+# with ``torch.compile()``. As of 2.6, it will also offer grouped query attention
+# natively.
+#
+# * `torch.compile() <https://pytorch.org/tutorials/intermediate/torch_compile_tutorial.html>`_
+#
+# ``torch.compile()`` is a compiler introduced in version 2.0 that is able to
+# capture a graph of PyTorch code and perform various optimizations on it, such as
+# fusing together sequences of ops. Nested tensors with the ``torch.jagged`` layout
+# and ``scaled_dot_product_attention`` work seamlessly with compile. In the
+# context of transformers, the value add of using compile with nested tensor
+# and SDPA is that compile can remove framework overhead ones sees in eager mode
+# and fuse sequences of ops in transformers together, such as projection and
+# activation.
+#
+# * `FlexAttention <https://pytorch.org/blog/flexattention/>`_
+#
+# ``FlexAttention`` is a primitive that allows users to modify attention scores
+# prior to the softmax operation. It generalizes the additive ``B`` term above
+# for ``scaled_dot_product_attention``, allowing for arbitrary calculation. It
+# requires compile to achieve good performance.
+#
+# The above building blocks are "All You Need" (as of October 2024)
+# ==================================================================
+#
+# The main premise in this section is that most transformer variations are
+# GPT-style, consisting of layers like Embedding, Positional Encoding, Attention
+# Blocks and Feed Forward networks. If we were to try to classify the differences
+# in this space, we might land on something like:
+#
+# 1.   Layer type (activation functions such as ``SwiGLU`` and others, normalization functions
+#      such as ``RMSNorm`` and others, positional encodings, such as Sinusoidal, Rotary.)
+# 2.   Layer ordering, such as where to apply norms and positional encoding.
+# 3.   Modifications to attention score, such as ``ALiBi``, Relative Positional Bias and so on.
+#
+#
+# In a pre-compiler environment, you might write a custom transformer and notice
+# that it functions correctly but is slow. To address this, you might develop a
+# custom fused kernel for the specific series of operations. In a compiler environment,
+# you can simply perform the initial step and then compile and benefit from improved performance.
+
+
+###############################################################################
+# MultiheadAttention
+# ------------------
+# Remember that MultiheadAttention takes in a query, key, and value, and consists
+# of an input projection, a ``scaled_dot_product_attention`` operator and an
+# output projection. The main takeaway we want to demonstrate here is the
+# improvement yielded when we replaced padded/masked inputs with nested tensors.
+# The improvements are threefold:
+#
+# * **User Experience**
+#   Remember that ``nn.MultiheadAttention`` requires ``query``, ``key``, and
+#   ``value`` to be dense ``torch.Tensors``. It also provides a
+#   ``key_padding_mask`` that is used to mask out padding tokens in the ``key``
+#   that arise due to different sequence lengths within a batch. Since there is
+#   no ``query_padding_mask`` in ``nn.MHA``, users have to take care to mask/slice
+#   the outputs appropriately to account for query sequence lengths. ``NestedTensor``
+#   cleanly removes the need for this sort of error-prone padding masks.
+#
+# * **Memory**
+#   Instead of materializing a dense ``[B, S, D]`` tensor with a ``[B, S]``
+#   padding mask (where ``B`` is batch size, ``S`` is max sequence length in the
+#   batch and ``D`` is embedding size), nested tensors allow you to cleanly
+#   represent the batch of varying sequence lengths. As a result, the input and
+#   intermediate activations will use less memory.
+#
+# * **Performance**
+#   Since padding is not materialized and unnecessary computation on padding is
+#   skipped, performance and memory usage improve.
+#
+# We'll demonstrate the above by building upon the ``MultiheadAttention`` layer in the
+# `Nested Tensor tutorial <https://pytorch.org/tutorials/unstable/nestedtensor.html>`_
+# and comparing it to the ``nn.MultiheadAttention`` layer.
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class MultiHeadAttention(nn.Module):
+    """
+    Computes multi-head attention. Supports nested or padded tensors.
+
+    Args:
+        E_q (int): Size of embedding dim for query
+        E_k (int): Size of embedding dim for key
+        E_v (int): Size of embedding dim for value
+        E_total (int): Total embedding dim of combined heads post input projection. Each head
+            has dim E_total // nheads
+        nheads (int): Number of heads
+        dropout (float, optional): Dropout probability. Default: 0.0
+        bias (bool, optional): Whether to add bias to input projection. Default: True
+    """
+
+    def __init__(
+        self,
+        E_q: int,
+        E_k: int,
+        E_v: int,
+        E_total: int,
+        nheads: int,
+        dropout: float = 0.0,
+        bias=True,
+        device=None,
+        dtype=None,
+    ):
+        factory_kwargs = {"device": device, "dtype": dtype}
+        super().__init__()
+        self.nheads = nheads
+        self.dropout = dropout
+        self._qkv_same_embed_dim = E_q == E_k and E_q == E_v
+        if self._qkv_same_embed_dim:
+            self.packed_proj = nn.Linear(E_q, E_total * 3, bias=bias, **factory_kwargs)
+        else:
+            self.q_proj = nn.Linear(E_q, E_total, bias=bias, **factory_kwargs)
+            self.k_proj = nn.Linear(E_k, E_total, bias=bias, **factory_kwargs)
+            self.v_proj = nn.Linear(E_v, E_total, bias=bias, **factory_kwargs)
+        E_out = E_q
+        self.out_proj = nn.Linear(E_total, E_out, bias=bias, **factory_kwargs)
+        assert E_total % nheads == 0, "Embedding dim is not divisible by nheads"
+        self.E_head = E_total // nheads
+        self.bias = bias
+
+    def forward(
+        self,
+        query: torch.Tensor,
+        key: torch.Tensor,
+        value: torch.Tensor,
+        attn_mask=None,
+        is_causal=False,
+    ) -> torch.Tensor:
+        """
+        Forward pass; runs the following process:
+            1. Apply input projection
+            2. Split heads and prepare for SDPA
+            3. Run SDPA
+            4. Apply output projection
+
+        Args:
+            query (torch.Tensor): query of shape (``N``, ``L_q``, ``E_qk``)
+            key (torch.Tensor): key of shape (``N``, ``L_kv``, ``E_qk``)
+            value (torch.Tensor): value of shape (``N``, ``L_kv``, ``E_v``)
+            attn_mask (torch.Tensor, optional): attention mask of shape (``N``, ``L_q``, ``L_kv``) to pass to SDPA. Default: None
+            is_causal (bool, optional): Whether to apply causal mask. Default: False
+
+        Returns:
+            attn_output (torch.Tensor): output of shape (N, L_t, E_q)
+        """
+        # Step 1. Apply input projection
+        if self._qkv_same_embed_dim:
+            if query is key and key is value:
+                result = self.packed_proj(query)
+                query, key, value = torch.chunk(result, 3, dim=-1)
+            else:
+                q_weight, k_weight, v_weight = torch.chunk(
+                    self.packed_proj.weight, 3, dim=0
+                )
+                if self.bias:
+                    q_bias, k_bias, v_bias = torch.chunk(
+                        self.packed_proj.bias, 3, dim=0
+                    )
+                else:
+                    q_bias, k_bias, v_bias = None, None, None
+                query, key, value = (
+                    F.linear(query, q_weight, q_bias),
+                    F.linear(key, k_weight, k_bias),
+                    F.linear(value, v_weight, v_bias),
+                )
+
+        else:
+            query = self.q_proj(query)
+            key = self.k_proj(key)
+            value = self.v_proj(value)
+
+        # Step 2. Split heads and prepare for SDPA
+        # reshape query, key, value to separate by head
+        # (N, L_t, E_total) -> (N, L_t, nheads, E_head) -> (N, nheads, L_t, E_head)
+        query = query.unflatten(-1, [self.nheads, self.E_head]).transpose(1, 2)
+        # (N, L_s, E_total) -> (N, L_s, nheads, E_head) -> (N, nheads, L_s, E_head)
+        key = key.unflatten(-1, [self.nheads, self.E_head]).transpose(1, 2)
+        # (N, L_s, E_total) -> (N, L_s, nheads, E_head) -> (N, nheads, L_s, E_head)
+        value = value.unflatten(-1, [self.nheads, self.E_head]).transpose(1, 2)
+
+        # Step 3. Run SDPA
+        # (N, nheads, L_t, E_head)
+        attn_output = F.scaled_dot_product_attention(
+            query, key, value, dropout_p=self.dropout, is_causal=is_causal
+        )
+        # (N, nheads, L_t, E_head) -> (N, L_t, nheads, E_head) -> (N, L_t, E_total)
+        attn_output = attn_output.transpose(1, 2).flatten(-2)
+
+        # Step 4. Apply output projection
+        # (N, L_t, E_total) -> (N, L_t, E_out)
+        attn_output = self.out_proj(attn_output)
+
+        return attn_output
+
+
+###############################################################################
+# Utilities
+# ~~~~~~~~~
+# In this section, we include a utility to generate semi-realistic data using
+# ``Zipf`` distribution for sentence lengths. This is used to generate the nested
+# query, key, and value tensors. We also include a benchmark utility.
+
+
+import numpy as np
+
+
+def zipf_sentence_lengths(alpha: float, batch_size: int) -> torch.Tensor:
+    # generate fake corpus by unigram Zipf distribution
+    # from wikitext-2 corpus, we get rank "." = 3, "!" = 386, "?" = 858
+    sentence_lengths = np.empty(batch_size, dtype=int)
+    for ibatch in range(batch_size):
+        sentence_lengths[ibatch] = 1
+        word = np.random.zipf(alpha)
+        while word != 3 and word != 386 and word != 858:
+            sentence_lengths[ibatch] += 1
+            word = np.random.zipf(alpha)
+    return torch.tensor(sentence_lengths)
+
+
+# Generate a batch of semi-realistic data using Zipf distribution for sentence lengths
+# in the form of nested tensors with the jagged layout.
+def gen_batch(N, E_q, E_k, E_v, device, dtype=torch.float32, query_seq_len_1=False):
+    # generate semi-realistic data using Zipf distribution for sentence lengths
+    sentence_lengths = zipf_sentence_lengths(alpha=1.2, batch_size=N)
+
+    # Note: the torch.jagged layout is a nested tensor layout that supports a single ragged
+    # dimension and works with torch.compile. The batch items each have shape (B, S*, D)
+    # where B = batch size, S* = ragged sequence length, and D = embedding dimension.
+    if query_seq_len_1:
+        query = torch.nested.nested_tensor(
+            [torch.randn(1, E_q, dtype=dtype, device=device) for l in sentence_lengths],
+            layout=torch.jagged,
+        )
+    else:
+        query = torch.nested.nested_tensor(
+            [
+                torch.randn(l.item(), E_q, dtype=dtype, device=device)
+                for l in sentence_lengths
+            ],
+            layout=torch.jagged,
+        )
+
+    key = torch.nested.nested_tensor(
+        [
+            torch.randn(s.item(), E_k, dtype=dtype, device=device)
+            for s in sentence_lengths
+        ],
+        layout=torch.jagged,
+    )
+
+    value = torch.nested.nested_tensor(
+        [
+            torch.randn(s.item(), E_v, dtype=dtype, device=device)
+            for s in sentence_lengths
+        ],
+        layout=torch.jagged,
+    )
+
+    return query, key, value, sentence_lengths
+
+
+import math
+import timeit
+
+
+def benchmark(func, *args, **kwargs):
+    torch.cuda.synchronize()
+    torch.cuda.reset_peak_memory_stats()
+    begin = timeit.default_timer()
+    output = func(*args, **kwargs)
+    torch.cuda.synchronize()
+    end = timeit.default_timer()
+    return output, (end - begin), torch.cuda.max_memory_allocated()
+
+
+##############################################################################
+# We will now demonstrate the performance improvements of using nested tensors
+# in the ``MultiheadAttention`` layer + compile for self attention. We compare this against
+# the traditional ``nn.MultiheadAttention`` + compile with padding and masking.
+
+N, E_q, E_k, E_v, E_total = 512, 512, 512, 512, 512
+E_out = E_q
+d_model = E_q
+nheads = 8
+dropout = 0.0
+bias = True
+device = "cuda"
+torch.manual_seed(6)
+query, key, value, sentence_lengths = gen_batch(N, E_q, E_k, E_v, device)
+S = sentence_lengths.max().item()
+print(
+    f"Total sequence length in nested query {sentence_lengths.sum().item()}, max sequence length {S}"
+)
+padded_query, padded_key, padded_value = (
+    t.to_padded_tensor(0.0) for t in (query, key, value)
+)
+
+torch.manual_seed(6)
+mha_layer = MultiHeadAttention(
+    E_q, E_k, E_v, E_total, nheads, dropout=dropout, bias=bias, device="cuda"
+)
+torch.manual_seed(6)
+vanilla_mha_layer = nn.MultiheadAttention(
+    E_q, nheads, dropout=dropout, batch_first=True, bias=bias, device="cuda"
+)
+
+# ``nn.MultiheadAttention`` uses a non conventional initialization for layers, so do this for exact parity :(
+mha_layer.out_proj.weight = nn.Parameter(
+    vanilla_mha_layer.out_proj.weight.clone().detach()
+)
+mha_layer.packed_proj.weight = nn.Parameter(
+    vanilla_mha_layer.in_proj_weight.clone().detach()
+)
+mha_layer.out_proj.bias = nn.Parameter(vanilla_mha_layer.out_proj.bias.clone().detach())
+mha_layer.packed_proj.bias = nn.Parameter(
+    vanilla_mha_layer.in_proj_bias.clone().detach()
+)
+
+new_mha_layer = torch.compile(mha_layer)
+# warmup compile
+nested_result_warmup = new_mha_layer(query, query, query, is_causal=True)
+
+# benchmark
+nested_result, nested_time, nested_peak_memory = benchmark(
+    new_mha_layer, query, query, query, is_causal=True
+)
+padded_nested_result = nested_result.to_padded_tensor(0.0)
+
+# For the vanilla ``nn.MultiheadAttention``, we need to construct the ``key_padding_mask``
+# Further, ``nn.MultiheadAttention`` forces one to materialize the ``attn_mask`` even if using ``is_causal``
+src_key_padding_mask = torch.where(padded_query == 0.0, -math.inf, 0)[:, :, 0]
+attn_mask = torch.empty((N, S, S), device=device).fill_(float("-inf"))
+for i, s in enumerate(sentence_lengths):
+    attn_mask[i, :s, :s] = nn.Transformer.generate_square_subsequent_mask(s)
+attn_mask = attn_mask.unsqueeze(1).expand(N, nheads, S, S).reshape(N * nheads, S, S)
+
+vanilla_mha_layer = torch.compile(vanilla_mha_layer)
+# warmup compile
+warmup_vanilla_result = vanilla_mha_layer(
+    padded_query,
+    padded_query,
+    padded_query,
+    attn_mask=attn_mask,
+    key_padding_mask=src_key_padding_mask,
+    need_weights=False,
+    is_causal=True,
+)
+
+# benchmark
+(padded_result, _), padded_time, padded_peak_memory = benchmark(
+    vanilla_mha_layer,
+    padded_query,
+    padded_query,
+    padded_query,
+    key_padding_mask=src_key_padding_mask,
+    need_weights=False,
+    attn_mask=attn_mask,
+    is_causal=True,
+)
+
+print(f"{padded_time=:.5f}, padded_peak_memory={padded_peak_memory/1e9:.2f} GB")
+print(f"{nested_time=:.5f}, nested_peak_memory={nested_peak_memory/1e9:.2f} GB")
+print(
+    "Max difference between vanilla and nested result",
+    (padded_result - padded_nested_result).abs().max().item(),
+)
+print(f"Nested speedup: {(padded_time/nested_time):.2f}")
+print(
+    f"Nested peak memory reduction {((padded_peak_memory - nested_peak_memory)/1e9):.2f} GB"
+)
+
+######################################################################################
+# For reference, here are some sample outputs on A100:
+#
+# .. code::
+#
+#     padded_time=0.03454, padded_peak_memory=4.14 GB
+#     nested_time=0.00612, nested_peak_memory=0.76 GB
+#     Max difference between vanilla and nested result 0.0
+#     Nested speedup: 5.65
+#     Nested peak memory reduction 3.39 GB
+#
+# We can also see the same for backward pass
+
+for i, entry_length in enumerate(sentence_lengths):
+    # padding-specific step: remove output projection bias from padded entries for fair comparison
+    padded_result[i, entry_length:, :] = 0.0
+
+_, padded_bw_time, padded_bw_peak_mem = benchmark(
+    lambda: padded_result.sum().backward()
+)
+_, nested_bw_time, nested_bw_peak_mem = benchmark(
+    lambda: padded_nested_result.sum().backward()
+)
+
+print(f"{padded_bw_time=:.5f}, padded_bw_peak_mem={padded_bw_peak_mem/1e9:.2f} GB")
+print(f"{nested_bw_time=:.5f}, nested_bw_peak_mem={nested_bw_peak_mem/1e9:.2f} GB")
+print(f"Nested backward speedup: {(padded_bw_time/nested_bw_time):.2f}")
+print(
+    f"Nested backward peak memory reduction {((padded_bw_peak_mem - nested_bw_peak_mem)/1e9):.2f} GB"
+)
+
+print(
+    "Difference in out_proj.weight.grad",
+    (mha_layer.out_proj.weight.grad - vanilla_mha_layer.out_proj.weight.grad)
+    .abs()
+    .max()
+    .item(),
+)
+print(
+    "Difference in packed_proj.weight.grad",
+    (mha_layer.packed_proj.weight.grad - vanilla_mha_layer.in_proj_weight.grad)
+    .abs()
+    .max()
+    .item(),
+)
+print(
+    "Difference in out_proj.bias.grad",
+    (mha_layer.out_proj.bias.grad - vanilla_mha_layer.out_proj.bias.grad)
+    .abs()
+    .max()
+    .item(),
+)
+print(
+    "Difference in packed_proj.bias.grad",
+    (mha_layer.packed_proj.bias.grad - vanilla_mha_layer.in_proj_bias.grad)
+    .abs()
+    .max()
+    .item(),
+)
+
+##################################################################################
+# Sample outputs on A100:
+#
+# .. code::
+#
+#     padded_bw_time=2.09337, padded_bw_peak_mem=5.10 GB
+#     nested_bw_time=0.01452, nested_bw_peak_mem=3.24 GB
+#     Nested backward speedup: 144.13
+#     Nested backward peak memory reduction 1.86 GB
+#     Difference in out_proj.weight.grad 0.000244140625
+#     Difference in packed_proj.weight.grad 0.001556396484375
+#     Difference in out_proj.bias.grad 0.0
+#     Difference in packed_proj.bias.grad 0.001953125
+#
+
+##################################################################################
+# GPT-style layer
+# ---------------
+# A basic GPT-style transformer layer consists of a causal self-attention layer
+# followed by a feed-forward network (FFN) with skip connections. Implementing
+# this is fairly straightforward using the ``MultiheadAttention`` layer above and
+# gives equivalent results to an ``nn.TransformerEncoderLayer`` with
+# ``is_causal=True``.
+#
+# We  demonstrate examples of implementing the rest of the ``nn`` layers
+# `here <https://github.com/mikaylagawarecki/transformer_tutorial_accompaniment>`_
+# but omit that from this tutorial for brevity.
+
+
+###############################################################################
+# Going one step further
+# ----------------------
+# So far, we have demonstrated how to implement a performant ``MultiheadAttention``
+# layer that follows the traditional ``nn.MultiheadAttention``. Going back to our
+# classification of modifications to the transformer architecture, remember that we
+# classified the modifications into layer type, layer ordering, and modifications
+# to the attention score. We trust that changing layer type and layer ordering
+# (such as swapping ``LayerNorm`` for ``RMSNorm``) is fairly straightforward.
+#
+# In this section, we will discuss various functionalities using the
+# aforementioned building blocks, including the following:
+#
+# * Cross Attention
+# * Fully masked rows no longer cause NaNs
+# * Packed Projection
+
+###############################################################################
+# Cross Attention
+# ---------------
+# Cross attention is a form of attention where the query and key/value tensors
+# are from different sequences.
+#
+# One example of this is in ``nn.TransformerDecoderLayer`` where the query comes
+# from the decoder and the key/value come from the encoder.
+#
+# The above MultiheadAttention layer nicely generalizes to this case with nested
+# tensors for both query and key/value.
+
+query, _, _, q_len = gen_batch(N, E_q, E_k, E_v, device)
+_, key, value, kv_len = gen_batch(N, E_q, E_k, E_v, device)
+
+print(
+    f"Total sequence length in nested query {q_len.sum().item()}, max sequence length {q_len.max().item()}"
+)
+print(
+    f"Total sequence length in nested key/value {kv_len.sum().item()}, max sequence length {kv_len.max().item()}"
+)
+out = new_mha_layer(query, key, value, is_causal=False)
+
+########################################################################################
+# As above, we can compare this against the vanilla compiled ``nn.MultiheadAttention``.
+
+torch.manual_seed(6)
+query, _, _, q_len = gen_batch(N, E_q, E_k, E_v, device)
+_, key, value, kv_len = gen_batch(N, E_q, E_k, E_v, device)
+padded_query, padded_key, padded_value = (
+    t.to_padded_tensor(0.0) for t in (query, key, value)
+)
+
+key_padding_mask = torch.where(padded_key == 0.0, -math.inf, 0)[:, :, 0]
+
+# warmup compile
+warmup_nested_result = new_mha_layer(query, key, value, is_causal=False)
+warmup_vanilla_result = vanilla_mha_layer(
+    padded_query,
+    padded_key,
+    padded_value,
+    key_padding_mask=key_padding_mask,
+    need_weights=False,
+    is_causal=False,
+)
+
+nested_result, nested_time, nested_peak_memory = benchmark(
+    new_mha_layer, query, key, value, is_causal=False
+)
+(padded_result, _), padded_time, padded_peak_memory = benchmark(
+    vanilla_mha_layer,
+    padded_query,
+    padded_key,
+    padded_value,
+    key_padding_mask=key_padding_mask,
+    need_weights=False,
+    is_causal=False,
+)
+padded_nested_result = nested_result.to_padded_tensor(0.0)
+for i, entry_length in enumerate(q_len):
+    # padding-specific step: remove output projection bias from padded entries for fair comparison
+    padded_result[i, entry_length:, :] = 0.0
+
+print(
+    "Max difference between vanilla and nested result",
+    (padded_result - padded_nested_result).abs().max().item(),
+)
+print(f"Nested speedup: {(padded_time/nested_time):.2f}")
+print(
+    f"Nested peak memory reduction {((padded_peak_memory - nested_peak_memory)/1e9):.2f} GB"
+)
+
+##################################################################################
+# Sample outputs on A100:
+#
+# .. code::
+#
+#     Max difference between vanilla and nested result 0.0
+#     Nested speedup: 4.01
+#     Nested peak memory reduction 1.40 GB
+#
+
+################################################################################
+# Fully masked rows no longer cause NaNs
+# --------------------------------------
+#
+# There has been a long standing issue with ``nn.MultiheadAttention`` and
+# ``scaled_dot_product_attention`` where if a row was fully masked out, the output
+# of the attention layer would be NaN. See `issue <https://github.com/pytorch/pytorch/issues/41508>`_.
+# This is because the softmax over an empty set is undefined.
+#
+# Thanks to `this PR <https://github.com/pytorch/pytorch/pull/133882>`_
+# this is no longer the case. Instead, the output corresponding to fully masked rows
+# in ``scaled_dot_product_attention`` will be 0. For cases where ``nn.MHA`` does
+# not employ the "fast-path", this will also apply.
+#
+# Using a custom MHA layer with NJTs is strongly recommended over the
+# existing "fast-path" in ``nn.MultiheadAttention`` as NJT's ability to model raggedness
+# appropriately makes it possible to properly express empty sequences.
+
+
+###############################################################################
+# Packed Projection
+# -----------------
+#
+# Packed projection is a technique that makes use of the fact that when the input
+# for projection (matrix multiplications) are the same (self-attention), we can pack the projection
+# weights and biases into single tensors. It is especially useful when the individual
+# projections are memory bound rather than compute bound. There are
+# two examples that we will demonstrate here:
+#
+# * Input projection for MultiheadAttention
+# * SwiGLU activation in feed-forward network of Transformer Layer
+#
+# Input projection for MultiheadAttention
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# When doing self-attention, the ``query``, ``key``, and ``value``
+# are the same tensor. Each of these tensors is projected with a
+# ``Linear(E_q, E_total)`` layer. Instead, we can pack this into one layer,
+# which is what we do in the MultiheadAttention layer above.
+#
+# Let us compare the performance of the packed projection against the usual method:
+
+
+class InputProjection(nn.Module):
+    def __init__(self, E_q, E_total, bias=False, device=None, dtype=None):
+        factory_kwargs = {"device": device, "dtype": dtype}
+        super().__init__()
+        self.q_proj = nn.Linear(E_q, E_total, bias=bias, **factory_kwargs)
+        self.k_proj = nn.Linear(E_q, E_total, bias=bias, **factory_kwargs)
+        self.v_proj = nn.Linear(E_q, E_total, bias=bias, **factory_kwargs)
+
+    def forward(self, x):
+        return self.q_proj(x), self.k_proj(x), self.v_proj(x)
+
+
+class PackedInputProjection(nn.Module):
+    def __init__(self, E_q, E_total, bias=False, device=None, dtype=None):
+        factory_kwargs = {"device": device, "dtype": dtype}
+        super().__init__()
+        self.packed_proj = nn.Linear(E_q, E_total * 3, bias=bias, **factory_kwargs)
+
+    def forward(self, query):
+        return torch.chunk(self.packed_proj(query), 3, dim=-1)
+
+
+B, D, dtype = 256, 8192, torch.bfloat16
+
+torch.set_float32_matmul_precision("high")
+in_proj = torch.compile(InputProjection(D, D, device="cuda", dtype=torch.bfloat16))
+packed_in_proj = torch.compile(
+    PackedInputProjection(D, D, device="cuda", dtype=torch.bfloat16)
+)
+
+q, _, _, sequence_lengths = gen_batch(B, D, D, D, device="cuda", dtype=torch.bfloat16)
+
+# warmup
+in_proj(q)
+packed_in_proj(q)
+
+# benchmark
+(q_out, k_out, v_out), time, _ = benchmark(in_proj, q)
+(q_out, k_out, v_out), time_packed, _ = benchmark(packed_in_proj, q)
+# On my A100 prints 1.05x speedup
+print(
+    f"InputProjection: {time:5f} s, PackedInputProjection: {time_packed:5f} s, speedup: {time/time_packed:.2f}x"
+)
+
+##################################################
+# SwiGLU feed forward network of Transformer Layer
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# Swish-Gated Linear Unit (SwiGLU) is a non-linear activation function that is increasingly popular in the feed-forward
+# network of the transformer layer (e.g. Llama). A feed-forward network with SwiGLU activation is defined as:
+
+
+class SwiGLUFFN(nn.Module):
+    def __init__(
+        self,
+        dim,
+        hidden_dim,
+        multiple_of,
+        ffn_dim_multiplier=None,
+        device=None,
+        dtype=None,
+    ):
+        factory_kwargs = {"device": device, "dtype": dtype}
+        super().__init__()
+        hidden_dim = int(2 * hidden_dim / 3)
+        # custom dim factor multiplier
+        if ffn_dim_multiplier is not None:
+            hidden_dim = int(ffn_dim_multiplier * hidden_dim)
+        hidden_dim = multiple_of * ((hidden_dim + multiple_of - 1) // multiple_of)
+
+        self.w1 = nn.Linear(dim, hidden_dim, bias=False, **factory_kwargs)
+        self.w2 = nn.Linear(hidden_dim, dim, bias=False, **factory_kwargs)
+        self.w3 = nn.Linear(dim, hidden_dim, bias=False, **factory_kwargs)
+
+    def forward(self, x):
+        return self.w2(F.silu(self.w1(x)) * self.w3(x))
+
+
+########################################################################
+# An alternative way of implementing this that uses packed projection is
+
+
+class PackedSwiGLUFFN(nn.Module):
+    def __init__(
+        self,
+        dim,
+        hidden_dim,
+        multiple_of,
+        ffn_dim_multiplier=None,
+        device=None,
+        dtype=None,
+    ):
+        factory_kwargs = {"device": device, "dtype": dtype}
+        super().__init__()
+        hidden_dim = int(2 * hidden_dim / 3)
+        # custom dim factor multiplier
+        if ffn_dim_multiplier is not None:
+            hidden_dim = int(ffn_dim_multiplier * hidden_dim)
+        hidden_dim = multiple_of * ((hidden_dim + multiple_of - 1) // multiple_of)
+
+        self.w13 = nn.Linear(dim, 2 * hidden_dim, bias=False, **factory_kwargs)
+        self.w2 = nn.Linear(hidden_dim, dim, bias=False, **factory_kwargs)
+
+    def forward(self, x):
+        x1, x3 = torch.chunk(self.w13(x), 2, dim=-1)
+        return self.w2(F.silu(x1) * x3)
+
+
+################################################################################
+# We can compare the performance of the two implementations as follows
+# Depending on your hardware, you might see different results. On an A100 I see
+# 1.12x speedup for D=128.
+D = 128
+
+swigluffn = torch.compile(SwiGLUFFN(D, D * 4, 256, device="cuda", dtype=torch.bfloat16))
+packed_swigluffn = torch.compile(
+    PackedSwiGLUFFN(D, D * 4, 256, device="cuda", dtype=torch.bfloat16)
+)
+
+q, _, _, sentence_lengths = gen_batch(D, D, D, D, device="cuda", dtype=torch.bfloat16)
+
+# warmup
+swigluffn(q)
+packed_swigluffn(q)
+
+# benchmark
+_, time, _ = benchmark(swigluffn, q)
+_, time_packed, _ = benchmark(packed_swigluffn, q)
+# On my A100 prints 1.08x speedup
+print(
+    f"SwiGLUFFN: {time} s, PackedSwiGLUFFN: {time_packed} s, speedup: {time/time_packed:.2f}x"
+)
+
+################################################################################
+# Extended examples
+# -----------------
+#
+# We intend to update this tutorial to demonstrate more examples of how to use
+# the various performant building blocks such as KV-Caching, Grouped Query Attention
+# etc. Further, there are several good examples of using various performant building blocks to
+# implement various transformer architectures. Some examples include
+#
+# * `gpt-fast <https://github.com/meta-pytorch/gpt-fast>`_
+# * `segment-anything-fast <https://github.com/meta-pytorch/segment-anything-fast>`_
+# * `lucidrains implementation of NaViT with nested tensors <https://github.com/lucidrains/vit-pytorch/blob/73199ab486e0fad9eced2e3350a11681db08b61b/vit_pytorch/na_vit_nested_tensor.py>`_
+# * `torchtune's implementation of VisionTransformer <https://github.com/pytorch/torchtune/blob/a8a64ec6a99a6ea2be4fdaf0cd5797b03a2567cf/torchtune/modules/vision_transformer.py#L16>`_
+
+################################################################################
+# Conclusion
+# ----------
+#
+# In this tutorial, we have introduced the low level building blocks PyTorch
+# provides for writing transformer layers and demonstrated examples how to compose
+# them. It is our hope that this tutorial has educated the reader on the ease with
+# which flexible and performant transformer layers can be implemented by users of PyTorch.
diff --git a/intermediate_source/visualizing_gradients_tutorial.py b/intermediate_source/visualizing_gradients_tutorial.py
new file mode 100644
index 00000000000..ff78fa3f01a
--- /dev/null
+++ b/intermediate_source/visualizing_gradients_tutorial.py
@@ -0,0 +1,298 @@
+"""
+Visualizing Gradients
+=====================
+
+**Author:** `Justin Silver <https://github.com/j-silv>`__
+
+This tutorial explains how to extract and visualize gradients at any
+layer in a neural network. By inspecting how information flows from the
+end of the network to the parameters we want to optimize, we can debug
+issues such as `vanishing or exploding
+gradients <https://arxiv.org/abs/1211.5063>`__ that occur during
+training.
+
+Before starting, make sure you understand `tensors and how to manipulate
+them <https://docs.pytorch.org/tutorials/beginner/basics/tensorqs_tutorial.html>`__.
+A basic knowledge of `how autograd
+works <https://docs.pytorch.org/tutorials/beginner/basics/autogradqs_tutorial.html>`__
+would also be useful.
+
+"""
+
+
+######################################################################
+# Setup
+# -----
+#
+# First, make sure `PyTorch is
+# installed <https://pytorch.org/get-started/locally/>`__ and then import
+# the necessary libraries.
+#
+
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import torch.nn.functional as F
+import matplotlib.pyplot as plt
+
+
+######################################################################
+# Next, we’ll be creating a network intended for the MNIST dataset,
+# similar to the architecture described by the `batch normalization
+# paper <https://arxiv.org/abs/1502.03167>`__.
+#
+# To illustrate the importance of gradient visualization, we will
+# instantiate one version of the network with batch normalization
+# (BatchNorm), and one without it. Batch normalization is an extremely
+# effective technique to resolve `vanishing/exploding
+# gradients <https://arxiv.org/abs/1211.5063>`__, and we will be verifying
+# that experimentally.
+#
+# The model we use has a configurable number of repeating fully-connected
+# layers which alternate between ``nn.Linear``, ``norm_layer``, and
+# ``nn.Sigmoid``. If batch normalization is enabled, then ``norm_layer``
+# will use
+# `BatchNorm1d <https://docs.pytorch.org/docs/stable/generated/torch.nn.BatchNorm1d.html>`__,
+# otherwise it will use the
+# `Identity <https://docs.pytorch.org/docs/stable/generated/torch.nn.Identity.html>`__
+# transformation.
+#
+
+def fc_layer(in_size, out_size, norm_layer):
+    """Return a stack of linear->norm->sigmoid layers"""
+    return nn.Sequential(nn.Linear(in_size, out_size), norm_layer(out_size), nn.Sigmoid())
+
+class Net(nn.Module):
+    """Define a network that has num_layers of linear->norm->sigmoid transformations"""
+    def __init__(self, in_size=28*28, hidden_size=128,
+                 out_size=10, num_layers=3, batchnorm=False):
+        super().__init__()
+        if batchnorm is False:
+            norm_layer = nn.Identity
+        else:
+            norm_layer = nn.BatchNorm1d
+
+        layers = []
+        layers.append(fc_layer(in_size, hidden_size, norm_layer))
+
+        for i in range(num_layers-1):
+            layers.append(fc_layer(hidden_size, hidden_size, norm_layer))
+
+        layers.append(nn.Linear(hidden_size, out_size))
+
+        self.layers = nn.Sequential(*layers)
+
+    def forward(self, x):
+        x = torch.flatten(x, 1)
+        return self.layers(x)
+
+
+######################################################################
+# Next we set up some dummy data, instantiate two versions of the model,
+# and initialize the optimizers.
+#
+
+# set up dummy data
+x = torch.randn(10, 28, 28)
+y = torch.randint(10, (10, ))
+
+# init model
+model_bn = Net(batchnorm=True, num_layers=3)
+model_nobn = Net(batchnorm=False, num_layers=3)
+
+model_bn.train()
+model_nobn.train()
+
+optimizer_bn = optim.SGD(model_bn.parameters(), lr=0.01, momentum=0.9)
+optimizer_nobn = optim.SGD(model_nobn.parameters(), lr=0.01, momentum=0.9)
+
+
+
+######################################################################
+# We can verify that batch normalization is only being applied to one of
+# the models by probing one of the internal layers:
+#
+
+print(model_bn.layers[0])
+print(model_nobn.layers[0])
+
+
+######################################################################
+# Registering hooks
+# -----------------
+#
+
+
+######################################################################
+# Because we wrapped up the logic and state of our model in a
+# ``nn.Module``, we need another method to access the intermediate
+# gradients if we want to avoid modifying the module code directly. This
+# is done by `registering a
+# hook <https://docs.pytorch.org/docs/stable/notes/autograd.html#backward-hooks-execution>`__.
+#
+# .. warning::
+#
+#    Using backward pass hooks attached to output tensors is preferred over using ``retain_grad()`` on the tensors themselves. An alternative method is to directly attach module hooks (e.g. ``register_full_backward_hook()``) so long as the ``nn.Module`` instance does not do perform any in-place operations. For more information, please refer to `this issue <https://github.com/pytorch/pytorch/issues/61519>`__.
+#
+# The following code defines our hooks and gathers descriptive names for
+# the network’s layers.
+#
+
+# note that wrapper functions are used for Python closure
+# so that we can pass arguments.
+
+def hook_forward(module_name, grads, hook_backward):
+    def hook(module, args, output):
+        """Forward pass hook which attaches backward pass hooks to intermediate tensors"""
+        output.register_hook(hook_backward(module_name, grads))
+    return hook
+
+def hook_backward(module_name, grads):
+    def hook(grad):
+        """Backward pass hook which appends gradients"""
+        grads.append((module_name, grad))
+    return hook
+
+def get_all_layers(model, hook_forward, hook_backward):
+    """Register forward pass hook (which registers a backward hook) to model outputs
+
+    Returns:
+        - layers: a dict with keys as layer/module and values as layer/module names
+                  e.g. layers[nn.Conv2d] = layer1.0.conv1
+        - grads: a list of tuples with module name and tensor output gradient
+                 e.g. grads[0] == (layer1.0.conv1, tensor.Torch(...))
+    """
+    layers = dict()
+    grads = []
+    for name, layer in model.named_modules():
+        # skip Sequential and/or wrapper modules
+        if any(layer.children()) is False:
+            layers[layer] = name
+            layer.register_forward_hook(hook_forward(name, grads, hook_backward))
+    return layers, grads
+
+# register hooks
+layers_bn, grads_bn = get_all_layers(model_bn, hook_forward, hook_backward)
+layers_nobn, grads_nobn = get_all_layers(model_nobn, hook_forward, hook_backward)
+
+
+######################################################################
+# Training and visualization
+# --------------------------
+#
+# Let’s now train the models for a few epochs:
+#
+
+epochs = 10
+
+for epoch in range(epochs):
+
+    # important to clear, because we append to
+    # outputs everytime we do a forward pass
+    grads_bn.clear()
+    grads_nobn.clear()
+
+    optimizer_bn.zero_grad()
+    optimizer_nobn.zero_grad()
+
+    y_pred_bn = model_bn(x)
+    y_pred_nobn = model_nobn(x)
+
+    loss_bn = F.cross_entropy(y_pred_bn, y)
+    loss_nobn = F.cross_entropy(y_pred_nobn, y)
+
+    loss_bn.backward()
+    loss_nobn.backward()
+
+    optimizer_bn.step()
+    optimizer_nobn.step()
+
+
+######################################################################
+# After running the forward and backward pass, the gradients for all the
+# intermediate tensors should be present in ``grads_bn`` and
+# ``grads_nobn``. We compute the mean absolute value of each gradient
+# matrix so that we can compare the two models.
+#
+
+def get_grads(grads):
+    layer_idx = []
+    avg_grads = []
+    for idx, (name, grad) in enumerate(grads):
+        if grad is not None:
+            avg_grad = grad.abs().mean()
+            avg_grads.append(avg_grad)
+            # idx is backwards since we appended in backward pass
+            layer_idx.append(len(grads) - 1 - idx)
+    return layer_idx, avg_grads
+
+layer_idx_bn, avg_grads_bn = get_grads(grads_bn)
+layer_idx_nobn, avg_grads_nobn = get_grads(grads_nobn)
+
+
+######################################################################
+# With the average gradients computed, we can now plot them and see how
+# the values change as a function of the network depth. Notice that when
+# we don’t apply batch normalization, the gradient values in the
+# intermediate layers fall to zero very quickly. The batch normalization
+# model, however, maintains non-zero gradients in its intermediate layers.
+#
+
+fig, ax = plt.subplots()
+ax.plot(layer_idx_bn, avg_grads_bn, label="With BatchNorm", marker="o")
+ax.plot(layer_idx_nobn, avg_grads_nobn, label="Without BatchNorm", marker="x")
+ax.set_xlabel("Layer depth")
+ax.set_ylabel("Average gradient")
+ax.set_title("Gradient flow")
+ax.grid(True)
+ax.legend()
+plt.show()
+
+
+######################################################################
+# Conclusion
+# ----------
+#
+# In this tutorial, we demonstrated how to visualize the gradient flow
+# through a neural network wrapped in a ``nn.Module`` class. We
+# qualitatively showed how batch normalization helps to alleviate the
+# vanishing gradient issue which occurs with deep neural networks.
+#
+# If you would like to learn more about how PyTorch’s autograd system
+# works, please visit the `references <#references>`__ below. If you have
+# any feedback for this tutorial (improvements, typo fixes, etc.) then
+# please use the `PyTorch Forums <https://discuss.pytorch.org/>`__ and/or
+# the `issue tracker <https://github.com/pytorch/tutorials/issues>`__ to
+# reach out.
+#
+
+
+######################################################################
+# (Optional) Additional exercises
+# -------------------------------
+#
+# -  Try increasing the number of layers (``num_layers``) in our model and
+#    see what effect this has on the gradient flow graph
+# -  How would you adapt the code to visualize average activations instead
+#    of average gradients? (*Hint: in the hook_forward() function we have
+#    access to the raw tensor output*)
+# -  What are some other methods to deal with vanishing and exploding
+#    gradients?
+#
+
+
+######################################################################
+# References
+# ----------
+#
+# -  `A Gentle Introduction to
+#    torch.autograd <https://docs.pytorch.org/tutorials/beginner/blitz/autograd_tutorial.html>`__
+# -  `Automatic Differentiation with
+#    torch.autograd <https://docs.pytorch.org/tutorials/beginner/basics/autogradqs_tutorial>`__
+# -  `Autograd
+#    mechanics <https://docs.pytorch.org/docs/stable/notes/autograd.html>`__
+# -  `Batch Normalization: Accelerating Deep Network Training by Reducing
+#    Internal Covariate Shift <https://arxiv.org/abs/1502.03167>`__
+# -  `On the difficulty of training Recurrent Neural
+#    Networks <https://arxiv.org/abs/1211.5063>`__
+#
\ No newline at end of file
diff --git a/intro.rst b/intro.rst
new file mode 100644
index 00000000000..1f9c8ceb4ef
--- /dev/null
+++ b/intro.rst
@@ -0,0 +1,66 @@
+Intro
+=====
+
+This is a collection of beginner-friendly resources to help you get
+started with PyTorch. These tutorials cover fundamental concepts,
+basic operations, and essential workflows to build a solid foundation
+for your deep learning journey. Perfect for newcomers looking to
+understand PyTorch's core functionality through step-by-step guidance.
+
+.. grid:: 2
+
+    .. grid-item-card:: :octicon:`file-code;1em`
+       Learn the Basics
+       :link: https://pytorch.org/tutorials/beginner/basics/intro.html
+       :link-type: url
+
+       A step-by-step interactive series for those just starting out
+       with PyTorch.
+       +++
+       :octicon:`code;1em` Code
+
+    .. grid-item-card:: :octicon:`file-code;1em`
+       Introduction to PyTorch - YouTube Series
+       :link: https://pytorch.org/tutorials/beginner/introyt/introyt_index.html
+       :link-type: url
+
+       Learn the fundamentals of PyTorch through our video series,
+       perfect for those who prefer learning from videos.
+       +++
+       :octicon:`code;1em` Code :octicon:`square-fill;1em` :octicon:`video;1em` Video
+
+.. grid:: 2
+
+    .. grid-item-card:: :octicon:`file-code;1em`
+       Learning PyTorch
+       :link: https://pytorch.org/tutorials/beginner/deep_learning_60min_blitz.html
+       :link-type: url
+
+       Quickly grasp the basics of PyTorch with these bite-sized
+       foundational recipes.
+       +++
+       :octicon:`code;1em` Code
+
+.. toctree::
+   :maxdepth: 1
+   :hidden:
+   :includehidden:
+   :caption: Getting Started with PyTorch
+
+   beginner/basics/intro
+   beginner/introyt/introyt_index
+
+.. toctree::
+   :maxdepth: 1
+   :hidden:
+   :includehidden:
+   :caption: Learning PyTorch
+
+   beginner/deep_learning_60min_blitz
+   beginner/pytorch_with_examples
+   beginner/nn_tutorial
+   beginner/understanding_leaf_vs_nonleaf_tutorial
+   intermediate/nlp_from_scratch_index
+   intermediate/tensorboard_tutorial
+   intermediate/pinmem_nonblock
+   intermediate/visualizing_gradients_tutorial
diff --git a/lychee.toml b/lychee.toml
new file mode 100644
index 00000000000..b07496f7876
--- /dev/null
+++ b/lychee.toml
@@ -0,0 +1 @@
+exclude_path = [".jenkins/build.sh", "_static/img/", "_static/images/"]
diff --git a/recipes_index.rst b/recipes_index.rst
new file mode 100644
index 00000000000..b8cb9089e44
--- /dev/null
+++ b/recipes_index.rst
@@ -0,0 +1,356 @@
+Recipes
+========
+
+Recipes are bite-sized, actionable examples of
+how to use specific PyTorch features, different
+from our full-length tutorials.
+
+.. raw:: html
+
+   <div id="tutorial-cards-container">
+
+    <nav class="navbar navbar-expand-lg navbar-light tutorials-nav col-12">
+        <div class="tutorial-tags-container">
+            <div id="dropdown-filter-tags">
+                <div class="tutorial-filter-menu">
+                    <div class="tutorial-filter filter-btn all-tag-selected" data-tag="all">All</div>
+                </div>
+            </div>
+        </div>
+    </nav>
+
+    <hr class="tutorials-hr">
+
+    <div class="row">
+
+    <div id="tutorial-cards">
+    <div class="list">
+
+.. Add recipe cards below this line
+
+.. Basics
+
+.. customcarditem::
+   :header: Defining a Neural Network
+   :card_description: Learn how to use PyTorch's torch.nn package to create and define a neural network for the MNIST dataset.
+   :image: _static/img/thumbnails/cropped/defining-a-network.PNG
+   :link: recipes/recipes/defining_a_neural_network.html
+   :tags: Basics
+
+.. customcarditem::
+   :header: What is a state_dict in PyTorch
+   :card_description: Learn how state_dict objects and Python dictionaries are used in saving or loading models from PyTorch.
+   :image: _static/img/thumbnails/cropped/what-is-a-state-dict.PNG
+   :link: recipes/recipes/what_is_state_dict.html
+   :tags: Basics
+
+
+.. customcarditem::
+   :header: Warmstarting model using parameters from a different model in PyTorch
+   :card_description: Learn how warmstarting the training process by partially loading a model or loading a partial model can help your model converge much faster than training from scratch.
+   :image: _static/img/thumbnails/cropped/warmstarting-models.PNG
+   :link: recipes/recipes/warmstarting_model_using_parameters_from_a_different_model.html
+   :tags: Basics
+
+.. customcarditem::
+   :header: Zeroing out gradients in PyTorch
+   :card_description: Learn when you should zero out gradients and how doing so can help increase the accuracy of your model.
+   :image: _static/img/thumbnails/cropped/zeroing-out-gradients.PNG
+   :link: recipes/recipes/zeroing_out_gradients.html
+   :tags: Basics
+
+.. customcarditem::
+   :header: PyTorch Benchmark
+   :card_description: Learn how to use PyTorch's benchmark module to measure and compare the performance of your code
+   :image: _static/img/thumbnails/cropped/profiler.png
+   :link: recipes/recipes/benchmark.html
+   :tags: Basics
+
+.. customcarditem::
+   :header: PyTorch Benchmark (quick start)
+   :card_description: Learn how to measure snippet run times and collect instructions.
+   :image: _static/img/thumbnails/cropped/profiler.png
+   :link: recipes/recipes/timer_quick_start.html
+   :tags: Basics
+
+.. customcarditem::
+   :header: PyTorch Profiler
+   :card_description: Learn how to use PyTorch's profiler to measure operators time and memory consumption
+   :image: _static/img/thumbnails/cropped/profiler.png
+   :link: recipes/recipes/profiler_recipe.html
+   :tags: Basics
+
+.. customcarditem::
+   :header: PyTorch Profiler with Instrumentation and Tracing Technology API (ITT API) support
+   :card_description: Learn how to use PyTorch's profiler with Instrumentation and Tracing Technology API (ITT API) to visualize operators labeling in Intel® VTune™ Profiler GUI
+   :image: _static/img/thumbnails/cropped/profiler.png
+   :link: recipes/profile_with_itt.html
+   :tags: Basics
+
+.. customcarditem::
+   :header: Dynamic Compilation Control with ``torch.compiler.set_stance``
+   :card_description: Learn how to use torch.compiler.set_stance
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: recipes/torch_compiler_set_stance_tutorial.html
+   :tags: Compiler
+
+.. customcarditem::
+   :header: Reasoning about Shapes in PyTorch
+   :card_description: Learn how to use the meta device to reason about shapes in your model.
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: recipes/recipes/reasoning_about_shapes.html
+   :tags: Basics
+
+.. customcarditem::
+   :header: Tips for Loading an nn.Module from a Checkpoint
+   :card_description: Learn tips for loading an nn.Module from a checkpoint.
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: recipes/recipes/module_load_state_dict_tips.html
+   :tags: Basics
+
+.. customcarditem::
+   :header: (beta) Using TORCH_LOGS to observe torch.compile
+   :card_description: Learn how to use the torch logging APIs to observe the compilation process.
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: recipes/torch_logs.html
+   :tags: Basics
+
+.. customcarditem::
+   :header: Extension points in nn.Module for loading state_dict and tensor subclasses
+   :card_description: New extension points in nn.Module.
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: recipes/recipes/swap_tensors.html
+   :tags: Basics
+
+.. customcarditem::
+   :header: torch.export AOTInductor Tutorial for Python runtime
+   :card_description: Learn an end-to-end example of how to use AOTInductor for python runtime.
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: recipes/torch_export_aoti_python.html
+   :tags: Basics
+
+.. customcarditem::
+   :header: Demonstration of torch.export flow, common challenges and the solutions to address them
+   :card_description: Learn how to export models for popular usecases
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: recipes/torch_export_challenges_solutions.html
+   :tags: Compiler,TorchCompile
+
+.. Interpretability
+
+.. customcarditem::
+   :header: Model Interpretability using Captum
+   :card_description: Learn how to use Captum attribute the predictions of an image classifier to their corresponding image features and visualize the attribution results.
+   :image: _static/img/thumbnails/cropped/model-interpretability-using-captum.png
+   :link: recipes/recipes/Captum_Recipe.html
+   :tags: Interpretability,Captum
+
+.. customcarditem::
+   :header: How to use TensorBoard with PyTorch
+   :card_description: Learn basic usage of TensorBoard with PyTorch, and how to visualize data in TensorBoard UI
+   :image: _static/img/thumbnails/tensorboard_scalars.png
+   :link: recipes/recipes/tensorboard_with_pytorch.html
+   :tags: Visualization,TensorBoard
+
+.. Automatic Mixed Precision
+
+.. customcarditem::
+   :header: Automatic Mixed Precision
+   :card_description: Use torch.cuda.amp to reduce runtime and save memory on NVIDIA GPUs.
+   :image: _static/img/thumbnails/cropped/amp.png
+   :link: recipes/recipes/amp_recipe.html
+   :tags: Model-Optimization
+
+.. Performance
+
+.. customcarditem::
+   :header: Performance Tuning Guide
+   :card_description: Tips for achieving optimal performance.
+   :image: _static/img/thumbnails/cropped/profiler.png
+   :link: recipes/recipes/tuning_guide.html
+   :tags: Model-Optimization
+
+.. customcarditem::
+   :header: Optimizing CPU Performance on Intel® Xeon® with run_cpu Script
+   :card_description: How to use run_cpu script for optimal runtime configurations on Intel® Xeon CPUs.
+   :image: _static/img/thumbnails/cropped/profiler.png
+   :link: recipes/xeon_run_cpu.html
+   :tags: Model-Optimization
+
+
+.. (beta) Utilizing Torch Function modes with torch.compile
+
+.. customcarditem::
+   :header: (beta) Utilizing Torch Function modes with torch.compile
+   :card_description: Override torch operators with Torch Function modes and torch.compile
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: recipes/torch_compile_torch_function_modes.html
+   :tags: Model-Optimization
+
+.. (beta) Compiling the Optimizer with torch.compile
+
+.. customcarditem::
+   :header: (beta) Compiling the Optimizer with torch.compile
+   :card_description: Speed up the optimizer using torch.compile
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: recipes/compiling_optimizer.html
+   :tags: Model-Optimization
+
+.. (beta) Running the compiled optimizer with an LR Scheduler
+
+.. customcarditem::
+   :header: (beta) Running the compiled optimizer with an LR Scheduler
+   :card_description: Speed up training with LRScheduler and torch.compiled optimizer
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: recipes/compiling_optimizer_lr_scheduler.html
+   :tags: Model-Optimization
+
+.. (beta) Explicit horizontal fusion with foreach_map and torch.compile
+.. customcarditem::
+   :header: (beta) Explicit horizontal fusion with foreach_map and torch.compile
+   :card_description: Horizontally fuse pointwise ops with torch.compile
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: recipes/foreach_map.py
+   :tags: Model-Optimization
+
+.. Using User-Defined Triton Kernels with ``torch.compile``
+
+.. customcarditem::
+   :header: Using User-Defined Triton Kernels with ``torch.compile``
+   :card_description: Learn how to use user-defined kernels with ``torch.compile``
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: recipes/torch_compile_user_defined_triton_kernel_tutorial.html
+   :tags: Model-Optimization
+
+.. Compile Time Caching in ``torch.compile``
+
+.. customcarditem::
+   :header: Compile Time Caching in ``torch.compile``
+   :card_description: Learn how to use compile time caching in ``torch.compile``
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: recipes/torch_compile_caching_tutorial.html
+   :tags: Model-Optimization
+
+.. Compile Time Caching Configurations
+
+.. customcarditem::
+   :header: Compile Time Caching Configurations
+   :card_description: Learn how to configure compile time caching in ``torch.compile``
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: recipes/torch_compile_caching_configuration_tutorial.html
+   :tags: Model-Optimization
+
+.. Reducing Cold Start Compilation Time with Regional Compilation
+
+.. customcarditem::
+   :header: Reducing torch.compile cold start compilation time with regional compilation
+   :card_description: Learn how to use regional compilation to control cold start compile time
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: recipes/regional_compilation.html
+   :tags: Model-Optimization
+
+.. Intel(R) Neural Compressor for PyTorch*
+
+.. customcarditem::
+   :header: Intel® Neural Compressor for PyTorch
+   :card_description: Ease-of-use quantization for PyTorch with Intel® Neural Compressor.
+   :image: _static/img/thumbnails/cropped/profiler.png
+   :link: recipes/intel_neural_compressor_for_pytorch.html
+   :tags: Quantization,Model-Optimization
+
+.. Distributed Training
+
+.. customcarditem::
+   :header: Getting Started with DeviceMesh
+   :card_description: Learn how to use DeviceMesh
+   :image: _static/img/thumbnails/cropped/profiler.png
+   :link: recipes/distributed_device_mesh.html
+   :tags: Distributed-Training
+
+.. customcarditem::
+   :header: Shard Optimizer States with ZeroRedundancyOptimizer
+   :card_description: How to use ZeroRedundancyOptimizer to reduce memory consumption.
+   :image: _static/img/thumbnails/cropped/profiler.png
+   :link: recipes/zero_redundancy_optimizer.html
+   :tags: Distributed-Training
+
+.. customcarditem::
+   :header: Direct Device-to-Device Communication with TensorPipe RPC
+   :card_description: How to use RPC with direct GPU-to-GPU communication.
+   :image: _static/img/thumbnails/cropped/profiler.png
+   :link: recipes/cuda_rpc.html
+   :tags: Distributed-Training
+
+.. customcarditem::
+   :header: Getting Started with Distributed Checkpoint (DCP)
+   :card_description: Learn how to checkpoint distributed models with Distributed Checkpoint package.
+   :image: _static/img/thumbnails/cropped/Getting-Started-with-DCP.png
+   :link: recipes/distributed_checkpoint_recipe.html
+   :tags: Distributed-Training
+
+.. customcarditem::
+   :header: Asynchronous Checkpointing (DCP)
+   :card_description: Learn how to checkpoint distributed models with Distributed Checkpoint package.
+   :image: _static/img/thumbnails/cropped/Getting-Started-with-DCP.png
+   :link: recipes/distributed_async_checkpoint_recipe.html
+   :tags: Distributed-Training
+
+.. customcarditem::
+   :header: Getting Started with CommDebugMode
+   :card_description: Learn how to use CommDebugMode for DTensors
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: recipes/distributed_comm_debug_mode.html
+   :tags: Distributed-Training
+
+.. customcarditem::
+   :header: Reducing AoT cold start compilation time with regional compilation
+   :card_description: Learn how to use regional compilation to control AoT cold start compile time
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: recipes/regional_aot.html
+   :tags: Model-Optimization
+
+.. End of tutorial card section
+
+.. -----------------------------------------
+.. Page TOC
+.. -----------------------------------------
+.. toctree::
+   :maxdepth: 2
+   :hidden:
+
+   recipes/recipes/defining_a_neural_network
+   recipes/torch_logs
+   recipes/recipes/what_is_state_dict
+   recipes/recipes/warmstarting_model_using_parameters_from_a_different_model
+   recipes/recipes/zeroing_out_gradients
+   recipes/recipes/profiler_recipe
+   recipes/recipes/profile_with_itt
+   recipes/recipes/Captum_Recipe
+   recipes/recipes/tensorboard_with_pytorch
+   recipes/recipes/dynamic_quantization
+   recipes/recipes/amp_recipe
+   recipes/recipes/tuning_guide
+   recipes/recipes/xeon_run_cpu
+   recipes/compiling_optimizer
+   recipes/recipes/timer_quick_start
+   recipes/zero_redundancy_optimizer
+   recipes/distributed_comm_debug_mode
+   recipes/torch_export_challenges_solutions
+   recipes/recipes/benchmark
+   recipes/recipes/module_load_state_dict_tips
+   recipes/recipes/reasoning_about_shapes
+   recipes/recipes/swap_tensors
+   recipes/torch_export_aoti_python
+   recipes/recipes/tensorboard_with_pytorch
+   recipes/torch_compile_torch_function_modes
+   recipes/compiling_optimizer_lr_scheduler
+   recipes/foreach_map
+   recipes/torch_compile_user_defined_triton_kernel_tutorial
+   recipes/torch_compile_caching_tutorial
+   recipes/torch_compile_caching_configuration_tutorial
+   recipes/regional_compilation
+   recipes/regional_aot
+   recipes/intel_neural_compressor_for_pytorch
+   recipes/distributed_device_mesh
+   recipes/distributed_checkpoint_recipe
+   recipes/distributed_async_checkpoint_recipe
diff --git a/recipes_source/README.txt b/recipes_source/README.txt
new file mode 100644
index 00000000000..bbc30dc3a6d
--- /dev/null
+++ b/recipes_source/README.txt
@@ -0,0 +1,7 @@
+Recipes
+------------------
+1. recipes/* and recipes_index.rst
+	   PyTorch Recipes
+	   https://pytorch.org/tutorials/recipes_index.html
+	   
+
diff --git a/recipes_source/android_native_app_with_custom_op.rst b/recipes_source/android_native_app_with_custom_op.rst
new file mode 100644
index 00000000000..c9dbc093b21
--- /dev/null
+++ b/recipes_source/android_native_app_with_custom_op.rst
@@ -0,0 +1,10 @@
+Making Native Android Application that uses PyTorch prebuilt libraries
+======================================================================
+
+PyTorch Mobile is no longer actively supported. Please check out `ExecuTorch <https://github.com/pytorch/executorch>`__.
+
+Redirecting in 3 seconds...
+
+.. raw:: html
+
+    <meta http-equiv="Refresh" content="3; url='https://pytorch.org/executorch/stable/index.html'" />
diff --git a/recipes_source/compiling_optimizer.rst b/recipes_source/compiling_optimizer.rst
new file mode 100644
index 00000000000..951495ca4fa
--- /dev/null
+++ b/recipes_source/compiling_optimizer.rst
@@ -0,0 +1,94 @@
+(beta) Compiling the optimizer with torch.compile
+==========================================================================================
+
+**Author:** `Michael Lazos <https://github.com/mlazos>`_
+
+The optimizer is a key algorithm for training any deep learning model.
+Since it is responsible for updating every model parameter, it can often
+become the bottleneck in training performance for large models. In this recipe, 
+we will apply ``torch.compile`` to the optimizer to observe the GPU performance 
+improvement.
+
+.. note::
+
+   This tutorial requires PyTorch 2.2.0 or later.
+
+Model Setup
+~~~~~~~~~~~~~~~~~~~~~
+For this example, we'll use a simple sequence of linear layers.
+Since we are only benchmarking the optimizer, the choice of model doesn't matter
+because optimizer performance is a function of the number of parameters.
+
+Depending on what machine you are using, your exact results may vary.
+
+.. code-block:: python
+
+   import torch
+   
+   model = torch.nn.Sequential(
+       *[torch.nn.Linear(1024, 1024, False, device="cuda") for _ in range(10)]
+   )
+   input = torch.rand(1024, device="cuda")
+   output = model(input)
+   output.sum().backward()
+
+Setting up and running the optimizer benchmark
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+In this example, we'll use the Adam optimizer
+and create a helper function to wrap the step()
+in ``torch.compile()``.
+
+.. note::
+   
+   ``torch.compile`` is only supported on cuda devices with compute capability >= 7.0
+
+.. code-block:: python
+
+   # exit cleanly if we are on a device that doesn't support torch.compile
+   if torch.cuda.get_device_capability() < (7, 0):
+       print("Exiting because torch.compile is not supported on this device.")
+       import sys
+       sys.exit(0)
+
+
+   opt = torch.optim.Adam(model.parameters(), lr=0.01)
+
+
+   @torch.compile(fullgraph=False)
+   def fn():
+       opt.step()
+   
+   
+   # Let's define a helpful benchmarking function:
+   import torch.utils.benchmark as benchmark
+   
+   
+   def benchmark_torch_function_in_microseconds(f, *args, **kwargs):
+       t0 = benchmark.Timer(
+           stmt="f(*args, **kwargs)", globals={"args": args, "kwargs": kwargs, "f": f}
+       )
+       return t0.blocked_autorange().mean * 1e6
+
+
+   # Warmup runs to compile the function
+   for _ in range(5):
+       fn()
+   
+   eager_runtime = benchmark_torch_function_in_microseconds(opt.step)
+   compiled_runtime = benchmark_torch_function_in_microseconds(fn)
+   
+   assert eager_runtime > compiled_runtime
+   
+   print(f"eager runtime: {eager_runtime}us")
+   print(f"compiled runtime: {compiled_runtime}us")
+
+Sample Results:
+
+* Eager runtime: 747.2437149845064us
+* Compiled runtime: 392.07384741178us
+
+See Also
+~~~~~~~~~
+
+* For an in-depth technical overview, see
+`Compiling the optimizer with PT2 <https://dev-discuss.pytorch.org/t/compiling-the-optimizer-with-pt2/1669>`__
diff --git a/recipes_source/compiling_optimizer_lr_scheduler.py b/recipes_source/compiling_optimizer_lr_scheduler.py
new file mode 100644
index 00000000000..c0402729403
--- /dev/null
+++ b/recipes_source/compiling_optimizer_lr_scheduler.py
@@ -0,0 +1,117 @@
+"""
+(beta) Running the compiled optimizer with an LR Scheduler
+============================================================
+
+**Author:** `Michael Lazos <https://github.com/mlazos>`_
+"""
+
+#########################################################
+# The optimizer is a key algorithm for training any deep learning model.
+# In this example, we will show how to pair the optimizer, which has been compiled using ``torch.compile``,
+# with the LR schedulers to accelerate training convergence.
+#
+# .. note::
+#
+#    This tutorial requires PyTorch 2.3.0 or later.
+
+#####################################################################
+# Model Setup
+# ~~~~~~~~~~~~~~~~~~~~~
+# For this example, we'll use a simple sequence of linear layers.
+#
+
+import torch
+
+# Create simple model
+model = torch.nn.Sequential(
+    *[torch.nn.Linear(1024, 1024, False, device="cuda") for _ in range(10)]
+)
+input = torch.rand(1024, device="cuda")
+
+# run forward pass
+output = model(input)
+
+# run backward to populate the grads for our optimizer below
+output.sum().backward()
+
+
+#####################################################################
+# Setting up and running the compiled optimizer with LR Scheduler
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# In this section, we'll use the Adam optimizer with LinearLR Scheduler
+# and create a helper function to wrap the ``step()`` call for each of them
+# in ``torch.compile()``.
+#
+# .. note::
+#
+#    ``torch.compile`` is only supported on CUDA devices that have a compute capability of 7.0 or higher.
+
+
+# exit cleanly if we are on a device that doesn't support ``torch.compile``
+if torch.cuda.get_device_capability() < (7, 0):
+    print("Exiting because torch.compile is not supported on this device.")
+    import sys
+    sys.exit(0)
+
+# !!! IMPORTANT !!! Wrap the lr in a Tensor if we are pairing the
+# the optimizer with an LR Scheduler.
+# Without this, torch.compile will recompile as the value of the LR
+# changes.
+opt = torch.optim.Adam(model.parameters(), lr=torch.tensor(0.01))
+sched = torch.optim.lr_scheduler.LinearLR(opt, total_iters=5)
+
+@torch.compile(fullgraph=False)
+def fn():
+    opt.step()
+    sched.step()
+
+
+# Warmup runs to compile the function
+for _ in range(5):
+    fn()
+    print(opt.param_groups[0]["lr"])
+
+
+######################################################################
+# Extension: What happens with a non-tensor LR?
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# For the curious, we will show how to peek into what happens with ``torch.compile`` when we don't wrap the
+# LR in a tensor.
+
+# No longer wrap the LR in a tensor here
+opt = torch.optim.Adam(model.parameters(), lr=0.01)
+sched = torch.optim.lr_scheduler.LinearLR(opt, total_iters=5)
+
+@torch.compile(fullgraph=False)
+def fn():
+    opt.step()
+    sched.step()
+
+# Setup logging to view recompiles
+torch._logging.set_logs(recompiles=True)
+
+# Warmup runs to compile the function
+# We will now recompile on each iteration
+# as the value of the lr is mutated.
+for _ in range(5):
+    fn()
+
+
+######################################################################
+# With this example, we can see that we recompile the optimizer a few times
+# due to the guard failure on the ``lr`` in ``param_groups[0]``.
+
+######################################################################
+# Conclusion
+# ~~~~~~~~~~
+#
+# In this tutorial we showed how to pair the optimizer compiled with ``torch.compile``
+# with an LR Scheduler to accelerate training convergence. We used a model consisting
+# of a simple sequence of linear layers with the Adam optimizer paired
+# with a LinearLR scheduler to demonstrate the LR changing across iterations.
+#
+# See also:
+#
+# * `Compiled optimizer tutorial <https://pytorch.org/tutorials/recipes/compiling_optimizer.html>`__ - an intro into the compiled optimizer.
+# * `Compiling the optimizer with PT2 <https://dev-discuss.pytorch.org/t/compiling-the-optimizer-with-pt2/1669>`__ - deeper technical details on the compiled optimizer. 
diff --git a/recipes_source/distributed_async_checkpoint_recipe.rst b/recipes_source/distributed_async_checkpoint_recipe.rst
new file mode 100644
index 00000000000..e959883a25b
--- /dev/null
+++ b/recipes_source/distributed_async_checkpoint_recipe.rst
@@ -0,0 +1,289 @@
+Asynchronous Saving with Distributed Checkpoint (DCP)
+=====================================================
+
+**Author:** `Lucas Pasqualin <https://github.com/lucasllc>`__, `Iris Zhang <https://github.com/wz337>`__, `Rodrigo Kumpera <https://github.com/kumpera>`__, `Chien-Chin Huang <https://github.com/fegin>`__
+
+Checkpointing is often a bottle-neck in the critical path for distributed training workloads, incurring larger and larger costs as both model and world sizes grow.
+One excellent strategy for offsetting this cost is to checkpoint in parallel, asynchronously. Below, we expand the save example
+from the `Getting Started with Distributed Checkpoint Tutorial <https://github.com/pytorch/tutorials/blob/main/recipes_source/distributed_checkpoint_recipe.rst>`__
+to show how this can be integrated quite easily with ``torch.distributed.checkpoint.async_save``.
+
+
+.. grid:: 2
+
+    .. grid-item-card:: :octicon:`mortar-board;1em;` What you will learn
+       :class-card: card-prerequisites
+
+       * How to use DCP to generate checkpoints in parallel
+       * Effective strategies to optimize performance
+
+    .. grid-item-card:: :octicon:`list-unordered;1em;` Prerequisites
+       :class-card: card-prerequisites
+
+       * PyTorch v2.4.0 or later
+       * `Getting Started with Distributed Checkpoint Tutorial <https://github.com/pytorch/tutorials/blob/main/recipes_source/distributed_checkpoint_recipe.rst>`__
+
+
+Asynchronous Checkpointing Overview
+------------------------------------
+Before getting started with Asynchronous Checkpointing, it's important to understand it's differences and limitations as compared to synchronous checkpointing.
+Specifically:
+
+* Memory requirements - Asynchronous checkpointing works by first copying models into internal CPU-buffers.
+    This is helpful since it ensures model and optimizer weights are not changing while the model is still checkpointing,
+    but does raise CPU memory by a factor of ``checkpoint_size_per_rank X number_of_ranks``. Additionally, users should take care to understand
+    the memory constraints of their systems. Specifically, pinned memory implies the usage of ``page-lock`` memory, which can be scarce as compared to
+    ``pageable`` memory.
+
+* Checkpoint Management - Since checkpointing is asynchronous, it is up to the user to manage concurrently run checkpoints. In general, users can
+    employ their own management strategies by handling the future object returned form ``async_save``. For most users, we recommend limiting
+    checkpoints to one asynchronous request at a time, avoiding additional memory pressure per request.
+
+
+
+.. code-block:: python
+
+    import os
+
+    import torch
+    import torch.distributed as dist
+    import torch.distributed.checkpoint as dcp
+    import torch.multiprocessing as mp
+    import torch.nn as nn
+
+    from torch.distributed.fsdp import fully_shard
+    from torch.distributed.checkpoint.state_dict import get_state_dict, set_state_dict
+    from torch.distributed.checkpoint.stateful import Stateful
+
+    CHECKPOINT_DIR = "checkpoint"
+
+
+    class AppState(Stateful):
+        """This is a useful wrapper for checkpointing the Application State. Since this object is compliant
+        with the Stateful protocol, DCP will automatically call state_dict/load_stat_dict as needed in the
+        dcp.save/load APIs.
+
+        Note: We take advantage of this wrapper to hande calling distributed state dict methods on the model
+        and optimizer.
+        """
+
+        def __init__(self, model, optimizer=None):
+            self.model = model
+            self.optimizer = optimizer
+
+        def state_dict(self):
+            # this line automatically manages FSDP FQN's, as well as sets the default state dict type to FSDP.SHARDED_STATE_DICT
+            model_state_dict, optimizer_state_dict = get_state_dict(self.model, self.optimizer)
+            return {
+                "model": model_state_dict,
+                "optim": optimizer_state_dict
+            }
+
+        def load_state_dict(self, state_dict):
+            # sets our state dicts on the model and optimizer, now that we've loaded
+            set_state_dict(
+                self.model,
+                self.optimizer,
+                model_state_dict=state_dict["model"],
+                optim_state_dict=state_dict["optim"]
+            )
+
+    class ToyModel(nn.Module):
+        def __init__(self):
+            super(ToyModel, self).__init__()
+            self.net1 = nn.Linear(16, 16)
+            self.relu = nn.ReLU()
+            self.net2 = nn.Linear(16, 8)
+
+        def forward(self, x):
+            return self.net2(self.relu(self.net1(x)))
+
+
+    def setup(rank, world_size):
+        os.environ["MASTER_ADDR"] = "localhost"
+        os.environ["MASTER_PORT"] = "12355 "
+
+        # initialize the process group
+        dist.init_process_group("gloo", rank=rank, world_size=world_size)
+        torch.cuda.set_device(rank)
+
+
+    def cleanup():
+        dist.destroy_process_group()
+
+
+    def run_fsdp_checkpoint_save_example(rank, world_size):
+        print(f"Running basic FSDP checkpoint saving example on rank {rank}.")
+        setup(rank, world_size)
+
+        # create a model and move it to GPU with id rank
+        model = ToyModel().to(rank)
+        model = fully_shard(model)
+
+        loss_fn = nn.MSELoss()
+        optimizer = torch.optim.Adam(model.parameters(), lr=0.1)
+
+        checkpoint_future = None
+        for step in range(10):
+            optimizer.zero_grad()
+            model(torch.rand(8, 16, device="cuda")).sum().backward()
+            optimizer.step()
+
+            # waits for checkpointing to finish if one exists, avoiding queuing more then one checkpoint request at a time
+            if checkpoint_future is not None:
+                checkpoint_future.result()
+
+            state_dict = { "app": AppState(model, optimizer) }
+            checkpoint_future = dcp.async_save(state_dict, checkpoint_id=f"{CHECKPOINT_DIR}_step{step}")
+
+        cleanup()
+
+
+    if __name__ == "__main__":
+        world_size = torch.cuda.device_count()
+        print(f"Running async checkpoint example on {world_size} devices.")
+        mp.spawn(
+            run_fsdp_checkpoint_save_example,
+            args=(world_size,),
+            nprocs=world_size,
+            join=True,
+        )
+
+
+Even more performance with Pinned Memory
+-----------------------------------------
+If the above optimization is still not performant enough, you can take advantage of an additional optimization for GPU models which utilizes a pinned memory buffer for checkpoint staging.
+Specifically, this optimization attacks the main overhead of asynchronous checkpointing, which is the in-memory copying to checkpointing buffers. By maintaining a pinned memory buffer between
+checkpoint requests users can take advantage of direct memory access to speed up this copy.
+
+.. note::
+   The main drawback of this optimization is the persistence of the buffer in between checkpointing steps. Without
+   the pinned memory optimization (as demonstrated above), any checkpointing buffers are released as soon as
+   checkpointing is finished. With the pinned memory implementation, this buffer is maintained between steps,
+   leading to the same
+   peak memory pressure being sustained through the application life.
+
+
+.. code-block:: python
+
+    import os
+
+    import torch
+    import torch.distributed as dist
+    import torch.distributed.checkpoint as dcp
+    import torch.multiprocessing as mp
+    import torch.nn as nn
+
+    from torch.distributed.fsdp import fully_shard
+    from torch.distributed.checkpoint.state_dict import get_state_dict, set_state_dict
+    from torch.distributed.checkpoint.stateful import Stateful
+    from torch.distributed.checkpoint import FileSystemWriter as StorageWriter
+
+    CHECKPOINT_DIR = "checkpoint"
+
+
+    class AppState(Stateful):
+        """This is a useful wrapper for checkpointing the Application State. Since this object is compliant
+        with the Stateful protocol, DCP will automatically call state_dict/load_stat_dict as needed in the
+        dcp.save/load APIs.
+
+        Note: We take advantage of this wrapper to hande calling distributed state dict methods on the model
+        and optimizer.
+        """
+
+        def __init__(self, model, optimizer=None):
+            self.model = model
+            self.optimizer = optimizer
+
+        def state_dict(self):
+            # this line automatically manages FSDP FQN's, as well as sets the default state dict type to FSDP.SHARDED_STATE_DICT
+            model_state_dict, optimizer_state_dict = get_state_dict(self.model, self.optimizer)
+            return {
+                "model": model_state_dict,
+                "optim": optimizer_state_dict
+            }
+
+        def load_state_dict(self, state_dict):
+            # sets our state dicts on the model and optimizer, now that we've loaded
+            set_state_dict(
+                self.model,
+                self.optimizer,
+                model_state_dict=state_dict["model"],
+                optim_state_dict=state_dict["optim"]
+            )
+
+    class ToyModel(nn.Module):
+        def __init__(self):
+            super(ToyModel, self).__init__()
+            self.net1 = nn.Linear(16, 16)
+            self.relu = nn.ReLU()
+            self.net2 = nn.Linear(16, 8)
+
+        def forward(self, x):
+            return self.net2(self.relu(self.net1(x)))
+
+
+    def setup(rank, world_size):
+        os.environ["MASTER_ADDR"] = "localhost"
+        os.environ["MASTER_PORT"] = "12355 "
+
+        # initialize the process group
+        dist.init_process_group("gloo", rank=rank, world_size=world_size)
+        torch.cuda.set_device(rank)
+
+
+    def cleanup():
+        dist.destroy_process_group()
+
+
+    def run_fsdp_checkpoint_save_example(rank, world_size):
+        print(f"Running basic FSDP checkpoint saving example on rank {rank}.")
+        setup(rank, world_size)
+
+        # create a model and move it to GPU with id rank
+        model = ToyModel().to(rank)
+        model = fully_shard(model)
+
+        loss_fn = nn.MSELoss()
+        optimizer = torch.optim.Adam(model.parameters(), lr=0.1)
+
+        # The storage writer defines our 'staging' strategy, where staging is considered the process of copying
+        # checkpoints to in-memory buffers. By setting `cached_state_dict=True`, we enable efficient memory copying
+        # into a persistent buffer with pinned memory enabled.
+        # Note: It's important that the writer persists in between checkpointing requests, since it maintains the
+        # pinned memory buffer.
+        writer = StorageWriter(cache_staged_state_dict=True, path=CHECKPOINT_DIR)
+        checkpoint_future = None
+        for step in range(10):
+            optimizer.zero_grad()
+            model(torch.rand(8, 16, device="cuda")).sum().backward()
+            optimizer.step()
+
+            state_dict = { "app": AppState(model, optimizer) }
+            if checkpoint_future is not None:
+                # waits for checkpointing to finish, avoiding queuing more then one checkpoint request at a time
+                checkpoint_future.result()
+            checkpoint_future = dcp.async_save(state_dict, storage_writer=writer, checkpoint_id=f"{CHECKPOINT_DIR}_step{step}")
+
+        cleanup()
+
+
+    if __name__ == "__main__":
+        world_size = torch.cuda.device_count()
+        print(f"Running fsdp checkpoint example on {world_size} devices.")
+        mp.spawn(
+            run_fsdp_checkpoint_save_example,
+            args=(world_size,),
+            nprocs=world_size,
+            join=True,
+        )
+
+
+Conclusion
+----------
+In conclusion, we have learned how to use DCP's :func:`async_save` API to generate checkpoints off the critical training path. We've also learned about the
+additional memory and concurrency overhead introduced by using this API, as well as additional optimizations which utilize pinned memory to speed things up
+even further.
+
+-  `Saving and loading models tutorial <https://pytorch.org/tutorials/beginner/saving_loading_models.html>`__
+-  `Getting started with FullyShardedDataParallel tutorial <https://pytorch.org/tutorials/intermediate/FSDP_tutorial.html>`__
diff --git a/recipes_source/distributed_checkpoint_recipe.rst b/recipes_source/distributed_checkpoint_recipe.rst
new file mode 100644
index 00000000000..de31d430402
--- /dev/null
+++ b/recipes_source/distributed_checkpoint_recipe.rst
@@ -0,0 +1,367 @@
+Getting Started with Distributed Checkpoint (DCP)
+=====================================================
+
+**Author**: `Iris Zhang <https://github.com/wz337>`__, `Rodrigo Kumpera <https://github.com/kumpera>`__, `Chien-Chin Huang <https://github.com/fegin>`__, `Lucas Pasqualin <https://github.com/lucasllc>`__
+
+.. note::
+   |edit| View and edit this tutorial in `github <https://github.com/pytorch/tutorials/blob/main/recipes_source/distributed_checkpoint_recipe.rst>`__.
+
+
+Prerequisites:
+
+-  `FullyShardedDataParallel API documents <https://pytorch.org/docs/master/fsdp.html>`__
+-  `torch.load API documents <https://pytorch.org/docs/stable/generated/torch.load.html>`__
+
+
+Checkpointing AI models during distributed training could be challenging, as parameters and gradients are partitioned across trainers and the number of trainers available could change when you resume training.
+Pytorch Distributed Checkpointing (DCP) can help make this process easier.
+
+In this tutorial, we show how to use DCP APIs with a simple FSDP wrapped model.
+
+
+How DCP works
+--------------
+
+:func:`torch.distributed.checkpoint` enables saving and loading models from multiple ranks in parallel. You can use this module to save on any number of ranks in parallel,
+and then re-shard across differing cluster topologies at load time.
+
+Addditionally, through the use of modules in :func:`torch.distributed.checkpoint.state_dict`,
+DCP offers support for gracefully handling ``state_dict`` generation and loading in distributed settings.
+This includes managing fully-qualified-name (FQN) mappings across models and optimizers, and setting default parameters for PyTorch provided parallelisms.
+
+DCP is different from :func:`torch.save` and :func:`torch.load` in a few significant ways:
+
+* It produces multiple files per checkpoint, with at least one per rank.
+* It operates in place, meaning that the model should allocate its data first and DCP uses that storage instead.
+* DCP offers special handling of Stateful objects (formally defined in `torch.distributed.checkpoint.stateful`), automatically calling both `state_dict` and `load_state_dict` methods if they are defined.
+
+.. note::
+  The code in this tutorial runs on an 8-GPU server, but it can be easily
+  generalized to other environments.
+
+How to use DCP
+--------------
+
+Here we use a toy model wrapped with FSDP for demonstration purposes. Similarly, the APIs and logic can be applied to larger models for checkpointing.
+
+Saving
+~~~~~~
+
+Now, let's create a toy module, wrap it with FSDP, feed it with some dummy input data, and save it.
+
+.. code-block:: python
+
+    import os
+
+    import torch
+    import torch.distributed as dist
+    import torch.distributed.checkpoint as dcp
+    import torch.multiprocessing as mp
+    import torch.nn as nn
+
+    from torch.distributed.fsdp import fully_shard
+    from torch.distributed.checkpoint.state_dict import get_state_dict, set_state_dict
+    from torch.distributed.checkpoint.stateful import Stateful
+
+    CHECKPOINT_DIR = "checkpoint"
+
+
+    class AppState(Stateful):
+        """This is a useful wrapper for checkpointing the Application State. Since this object is compliant
+        with the Stateful protocol, DCP will automatically call state_dict/load_stat_dict as needed in the
+        dcp.save/load APIs.
+
+        Note: We take advantage of this wrapper to hande calling distributed state dict methods on the model
+        and optimizer.
+        """
+
+        def __init__(self, model, optimizer=None):
+            self.model = model
+            self.optimizer = optimizer
+
+        def state_dict(self):
+            # this line automatically manages FSDP FQN's, as well as sets the default state dict type to FSDP.SHARDED_STATE_DICT
+            model_state_dict, optimizer_state_dict = get_state_dict(self.model, self.optimizer)
+            return {
+                "model": model_state_dict,
+                "optim": optimizer_state_dict
+            }
+
+        def load_state_dict(self, state_dict):
+            # sets our state dicts on the model and optimizer, now that we've loaded
+            set_state_dict(
+                self.model,
+                self.optimizer,
+                model_state_dict=state_dict["model"],
+                optim_state_dict=state_dict["optim"]
+            )
+
+    class ToyModel(nn.Module):
+        def __init__(self):
+            super(ToyModel, self).__init__()
+            self.net1 = nn.Linear(16, 16)
+            self.relu = nn.ReLU()
+            self.net2 = nn.Linear(16, 8)
+
+        def forward(self, x):
+            return self.net2(self.relu(self.net1(x)))
+
+
+    def setup(rank, world_size):
+        os.environ["MASTER_ADDR"] = "localhost"
+        os.environ["MASTER_PORT"] = "12355 "
+
+        # initialize the process group
+        dist.init_process_group("nccl", rank=rank, world_size=world_size)
+        torch.cuda.set_device(rank)
+
+
+    def cleanup():
+        dist.destroy_process_group()
+
+
+    def run_fsdp_checkpoint_save_example(rank, world_size):
+        print(f"Running basic FSDP checkpoint saving example on rank {rank}.")
+        setup(rank, world_size)
+
+        # create a model and move it to GPU with id rank
+        model = ToyModel().to(rank)
+        model = fully_shard(model)
+
+        loss_fn = nn.MSELoss()
+        optimizer = torch.optim.Adam(model.parameters(), lr=0.1)
+
+        optimizer.zero_grad()
+        model(torch.rand(8, 16, device="cuda")).sum().backward()
+        optimizer.step()
+
+        state_dict = { "app": AppState(model, optimizer) }
+        dcp.save(state_dict, checkpoint_id=CHECKPOINT_DIR)
+
+        cleanup()
+
+
+    if __name__ == "__main__":
+        world_size = torch.cuda.device_count()
+        print(f"Running fsdp checkpoint example on {world_size} devices.")
+        mp.spawn(
+            run_fsdp_checkpoint_save_example,
+            args=(world_size,),
+            nprocs=world_size,
+            join=True,
+        )
+
+Please go ahead and check the `checkpoint` directory. You should see checkpoint files corresponding to the number of files as shown below. For example, if you have 8 devices, you should see 8 files.
+
+.. figure:: /_static/img/distributed/distributed_checkpoint_generated_files.png
+   :width: 100%
+   :align: center
+   :alt: Distributed Checkpoint
+
+Loading
+~~~~~~~
+
+After saving, let’s create the same FSDP-wrapped model, and load the saved state dict from storage into the model. You can load in the same world size or different world size.
+
+Please note that you will have to call :func:`model.state_dict` prior to loading and pass it to DCP's :func:`load_state_dict` API.
+This is fundamentally different from :func:`torch.load`, as :func:`torch.load` simply requires the path to the checkpoint prior for loading.
+The reason that we need the ``state_dict`` prior to loading is:
+
+* DCP uses the pre-allocated storage from model state_dict to load from the checkpoint directory. During loading, the state_dict passed in will be updated in place.
+* DCP requires the sharding information from the model prior to loading to support resharding.
+
+.. code-block:: python
+
+    import os
+
+    import torch
+    import torch.distributed as dist
+    import torch.distributed.checkpoint as dcp
+    from torch.distributed.checkpoint.stateful import Stateful
+    from torch.distributed.checkpoint.state_dict import get_state_dict, set_state_dict
+    import torch.multiprocessing as mp
+    import torch.nn as nn
+
+    from torch.distributed.fsdp import fully_shard
+
+    CHECKPOINT_DIR = "checkpoint"
+
+
+    class AppState(Stateful):
+        """This is a useful wrapper for checkpointing the Application State. Since this object is compliant
+        with the Stateful protocol, DCP will automatically call state_dict/load_stat_dict as needed in the
+        dcp.save/load APIs.
+
+        Note: We take advantage of this wrapper to hande calling distributed state dict methods on the model
+        and optimizer.
+        """
+
+        def __init__(self, model, optimizer=None):
+            self.model = model
+            self.optimizer = optimizer
+
+        def state_dict(self):
+            # this line automatically manages FSDP FQN's, as well as sets the default state dict type to FSDP.SHARDED_STATE_DICT
+            model_state_dict, optimizer_state_dict = get_state_dict(self.model, self.optimizer)
+            return {
+                "model": model_state_dict,
+                "optim": optimizer_state_dict
+            }
+
+        def load_state_dict(self, state_dict):
+            # sets our state dicts on the model and optimizer, now that we've loaded
+            set_state_dict(
+                self.model,
+                self.optimizer,
+                model_state_dict=state_dict["model"],
+                optim_state_dict=state_dict["optim"]
+            )
+
+    class ToyModel(nn.Module):
+        def __init__(self):
+            super(ToyModel, self).__init__()
+            self.net1 = nn.Linear(16, 16)
+            self.relu = nn.ReLU()
+            self.net2 = nn.Linear(16, 8)
+
+        def forward(self, x):
+            return self.net2(self.relu(self.net1(x)))
+
+
+    def setup(rank, world_size):
+        os.environ["MASTER_ADDR"] = "localhost"
+        os.environ["MASTER_PORT"] = "12355 "
+
+        # initialize the process group
+        dist.init_process_group("nccl", rank=rank, world_size=world_size)
+        torch.cuda.set_device(rank)
+
+
+    def cleanup():
+        dist.destroy_process_group()
+
+
+    def run_fsdp_checkpoint_load_example(rank, world_size):
+        print(f"Running basic FSDP checkpoint loading example on rank {rank}.")
+        setup(rank, world_size)
+
+        # create a model and move it to GPU with id rank
+        model = ToyModel().to(rank)
+        model = fully_shard(model)
+
+        optimizer = torch.optim.Adam(model.parameters(), lr=0.1)
+
+        state_dict = { "app": AppState(model, optimizer)}
+        dcp.load(
+            state_dict=state_dict,
+            checkpoint_id=CHECKPOINT_DIR,
+        )
+
+        cleanup()
+
+
+    if __name__ == "__main__":
+        world_size = torch.cuda.device_count()
+        print(f"Running fsdp checkpoint example on {world_size} devices.")
+        mp.spawn(
+            run_fsdp_checkpoint_load_example,
+            args=(world_size,),
+            nprocs=world_size,
+            join=True,
+        )
+
+If you would like to load the saved checkpoint into a non-FSDP wrapped model in a non-distributed setup, perhaps for inference, you can also do that with DCP.
+By default, DCP saves and loads a distributed ``state_dict`` in Single Program Multiple Data(SPMD) style. However if no process group is initialized, DCP infers
+the intent is to save or load in "non-distributed" style, meaning entirely in the current process.
+
+.. note::
+  Distributed checkpoint support for Multi-Program Multi-Data is still under development.
+
+.. code-block:: python
+
+    import os
+
+    import torch
+    import torch.distributed.checkpoint as dcp
+    import torch.nn as nn
+
+
+    CHECKPOINT_DIR = "checkpoint"
+
+
+    class ToyModel(nn.Module):
+        def __init__(self):
+            super(ToyModel, self).__init__()
+            self.net1 = nn.Linear(16, 16)
+            self.relu = nn.ReLU()
+            self.net2 = nn.Linear(16, 8)
+
+        def forward(self, x):
+            return self.net2(self.relu(self.net1(x)))
+
+
+    def run_checkpoint_load_example():
+        # create the non FSDP-wrapped toy model
+        model = ToyModel()
+        state_dict = {
+            "model": model.state_dict(),
+        }
+
+        # since no progress group is initialized, DCP will disable any collectives.
+        dcp.load(
+            state_dict=state_dict,
+            checkpoint_id=CHECKPOINT_DIR,
+        )
+        model.load_state_dict(state_dict["model"])
+
+    if __name__ == "__main__":
+        print(f"Running basic DCP checkpoint loading example.")
+        run_checkpoint_load_example()
+
+
+Formats
+----------
+One drawback not yet mentioned is that DCP saves checkpoints in a format which is inherently different then those generated using torch.save.
+Since this can be an issue when users wish to share models with users used to the torch.save format, or in general just want to add format flexibility
+to their applications. For this case, we provide the ``format_utils`` module in ``torch.distributed.checkpoint.format_utils``.
+
+A command line utility is provided for the users convenience, which follows the following format:
+
+.. code-block:: bash
+
+    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``.
+
+
+Alternatively, methods are also provided for users who may wish to convert checkpoints directly.
+
+.. code-block:: python
+
+    import os
+
+    import torch
+    import torch.distributed.checkpoint as DCP
+    from torch.distributed.checkpoint.format_utils import dcp_to_torch_save, torch_save_to_dcp
+
+    CHECKPOINT_DIR = "checkpoint"
+    TORCH_SAVE_CHECKPOINT_DIR = "torch_save_checkpoint.pth"
+
+    # convert dcp model to torch.save (assumes checkpoint was generated as above)
+    dcp_to_torch_save(CHECKPOINT_DIR, TORCH_SAVE_CHECKPOINT_DIR)
+
+    # converts the torch.save model back to DCP
+    torch_save_to_dcp(TORCH_SAVE_CHECKPOINT_DIR, f"{CHECKPOINT_DIR}_new")
+
+
+
+Conclusion
+----------
+In conclusion, we have learned how to use DCP's :func:`save` and :func:`load` APIs, as well as how they are different form :func:`torch.save` and :func:`torch.load`.
+Additionally, we've learned how to use :func:`get_state_dict` and :func:`set_state_dict` to automatically manage parallelism-specific FQN's and defaults during state dict
+generation and loading.
+
+For more information, please see the following:
+
+-  `Saving and loading models tutorial <https://pytorch.org/tutorials/beginner/saving_loading_models.html>`__
+-  `Getting started with FullyShardedDataParallel tutorial <https://pytorch.org/tutorials/intermediate/FSDP_tutorial.html>`__
diff --git a/recipes_source/distributed_comm_debug_mode.rst b/recipes_source/distributed_comm_debug_mode.rst
new file mode 100644
index 00000000000..dc1a6e3e565
--- /dev/null
+++ b/recipes_source/distributed_comm_debug_mode.rst
@@ -0,0 +1,210 @@
+Getting Started with ``CommDebugMode``
+=====================================================
+
+**Author**: `Anshul Sinha <https://github.com/sinhaanshul>`__
+
+
+In this tutorial, we will explore how to use ``CommDebugMode`` with PyTorch's
+DistributedTensor (DTensor) for debugging by tracking collective operations in distributed training environments.
+
+Prerequisites
+---------------------
+
+* Python 3.8 - 3.11
+* PyTorch 2.2 or later
+
+
+What is ``CommDebugMode`` and why is it useful
+----------------------------------------------------
+As the size of models continues to increase, users are seeking to leverage various combinations
+of parallel strategies to scale up distributed training. However, the lack of interoperability
+between existing solutions poses a significant challenge, primarily due to the absence of a
+unified abstraction that can bridge these different parallelism strategies. To address this
+issue, PyTorch has proposed `DistributedTensor(DTensor)
+<https://github.com/pytorch/pytorch/blob/main/torch/distributed/tensor/examples/comm_mode_features_example.py>`_
+which abstracts away the complexities of tensor communication in distributed training,
+providing a seamless user experience. However, when dealing with existing parallelism solutions and
+developing parallelism solutions using the unified abstraction like DTensor, the lack of transparency
+about what and when the collective communications happens under the hood could make it challenging
+for advanced users to identify and resolve issues. To address this challenge, ``CommDebugMode``, a
+Python context manager will serve as one of the primary debugging tools for DTensors, enabling
+users to view when and why collective operations are happening when using DTensors, effectively
+addressing this issue.
+
+
+Using ``CommDebugMode``
+------------------------
+
+Here is how you can use ``CommDebugMode``:
+
+.. code-block:: python
+
+    # The model used in this example is a MLPModule applying Tensor Parallel
+    comm_mode = CommDebugMode()
+        with comm_mode:
+            output = model(inp)
+
+    # print the operation level collective tracing information
+    print(comm_mode.generate_comm_debug_tracing_table(noise_level=0))
+
+    # log the operation level collective tracing information to a file
+    comm_mode.log_comm_debug_tracing_table_to_file(
+        noise_level=1, file_name="transformer_operation_log.txt"
+    )
+
+    # dump the operation level collective tracing information to json file,
+    # used in the visual browser below
+    comm_mode.generate_json_dump(noise_level=2)
+
+This is what the output looks like for a MLPModule at noise level 0:
+
+.. code-block:: python
+
+    Expected Output:
+        Global
+          FORWARD PASS
+            *c10d_functional.all_reduce: 1
+            MLPModule
+              FORWARD PASS
+                *c10d_functional.all_reduce: 1
+                MLPModule.net1
+                MLPModule.relu
+                MLPModule.net2
+                  FORWARD PASS
+                    *c10d_functional.all_reduce: 1
+
+To use ``CommDebugMode``, you must wrap the code running the model in ``CommDebugMode`` and call the API that
+you want to use to display the data. You can also use a ``noise_level`` argument to control the verbosity
+level of displayed information. Here is what each noise level displays:
+
+| 0. Prints module-level collective counts
+| 1. Prints DTensor operations (not including trivial operations), module sharding information
+| 2. Prints tensor operations (not including trivial operations)
+| 3. Prints all operations
+
+In the example above, you can see that the collective operation, all_reduce, occurs once in the forward pass
+of the ``MLPModule``. Furthermore, you can use ``CommDebugMode`` to pinpoint that the all-reduce operation happens
+in the second linear layer of the ``MLPModule``.
+
+
+Below is the interactive module tree visualization that you can use to upload your own JSON dump:
+
+.. raw:: html
+
+    <!DOCTYPE html>
+    <html lang ="en">
+    <head>
+        <meta charset="UTF-8">
+        <meta name = "viewport" content="width=device-width, initial-scale=1.0">
+        <title>CommDebugMode Module Tree</title>
+        <style>
+            ul, #tree-container {
+                list-style-type: none;
+                margin: 0;
+                padding: 0;
+            }
+            .caret {
+                cursor: pointer;
+                user-select: none;
+            }
+            .caret::before {
+                content: "\25B6";
+                color:black;
+                display: inline-block;
+                margin-right: 6px;
+            }
+            .caret-down::before {
+                transform: rotate(90deg);
+            }
+            .tree {
+                padding-left: 20px;
+            }
+            .tree ul {
+                padding-left: 20px;
+            }
+            .nested {
+                display: none;
+            }
+            .active {
+                display: block;
+            }
+            .forward-pass,
+            .backward-pass {
+                margin-left: 40px;
+            }
+            .forward-pass table {
+                margin-left: 40px;
+                width: auto;
+            }
+            .forward-pass table td, .forward-pass table th {
+                padding: 8px;
+            }
+            .forward-pass ul {
+                display: none;
+            }
+            table {
+                font-family: arial, sans-serif;
+                border-collapse: collapse;
+                width: 100%;
+            }
+            td, th {
+                border: 1px solid #dddddd;
+                text-align: left;
+                padding: 8px;
+            }
+            tr:nth-child(even) {
+                background-color: #dddddd;
+            }
+            #drop-area {
+                position: relative;
+                width: 25%;
+                height: 100px;
+                border: 2px dashed #ccc;
+                border-radius: 5px;
+                padding: 0px;
+                text-align: center;
+            }
+            .drag-drop-block {
+                display: inline-block;
+                width: 200px;
+                height: 50px;
+                background-color: #f7f7f7;
+                border: 1px solid #ccc;
+                border-radius: 5px;
+                padding: 10px;
+                font-size: 14px;
+                color: #666;
+                cursor: pointer;
+            }
+            #file-input {
+                position: absolute;
+                top: 0;
+                left: 0;
+                width: 100%;
+                height: 100%;
+                opacity: 0;
+            }
+        </style>
+    </head>
+    <body>
+        <div id="drop-area">
+            <div class="drag-drop-block">
+              <span>Drag file here</span>
+            </div>
+            <input type="file" id="file-input" accept=".json">
+          </div>
+        <div id="tree-container"></div>
+        <script src="https://cdn.jsdelivr.net/gh/pytorch/pytorch@main/torch/distributed/tensor/debug/comm_mode_broswer_visual.js"></script>
+    </body>
+    </html>
+
+Conclusion
+------------------------------------------
+
+In this recipe, we have learned how to use ``CommDebugMode`` to debug Distributed Tensors and
+parallelism solutions that uses communication collectives with PyTorch. You can use your own
+JSON outputs in the embedded visual browser.
+
+For more detailed information about ``CommDebugMode``, see
+`comm_mode_features_example.py
+<https://github.com/pytorch/pytorch/blob/main/torch/distributed/tensor/examples/comm_mode_features_example.py>`_
diff --git a/recipes_source/distributed_device_mesh.rst b/recipes_source/distributed_device_mesh.rst
new file mode 100644
index 00000000000..3a04b8de4bf
--- /dev/null
+++ b/recipes_source/distributed_device_mesh.rst
@@ -0,0 +1,179 @@
+Getting Started with DeviceMesh
+=====================================================
+
+**Author**: `Iris Zhang <https://github.com/wz337>`__, `Wanchao Liang <https://github.com/wanchaol>`__
+
+.. note::
+   |edit| View and edit this tutorial in `github <https://github.com/pytorch/tutorials/blob/main/recipes_source/distributed_device_mesh.rst>`__.
+
+Prerequisites:
+
+- `Distributed Communication Package - torch.distributed <https://pytorch.org/docs/stable/distributed.html>`__
+- Python 3.8 - 3.11
+- PyTorch 2.2
+
+
+Setting up distributed communicators, i.e. NVIDIA Collective Communication Library (NCCL) communicators, for distributed training can pose a significant challenge. For workloads where users need to compose different parallelisms,
+users would need to manually set up and manage NCCL communicators (for example, :class:`ProcessGroup`) for each parallelism solution. This process could be complicated and susceptible to errors.
+:class:`DeviceMesh` can simplify this process, making it more manageable and less prone to errors.
+
+What is DeviceMesh
+------------------
+:class:`DeviceMesh` is a higher level abstraction that manages :class:`ProcessGroup`. It allows users to effortlessly
+create inter-node and intra-node process groups without worrying about how to set up ranks correctly for different sub process groups.
+Users can also easily manage the underlying process_groups/devices for multi-dimensional parallelism via :class:`DeviceMesh`.
+
+.. figure:: /_static/img/distributed/device_mesh.png
+   :width: 100%
+   :align: center
+   :alt: PyTorch DeviceMesh
+
+Why DeviceMesh is Useful
+------------------------
+DeviceMesh is useful when working with multi-dimensional parallelism (i.e. 3-D parallel) where parallelism composability is required. For example, when your parallelism solutions require both communication across hosts and within each host.
+The image above shows that we can create a 2D mesh that connects the devices within each host, and connects each device with its counterpart on the other hosts in a homogeneous setup.
+
+Without DeviceMesh, users would need to manually set up NCCL communicators, cuda devices on each process before applying any parallelism, which could be quite complicated.
+The following code snippet illustrates a hybrid sharding 2-D Parallel pattern setup without :class:`DeviceMesh`.
+First, we need to manually calculate the shard group and replicate group. Then, we need to assign the correct shard and
+replicate group to each rank.
+
+.. code-block:: python
+
+    import os
+
+    import torch
+    import torch.distributed as dist
+
+    # Understand world topology
+    rank = int(os.environ["RANK"])
+    world_size = int(os.environ["WORLD_SIZE"])
+    print(f"Running example on {rank=} in a world with {world_size=}")
+
+    # Create process groups to manage 2-D like parallel pattern
+    dist.init_process_group("nccl")
+    torch.cuda.set_device(rank)
+
+    # Create shard groups (e.g. (0, 1, 2, 3), (4, 5, 6, 7))
+    # and assign the correct shard group to each rank
+    num_node_devices = torch.cuda.device_count()
+    shard_rank_lists = list(range(0, num_node_devices // 2)), list(range(num_node_devices // 2, num_node_devices))
+    shard_groups = (
+        dist.new_group(shard_rank_lists[0]),
+        dist.new_group(shard_rank_lists[1]),
+    )
+    current_shard_group = (
+        shard_groups[0] if rank in shard_rank_lists[0] else shard_groups[1]
+    )
+
+    # Create replicate groups (for example, (0, 4), (1, 5), (2, 6), (3, 7))
+    # and assign the correct replicate group to each rank
+    current_replicate_group = None
+    shard_factor = len(shard_rank_lists[0])
+    for i in range(num_node_devices // 2):
+        replicate_group_ranks = list(range(i, num_node_devices, shard_factor))
+        replicate_group = dist.new_group(replicate_group_ranks)
+        if rank in replicate_group_ranks:
+            current_replicate_group = replicate_group
+
+To run the above code snippet, we can leverage PyTorch Elastic. Let's create a file named ``2d_setup.py``.
+Then, run the following `torch elastic/torchrun <https://pytorch.org/docs/stable/elastic/quickstart.html>`__ command.
+
+.. code-block:: python
+
+    torchrun --nproc_per_node=8 --rdzv_id=100 --rdzv_endpoint=localhost:29400 2d_setup.py
+
+.. note::
+    For simplicity of demonstration, we are simulating 2D parallel using only one node. Note that this code snippet can also be used when running on multi hosts setup.
+
+With the help of :func:`init_device_mesh`, we can accomplish the above 2D setup in just two lines, and we can still
+access the underlying :class:`ProcessGroup` if needed.
+
+
+.. code-block:: python
+
+    from torch.distributed.device_mesh import init_device_mesh
+    mesh_2d = init_device_mesh("cuda", (2, 4), mesh_dim_names=("replicate", "shard"))
+
+    # Users can access the underlying process group thru `get_group` API.
+    replicate_group = mesh_2d.get_group(mesh_dim="replicate")
+    shard_group = mesh_2d.get_group(mesh_dim="shard")
+
+Let's create a file named ``2d_setup_with_device_mesh.py``.
+Then, run the following `torch elastic/torchrun <https://pytorch.org/docs/stable/elastic/quickstart.html>`__ command.
+
+.. code-block:: python
+
+    torchrun --nproc_per_node=8 2d_setup_with_device_mesh.py
+
+
+How to use DeviceMesh with HSDP
+-------------------------------
+
+Hybrid Sharding Data Parallel(HSDP) is 2D strategy to perform FSDP within a host and DDP across hosts.
+
+Let's see an example of how DeviceMesh can assist with applying HSDP to your model with a simple setup. With DeviceMesh,
+users would not need to manually create and manage shard group and replicate group.
+
+.. code-block:: python
+
+    import torch
+    import torch.nn as nn
+
+    from torch.distributed.device_mesh import init_device_mesh
+    from torch.distributed.fsdp import fully_shard as FSDP
+
+
+    class ToyModel(nn.Module):
+        def __init__(self):
+            super(ToyModel, self).__init__()
+            self.net1 = nn.Linear(10, 10)
+            self.relu = nn.ReLU()
+            self.net2 = nn.Linear(10, 5)
+
+        def forward(self, x):
+            return self.net2(self.relu(self.net1(x)))
+
+
+    # HSDP: MeshShape(2, 4)
+    mesh_2d = init_device_mesh("cuda", (2, 4), mesh_dim_names=("dp_replicate", "dp_shard"))
+    model = FSDP(
+        ToyModel(), device_mesh=mesh_2d
+    )
+
+Let's create a file named ``hsdp.py``.
+Then, run the following `torch elastic/torchrun <https://pytorch.org/docs/stable/elastic/quickstart.html>`__ command.
+
+.. code-block:: python
+
+    torchrun --nproc_per_node=8 hsdp.py
+
+How to use DeviceMesh for your custom parallel solutions
+--------------------------------------------------------
+When working with large scale training, you might have more complex custom parallel training composition. For example, you may need to slice out sub-meshes for different parallelism solutions.
+DeviceMesh allows users to slice child mesh from the parent mesh and re-use the NCCL communicators already created when the parent mesh is initialized.
+
+.. code-block:: python
+
+    from torch.distributed.device_mesh import init_device_mesh
+    mesh_3d = init_device_mesh("cuda", (2, 2, 2), mesh_dim_names=("replicate", "shard", "tp"))
+
+    # Users can slice child meshes from the parent mesh.
+    hsdp_mesh = mesh_3d["replicate", "shard"]
+    tp_mesh = mesh_3d["tp"]
+
+    # Users can access the underlying process group thru `get_group` API.
+    replicate_group = hsdp_mesh["replicate"].get_group()
+    shard_group = hsdp_mesh["shard"].get_group()
+    tp_group = tp_mesh.get_group()
+
+
+Conclusion
+----------
+In conclusion, we have learned about :class:`DeviceMesh` and :func:`init_device_mesh`, as well as how
+they can be used to describe the layout of devices across the cluster.
+
+For more information, please see the following:
+
+- `2D parallel combining Tensor/Sequence Parallel with FSDP <https://github.com/pytorch/examples/blob/main/distributed/tensor_parallelism/fsdp_tp_example.py>`__
+- `Composable PyTorch Distributed with PT2 <https://static.sched.com/hosted_files/pytorch2023/d1/%5BPTC%2023%5D%20Composable%20PyTorch%20Distributed%20with%20PT2.pdf>`__
diff --git a/recipes_source/distributed_optim_torchscript.rst b/recipes_source/distributed_optim_torchscript.rst
new file mode 100644
index 00000000000..01bc497d38e
--- /dev/null
+++ b/recipes_source/distributed_optim_torchscript.rst
@@ -0,0 +1,6 @@
+..
+  TODO(gmagogsfm): Replace/delete this document by 2.9 release. https://github.com/pytorch/tutorials/issues/3456
+
+.. warning::
+    TorchScript is deprecated, please use 
+    `torch.export <https://docs.pytorch.org/tutorials/intermediate/torch_export_tutorial.html>`__ instead.
\ No newline at end of file
diff --git a/recipes_source/distributed_rpc_profiling.rst b/recipes_source/distributed_rpc_profiling.rst
new file mode 100644
index 00000000000..a98ef2d5194
--- /dev/null
+++ b/recipes_source/distributed_rpc_profiling.rst
@@ -0,0 +1,10 @@
+Profiling PyTorch RPC-Based Workloads
+======================================
+
+This tutorial has been deprecated.
+
+Redirecting to home page.
+
+.. raw:: html
+
+   <meta http-equiv="Refresh" content="2; url='https://pytorch.org/tutorials'" />
diff --git a/recipes_source/foreach_map.py b/recipes_source/foreach_map.py
new file mode 100644
index 00000000000..0225a77e279
--- /dev/null
+++ b/recipes_source/foreach_map.py
@@ -0,0 +1,204 @@
+"""
+Explicit horizontal fusion with foreach_map and torch.compile
+===============================================================
+
+**Author:** `Michael Lazos <https://github.com/mlazos>`_
+"""
+
+#########################################################
+#  Horizontal fusion is a key optimization in ML compilers. In eager,
+#  this is typically expressed using the torch._foreach* ops which parallelizes
+#  operations across a list of tensors. However, supporting all possible permutations
+#  of arguments is quite difficult (e.g. mixtures of scalars and lists). Foreach_map
+#  allows conversion of any pointwise op in ``torch`` to a horiztonally fused foreach
+#  variant. In this tutorial, we will demonstrate how to implement the Adam optimizer
+#  with ``foreach_map`` to generate a fully fused kernel.  
+#
+# .. note::
+#
+#    This recipe describes a prototype feature. Prototype features are typically
+#    at an early stage for feedback and testing and are subject to change.
+#
+# Prerequisites
+# -------------
+#
+# * PyTorch v2.7.0 or later
+#
+
+#####################################################################
+# Model Setup
+# ~~~~~~~~~~~~~~~~~~~~~
+# For this example, we'll use a simple sequence of linear layers.
+# We instantiate an independent copy to compare the two optimizer implementations.
+#
+import torch
+
+# exit cleanly if we are on a device that doesn't support ``torch.compile``
+if torch.cuda.get_device_capability() < (7, 0):
+    print("Exiting because torch.compile is not supported on this device.")
+    import sys
+    sys.exit(0)
+
+# Create simple model
+model = torch.nn.Sequential(
+    *[torch.nn.Linear(1024, 1024, False, device="cuda") for _ in range(10)]
+)
+model_copy = torch.nn.Sequential(
+    *[torch.nn.Linear(1024, 1024, False, device="cuda") for _ in range(10)]
+)
+input = torch.rand(1024, device="cuda")
+
+# run forward pass
+output = model(input)
+output_copy = model_copy(input)
+
+# run backward to populate the grads for our optimizer below
+output.sum().backward()
+output_copy.sum().backward()
+
+#####################################################################
+# Helper functions for foreach_map implementation
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# In this section, we'll begin our implementation of the Adam optimizer.
+#
+from torch._higher_order_ops.foreach_map import foreach_map
+
+# Helper function to extract optimizer states from a torch.optim.Adam instance
+def get_inputs(optim):
+    steps = []
+    params = []
+    grads = []
+    exp_avgs = []
+    exp_avg_sqs = []
+    for group in optim.param_groups:
+        for p in group["params"]:
+            params.append(p)
+            grads.append(p.grad)
+            state = optim.state[p]
+            exp_avgs.append(state["exp_avg"])
+            exp_avg_sqs.append(state["exp_avg_sq"])
+            steps.append(state["step"])
+
+    return steps, params, exp_avgs, exp_avg_sqs
+
+
+# Functions to update the different optimizer states
+def update_exp_avg_sq(exp_avg_sq, grad, beta2):
+    return exp_avg_sq.mul(beta2).addcmul(grad, grad, value=1 - beta2)
+
+def update_param(param, step, exp_avg, exp_avg_sq, beta1, beta2, lr, eps):
+    bias_correction1 = 1 - torch.pow(beta1, step)
+    bias_correction2 = (1 - torch.pow(beta2, step)).sqrt()
+    step_size = (lr / bias_correction1).neg()
+    denom = (exp_avg_sq.sqrt() / (bias_correction2 * step_size)).add(eps / step_size)
+    return torch.add(param, torch.div(exp_avg, denom))
+
+# Our full Adam implementation
+def foreach_map_adam(
+    steps,
+    params,
+    exp_avgs,
+    exp_avg_sqs,
+    weight_decay=0,
+    beta1=0.9,
+    beta2=0.999,
+    lr=1e-3,
+    eps=1e-8,
+):
+    with torch.no_grad():
+        grads = [param.grad for param in params]
+        # update step
+        updated_steps = foreach_map(lambda x: x + 1, steps)
+        torch._foreach_copy_(steps, updated_steps)
+
+        if weight_decay != 0:
+            foreach_map(torch.add, (grads,), alpha=weight_decay)
+
+        # Higher-order operators (HOPs) cannot have multiple outputs at the moment
+        # need to call foreach_map once for each output
+        exp_avgs_updated = foreach_map(torch.lerp, exp_avgs, grads, 1 - beta1)
+        exp_avgs_sq_updated = foreach_map(update_exp_avg_sq, exp_avg_sqs, grads, beta2)
+        params_updated = foreach_map(
+            update_param,
+            params,
+            steps,
+            exp_avgs_updated,
+            exp_avgs_sq_updated,
+            beta1,
+            beta2,
+            lr,
+            eps,
+        )
+        # Higher-order operators (HOPs) don't support input mutation today
+        # so manually  update the states in-place
+        torch._foreach_copy_(exp_avgs, exp_avgs_updated)
+        torch._foreach_copy_(exp_avg_sqs, exp_avgs_sq_updated)
+        torch._foreach_copy_(params, params_updated)
+    return
+
+#####################################################################
+# Setting up and running the compiled kernel
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# In this section, we'll run our Adam optimizer 
+# and compare the results
+#
+# .. note::
+#
+#    ``torch.compile`` is only supported on CUDA devices that have a compute capability of 7.0 or higher.
+opt_eager = torch.optim.Adam(model.parameters(), lr=torch.tensor(0.01))
+opt_eager_copy = torch.optim.Adam(model_copy.parameters(), lr=torch.tensor(0.01))
+
+# warm up the optimizer state dict
+opt_eager.step()
+opt_eager_copy.step()
+
+inputs = get_inputs(opt_eager_copy)
+compiled_adam = torch.compile(foreach_map_adam)
+
+# optionally view the output code
+torch._logging.set_logs(output_code=True)
+
+# Warmup runs to compile the function
+for _ in range(5):
+    opt_eager.step()
+    compiled_adam(*inputs)
+
+for eager_p, compile_p in zip(opt_eager.param_groups[0]["params"], opt_eager_copy.param_groups[0]["params"]):
+    torch.allclose(eager_p, compile_p)
+
+# Benchmark performance
+
+ # Let's define a helpful benchmarking function:
+import torch.utils.benchmark as benchmark
+
+def benchmark_torch_function_in_microseconds(f, *args, **kwargs):
+    t0 = benchmark.Timer(
+        stmt="f(*args, **kwargs)", globals={"args": args, "kwargs": kwargs, "f": f}
+    )
+    return t0.blocked_autorange().mean * 1e6
+
+eager_runtime = benchmark_torch_function_in_microseconds(opt_eager.step)
+compiled_runtime = benchmark_torch_function_in_microseconds(lambda: compiled_adam(*inputs))
+
+assert eager_runtime > compiled_runtime
+   
+print(f"eager runtime: {eager_runtime}us")
+print(f"compiled runtime: {compiled_runtime}us")
+
+
+
+######################################################################
+# Conclusion
+# ~~~~~~~~~~
+# In this tutorial, we successfully implemented a custom fully-fused Adam optimizer using foreach_map. 
+# By leveraging the power of foreach_map and torch.compile, we were able to create an optimized version of the Adam 
+# optimizer that can be used in various machine learning applications. This tutorial provides a comprehensive guide 
+# on how to use foreach_map and torch.compile to optimize machine learning models, and serves as a 
+# valuable resource for developers looking to improve the performance of their models with horizontal fusion.
+#
+# See also:
+#
+# * `Compiled optimizer tutorial <https://pytorch.org/tutorials/recipes/compiling_optimizer.html>`__ - an intro into the compiled optimizer.
+# * `Compiling the optimizer with PT2 <https://dev-discuss.pytorch.org/t/compiling-the-optimizer-with-pt2/1669>`__ - deeper technical details on the compiled optimizer. 
diff --git a/recipes_source/intel_neural_compressor_for_pytorch.rst b/recipes_source/intel_neural_compressor_for_pytorch.rst
new file mode 100755
index 00000000000..ee569382343
--- /dev/null
+++ b/recipes_source/intel_neural_compressor_for_pytorch.rst
@@ -0,0 +1,161 @@
+Ease-of-use quantization for PyTorch with Intel® Neural Compressor
+==================================================================
+
+Overview
+--------
+
+Most deep learning applications are using 32-bits of floating-point precision for inference. But low precision data types, such as fp8, are getting more focus due to significant performance boost. A key concern in adopting low precision is mitigating accuracy loss while meeting predefined requirements.
+
+Intel® Neural Compressor aims to address the aforementioned concern by extending PyTorch with accuracy-driven automatic tuning strategies to help user quickly find out the best quantized model on Intel hardware.
+
+Intel® Neural Compressor is an open-source project at `Github <https://github.com/intel/neural-compressor>`_.
+
+Features
+--------
+
+- **Ease-of-use API:** Intel® Neural Compressor is re-using the PyTorch ``prepare``, ``convert`` API for user usage.
+
+- **Accuracy-driven Tuning:** Intel® Neural Compressor supports accuracy-driven automatic tuning process, provides ``autotune`` API for user usage.
+
+- **Kinds of Quantization:** Intel® Neural Compressor supports a variety of quantization methods, including classic INT8 quantization, weight-only quantization and the popular FP8 quantization. Neural compressor also provides the latest research in simulation work, such as MX data type emulation quantization. For more details, please refer to `Supported Matrix <https://github.com/intel/neural-compressor/blob/master/docs/source/3x/PyTorch.md#supported-matrix>`_.
+
+Getting Started
+---------------
+
+Installation
+~~~~~~~~~~~~
+
+.. code:: bash
+
+    # install stable version from pip
+    pip install neural-compressor-pt
+..
+
+**Note**: Neural Compressor provides automatic accelerator detection, including HPU, Intel GPU, CUDA, and CPU. To specify the target device, ``INC_TARGET_DEVICE`` is suggested, e.g., ``export INC_TARGET_DEVICE=cpu``.
+
+
+Examples
+~~~~~~~~~~~~
+
+This section shows examples of kinds of quantization with Intel® Neural compressor
+
+FP8 Quantization
+^^^^^^^^^^^^^^^^
+
+**FP8 Quantization** is supported by Intel® Gaudi®2&3 AI Accelerator (HPU). To prepare the environment, please refer to `Intel® Gaudi® Documentation <https://docs.habana.ai/en/latest/index.html>`_.
+
+Run the example,
+
+.. code-block:: python
+
+    # FP8 Quantization Example
+    from neural_compressor.torch.quantization import (
+        FP8Config,
+        prepare,
+        convert,
+    )
+
+    import torch
+    import torchvision.models as models
+
+    # Load a pre-trained ResNet18 model
+    model = models.resnet18()
+
+    # Configure FP8 quantization
+    qconfig = FP8Config(fp8_config="E4M3")
+    model = prepare(model, qconfig)
+
+    # Perform calibration (replace with actual calibration data)
+    calibration_data = torch.randn(1, 3, 224, 224).to("hpu")
+    model(calibration_data)
+
+    # Convert the model to FP8
+    model = convert(model)
+
+    # Perform inference
+    input_data = torch.randn(1, 3, 224, 224).to("hpu")
+    output = model(input_data).to("cpu")
+    print(output)
+
+..
+
+Weight-only Quantization
+^^^^^^^^^^^^^^^^^^^^^^^^
+
+**Weight-only Quantization** is also supported on Intel® Gaudi®2&3 AI Accelerator. The quantized model could be loaded as below.
+
+.. code-block:: python
+
+    from neural_compressor.torch.quantization import load
+
+    # The model name comes from HuggingFace Model Hub.
+    model_name = "TheBloke/Llama-2-7B-GPTQ"
+    model = load(
+        model_name_or_path=model_name,
+        format="huggingface",
+        device="hpu",
+        torch_dtype=torch.bfloat16,
+    )
+..
+
+**Note:** Intel Neural Compressor will convert the model format from auto-gptq to hpu format on the first load and save hpu_model.safetensors to the local cache directory for the next load. So it may take a while to load for the first time.
+
+Static Quantization with PT2E Backend
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The PT2E path uses ``torch.dynamo`` to capture the eager model into an FX graph model, and then inserts the observers and Q/QD pairs on it. Finally it uses the ``torch.compile`` to perform the pattern matching and replace the Q/DQ pairs with optimized quantized operators.
+
+There are four steps to perform W8A8 static quantization with PT2E backend: ``export``, ``prepare``, ``convert`` and ``compile``.
+
+.. code-block:: python
+
+   import torch
+   from neural_compressor.torch.export import export
+   from neural_compressor.torch.quantization import StaticQuantConfig, prepare, convert
+
+   # Prepare the float model and example inputs for export model
+   model = UserFloatModel()
+   example_inputs = ...
+
+   # Export eager model into FX graph model
+   exported_model = export(model=model, example_inputs=example_inputs)
+   # Quantize the model
+   quant_config = StaticQuantConfig()
+   prepared_model = prepare(exported_model, quant_config=quant_config)
+   # Calibrate
+   run_fn(prepared_model)
+   q_model = convert(prepared_model)
+   # Compile the quantized model and replace the Q/DQ pattern with Q-operator
+   from torch._inductor import config
+
+   config.freezing = True
+   opt_model = torch.compile(q_model)
+..
+
+Accuracy-driven Tuning
+^^^^^^^^^^^^^^^^^^^^^^
+
+To leverage accuracy-driven automatic tuning, a specified tuning space is necessary. The ``autotune`` iterates the tuning space and applies the configuration on given high-precision model then records and compares its evaluation result with the baseline. The tuning process stops when meeting the exit policy.
+
+
+.. code-block:: python
+
+   from neural_compressor.torch.quantization import RTNConfig, TuningConfig, autotune
+
+
+   def eval_fn(model) -> float:
+       return ...
+
+
+   tune_config = TuningConfig(
+       config_set=RTNConfig(use_sym=[False, True], group_size=[32, 128]),
+       tolerable_loss=0.2,
+       max_trials=10,
+   )
+   q_model = autotune(model, tune_config=tune_config, eval_fn=eval_fn)
+..
+
+Tutorials
+---------
+
+More detailed tutorials are available in the official Intel® Neural Compressor `doc <https://intel.github.io/neural-compressor/latest/docs/source/Welcome.html>`_.
diff --git a/recipes_source/loading_data_recipe.rst b/recipes_source/loading_data_recipe.rst
new file mode 100644
index 00000000000..6ecd54b928a
--- /dev/null
+++ b/recipes_source/loading_data_recipe.rst
@@ -0,0 +1,8 @@
+Loading data in PyTorch
+=======================
+
+The content is deprecated. See `Datasets & DataLoaders <https://pytorch.org/tutorials/beginner/basics/data_tutorial.html>`__ instead.
+
+.. raw:: html
+
+   <meta http-equiv="Refresh" content="1; url='https://pytorch.org/tutorials/beginner/basics/data_tutorial.html'" />
diff --git a/recipes_source/mobile_interpreter.rst b/recipes_source/mobile_interpreter.rst
new file mode 100644
index 00000000000..e6d2056e1a6
--- /dev/null
+++ b/recipes_source/mobile_interpreter.rst
@@ -0,0 +1,10 @@
+(beta) Efficient mobile interpreter in Android and iOS
+==================================================================
+
+PyTorch Mobile is no longer actively supported. Please check out `ExecuTorch <https://github.com/pytorch/executorch>`__.
+
+Redirecting in 3 seconds...
+
+.. raw:: 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
new file mode 100644
index 00000000000..8835ddecc6d
--- /dev/null
+++ b/recipes_source/mobile_perf.rst
@@ -0,0 +1,10 @@
+Pytorch Mobile Performance Recipes
+==================================
+
+PyTorch Mobile is no longer actively supported. Please check out `ExecuTorch <https://github.com/pytorch/executorch>`__.
+
+Redirecting in 3 seconds...
+
+.. raw:: html
+
+    <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
new file mode 100644
index 00000000000..22c0e17df31
--- /dev/null
+++ b/recipes_source/model_preparation_android.rst
@@ -0,0 +1,10 @@
+Model Preparation for Android Recipe
+=====================================
+
+PyTorch Mobile is no longer actively supported. Please check out `ExecuTorch <https://github.com/pytorch/executorch>`__.
+
+Redirecting in 3 seconds...
+
+.. raw:: 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
new file mode 100644
index 00000000000..cbb4927eaeb
--- /dev/null
+++ b/recipes_source/model_preparation_ios.rst
@@ -0,0 +1,10 @@
+Model Preparation for iOS Recipe
+=====================================
+
+PyTorch Mobile is no longer actively supported. Please check out `ExecuTorch <https://github.com/pytorch/executorch>`__.
+
+Redirecting in 3 seconds...
+
+.. raw:: 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
new file mode 100644
index 00000000000..566fd614f22
--- /dev/null
+++ b/recipes_source/profile_with_itt.rst
@@ -0,0 +1,190 @@
+Profiling PyTorch workloads with The Instrumentation and Tracing Technology (ITT) API
+=====================================================================================
+
+In this recipe, you will learn:
+
+* What is Intel® VTune™ Profiler
+* What is Instrumentation and Tracing Technology (ITT) API
+* How to visualize PyTorch model hierarchy in Intel® VTune™ Profiler
+* A short sample code showcasing how to use PyTorch ITT APIs
+
+
+Requirements
+------------
+
+* PyTorch 1.13 or later
+* Intel® VTune™ Profiler
+
+The instructions for installing PyTorch are available at `pytorch.org <https://pytorch.org/get-started/locally/>`__.
+
+
+What is Intel® VTune™ Profiler
+------------------------------
+
+Intel® VTune™ Profiler is a performance analysis tool for serial and multithreaded applications. For those who are familiar with Intel Architecture, Intel® VTune™ Profiler provides a rich set of metrics to help users understand how the application executed on Intel platforms, and thus have an idea where the performance bottleneck is.
+
+More detailed information, including a Getting Started guide, are available `on the Intel website <https://www.intel.com/content/www/us/en/developer/tools/oneapi/vtune-profiler.html>`__.
+
+What is Instrumentation and Tracing Technology (ITT) API
+--------------------------------------------------------
+
+`The Instrumentation and Tracing Technology API (ITT API) <https://www.intel.com/content/www/us/en/develop/documentation/vtune-help/top/api-support/instrumentation-and-tracing-technology-apis.html>`_ provided by the Intel® VTune™ Profiler enables target application to generate and control the collection of trace data during its execution.
+
+The advantage of ITT feature is to label time span of individual PyTorch operators, as well as customized regions, on Intel® VTune™ Profiler GUI. When users find anything abnormal, it will be very helpful to locate which operator behaved unexpectedly.
+
+.. note::
+
+   The ITT API had been integrated into PyTorch since 1.13. Users don't need to invoke the original ITT C/C++ APIs, but only need to invoke the Python APIs in PyTorch. More detailed information can be found at `PyTorch Docs <https://pytorch.org/docs/stable/profiler.html#intel-instrumentation-and-tracing-technology-apis>`__.
+
+How to visualize PyTorch model hierarchy in Intel® VTune™ Profiler
+------------------------------------------------------------------
+
+Two types of usage are provided in PyTorch:
+
+1. Implicit invocation: By default, all operators that are registered by following the PyTorch operator registration mechanism will be labeled by ITT feature automatically when its feature is enabled.
+
+2. Explicit invocation: If customized labeling is needed, users can use APIs mentioned at `PyTorch Docs <https://pytorch.org/docs/stable/profiler.html#intel-instrumentation-and-tracing-technology-apis>`__ explicitly to label a desired range.
+
+
+To enable explicit invocation, code which are expected to be labeled should be invoked under a `torch.autograd.profiler.emit_itt()` scope. For example:
+
+.. code:: python3
+
+   with torch.autograd.profiler.emit_itt():
+     <code-to-be-profiled...>
+
+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
+   :width: 100%
+   :align: center
+
+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 for CPU
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Once you click the `Configure Analysis...` button, you should see the screen below:
+
+.. figure:: /_static/img/itt_tutorial/vtune_config.png
+   :width: 100%
+   :align: center
+
+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
+~~~~~~~~~~~~~~~~~~~~~
+
+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_timeline.png
+   :width: 100%
+   :align: center
+
+
+The timeline shows the main thread as a `python` thread on the top, and individual OpenMP threads below. 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. Labels `iteration_N` are explicitly labeled with specific APIs `torch.profiler.itt.range_push()`, `torch.profiler.itt.range_pop()` or `torch.profiler.itt.range()` scope. Please check the sample code in the next section for details.
+
+.. note::
+
+   Red boxes marked with `convolution` and `reorder` are labeled from Intel® oneAPI Deep Neural Network Library (oneDNN).
+
+As illustrated on the right side navigation bar, brown portions in the timeline rows show CPU usage of individual threads. The percerntage of height of a thread row that the brown portion occupies at a timestamp aligns with that of the CPU usage in that thread at that timestamp. Thus, it is intuitive from this timeline to understand the followings:
+
+1. How well CPU cores are utilized on each thread.
+2. How balance CPU cores are utilized on all threads. Do all threads have good CPU usage?
+3. How well OpenMP threads are synchronized. Are there jitters when starting OpenMP threads or OpenMP threads finish.
+
+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
+----------------------------------------------------------
+
+The sample code below is the script that was used for profiling in the screenshots above.
+
+The topology is formed by two operators, `Conv2d` and `Linear`. Three iterations of inference were performed. Each iteration was labeled by PyTorch ITT APIs as text string `iteration_N`. Either pair of `torch.profile.itt.range_push` and `torch.profile.itt.range_pop` or `torch.profile.itt.range` scope does the customized labeling feature.
+
+.. code:: python3
+
+   # sample.py
+
+   import torch
+   import torch.nn as nn
+   
+   class ITTSample(nn.Module):
+     def __init__(self):
+       super(ITTSample, self).__init__()
+       self.conv = nn.Conv2d(3, 5, 3)
+       self.linear = nn.Linear(292820, 1000)
+   
+     def forward(self, x):
+       x = self.conv(x)
+       x = x.view(x.shape[0], -1)
+       x = self.linear(x)
+       return x
+   
+   def main():
+     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
+         #torch.profiler.itt.range_push(f'iteration_{i}')
+         #m(x)
+         #torch.profiler.itt.range_pop()
+   
+         # Labeling a region with range scope
+         with torch.profiler.itt.range(f'iteration_{i}'):
+           m(x)
+   
+   if __name__ == '__main__':
+     main()
+
+
+The `launch.sh` bash script, mentioned in the Intel® VTune™ Profiler GUI screenshot, to wrap all manual steps is shown below.
+
+.. code:: bash
+
+   # launch.sh
+
+   #!/bin/bash
+   
+   # Retrieve the directory path where the path contains both the sample.py and launch.sh so that this bash script can be invoked from any directory
+   BASEFOLDER=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
+   <Activate a Python environment>
+   cd ${BASEFOLDER}
+   python sample.py
diff --git a/recipes_source/ptmobile_recipes_summary.rst b/recipes_source/ptmobile_recipes_summary.rst
new file mode 100644
index 00000000000..fdf9f58e43d
--- /dev/null
+++ b/recipes_source/ptmobile_recipes_summary.rst
@@ -0,0 +1,10 @@
+Summary of PyTorch Mobile Recipes
+=====================================
+
+PyTorch Mobile is no longer actively supported. Please check out `ExecuTorch <https://github.com/pytorch/executorch>`__.
+
+Redirecting in 3 seconds...
+
+.. raw:: html
+
+    <meta http-equiv="Refresh" content="3; url='https://pytorch.org/executorch/stable/index.html'" />
diff --git a/recipes_source/recipes/Captum_Recipe.py b/recipes_source/recipes/Captum_Recipe.py
new file mode 100644
index 00000000000..11fdc24429c
--- /dev/null
+++ b/recipes_source/recipes/Captum_Recipe.py
@@ -0,0 +1,190 @@
+"""
+Model Interpretability using Captum
+===================================
+
+"""
+
+
+######################################################################
+# Captum helps you understand how the data features impact your model
+# predictions or neuron activations, shedding light on how your model
+# operates.
+# 
+# Using Captum, you can apply a wide range of state-of-the-art feature
+# attribution algorithms such as \ ``Guided GradCam``\  and
+# \ ``Integrated Gradients``\  in a unified way.
+# 
+# In this recipe you will learn how to use Captum to: 
+#
+# - Attribute the predictions of an image classifier to their corresponding image features. 
+# - Visualize the attribution results.
+# 
+
+
+######################################################################
+# Before you begin
+# ----------------
+# 
+
+
+######################################################################
+# Make sure Captum is installed in your active Python environment. Captum
+# is available both on GitHub, as a ``pip`` package, or as a ``conda``
+# package. For detailed instructions, consult the installation guide at
+# https://captum.ai/
+# 
+
+
+######################################################################
+# For a model, we use a built-in image classifier in PyTorch. Captum can
+# reveal which parts of a sample image support certain predictions made by
+# the model.
+# 
+
+import torchvision
+from torchvision import models, transforms
+from PIL import Image
+import requests
+from io import BytesIO
+
+model = torchvision.models.resnet18(weights=models.ResNet18_Weights.IMAGENET1K_V1).eval()
+
+response = requests.get("https://image.freepik.com/free-photo/two-beautiful-puppies-cat-dog_58409-6024.jpg")
+img = Image.open(BytesIO(response.content))
+
+center_crop = transforms.Compose([
+ transforms.Resize(256),
+ transforms.CenterCrop(224),
+])
+
+normalize = transforms.Compose([
+    transforms.ToTensor(),               # converts the image to a tensor with values between 0 and 1
+    transforms.Normalize(                # normalize to follow 0-centered imagenet pixel RGB distribution
+     mean=[0.485, 0.456, 0.406],
+     std=[0.229, 0.224, 0.225]
+    )
+])
+input_img = normalize(center_crop(img)).unsqueeze(0)
+
+
+######################################################################
+# Computing Attribution
+# ---------------------
+# 
+
+
+######################################################################
+# Among the top-3 predictions of the models are classes 208 and 283 which
+# correspond to dog and cat.
+# 
+# Let us attribute each of these predictions to the corresponding part of
+# the input, using Captum’s \ ``Occlusion``\  algorithm.
+# 
+
+from captum.attr import Occlusion 
+
+occlusion = Occlusion(model)
+
+strides = (3, 9, 9)               # smaller = more fine-grained attribution but slower
+target=208,                       # Labrador index in ImageNet 
+sliding_window_shapes=(3,45, 45)  # choose size enough to change object appearance
+baselines = 0                     # values to occlude the image with. 0 corresponds to gray
+
+attribution_dog = occlusion.attribute(input_img,
+                                       strides = strides,
+                                       target=target,
+                                       sliding_window_shapes=sliding_window_shapes,
+                                       baselines=baselines)
+
+
+target=283,                       # Persian cat index in ImageNet 
+attribution_cat = occlusion.attribute(input_img,
+                                       strides = strides,
+                                       target=target,
+                                       sliding_window_shapes=sliding_window_shapes,
+                                       baselines=0)
+
+
+######################################################################
+# Besides ``Occlusion``, Captum features many algorithms such as
+# \ ``Integrated Gradients``\ , \ ``Deconvolution``\ ,
+# \ ``GuidedBackprop``\ , \ ``Guided GradCam``\ , \ ``DeepLift``\ , and
+# \ ``GradientShap``\ . All of these algorithms are subclasses of
+# ``Attribution`` which expects your model as a callable ``forward_func``
+# upon initialization and has an ``attribute(...)`` method which returns
+# the attribution result in a unified format.
+# 
+# Let us visualize the computed attribution results in case of images.
+# 
+
+
+######################################################################
+# Visualizing the Results
+# -----------------------
+# 
+
+
+######################################################################
+# Captum’s \ ``visualization``\  utility provides out-of-the-box methods
+# to visualize attribution results both for pictorial and for textual
+# inputs.
+# 
+
+import numpy as np
+from captum.attr import visualization as viz
+
+# Convert the compute attribution tensor into an image-like numpy array
+attribution_dog = np.transpose(attribution_dog.squeeze().cpu().detach().numpy(), (1,2,0))
+
+vis_types = ["heat_map", "original_image"]
+vis_signs = ["all", "all"] # "positive", "negative", or "all" to show both
+# positive attribution indicates that the presence of the area increases the prediction score
+# negative attribution indicates distractor areas whose absence increases the score
+
+_ = viz.visualize_image_attr_multiple(attribution_dog,
+                                      np.array(center_crop(img)),
+                                      vis_types,
+                                      vis_signs,
+                                      ["attribution for dog", "image"],
+                                      show_colorbar = True
+                                     )
+
+
+attribution_cat = np.transpose(attribution_cat.squeeze().cpu().detach().numpy(), (1,2,0))
+
+_ = viz.visualize_image_attr_multiple(attribution_cat,
+                                      np.array(center_crop(img)),
+                                      ["heat_map", "original_image"],  
+                                      ["all", "all"], # positive/negative attribution or all
+                                      ["attribution for cat", "image"],
+                                      show_colorbar = True
+                                     )
+
+
+######################################################################
+# If your data is textual, ``visualization.visualize_text()`` offers a
+# dedicated view to explore attribution on top of the input text. Find out
+# more at http://captum.ai/tutorials/IMDB_TorchText_Interpret
+# 
+
+
+######################################################################
+# Final Notes
+# -----------
+# 
+
+
+######################################################################
+# Captum can handle most model types in PyTorch across modalities
+# including vision, text, and more. With Captum you can: \* Attribute a
+# specific output to the model input as illustrated above. \* Attribute a
+# specific output to a hidden-layer neuron (see Captum API reference). \*
+# Attribute a hidden-layer neuron response to the model input (see Captum
+# API reference).
+# 
+# For complete API of the supported methods and a list of tutorials,
+# consult our website http://captum.ai
+# 
+# Another useful post by Gilbert Tanner:
+# https://gilberttanner.com/blog/interpreting-pytorch-models-with-captum
+# 
diff --git a/recipes_source/recipes/README.txt b/recipes_source/recipes/README.txt
new file mode 100644
index 00000000000..4ed6d351ae3
--- /dev/null
+++ b/recipes_source/recipes/README.txt
@@ -0,0 +1,46 @@
+PyTorch Recipes
+---------------------------------------------
+1. defining_a_neural_network.py
+	 Defining a Neural Network in PyTorch
+         https://pytorch.org/tutorials/recipes/recipes/defining_a_neural_network.html
+
+2. what_is_state_dict.py
+	 What is a state_dict in PyTorch
+         https://pytorch.org/tutorials/recipes/recipes/what_is_state_dict.html
+
+3. 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
+
+4. custom_dataset_transforms_loader.py
+	 Developing Custom PyTorch Dataloaders
+         https://pytorch.org/tutorials/recipes/recipes/custom_dataset_transforms_loader.html
+
+
+5. Captum_Recipe.py
+	 Model Interpretability using Captum
+         https://pytorch.org/tutorials/recipes/recipes/Captum_Recipe.html
+
+6. dynamic_quantization.py
+         Dynamic Quantization
+         https://pytorch.org/tutorials/recipes/recipes/dynamic_quantization.html
+
+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
+
+8. zeroing_out_gradients.py
+         Zeroing out gradients
+         https://pytorch.org/tutorials/recipes/recipes/zeroing_out_gradients.html
+
+9. mobile_perf.py
+         PyTorch Mobile Performance Recipes
+         https://pytorch.org/tutorials/recipes/mobile_perf.html
+
+10. amp_recipe.py
+         Automatic Mixed Precision
+         https://pytorch.org/tutorials/recipes/amp_recipe.html
+
+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/amp_recipe.py b/recipes_source/recipes/amp_recipe.py
new file mode 100644
index 00000000000..91ce19a93a9
--- /dev/null
+++ b/recipes_source/recipes/amp_recipe.py
@@ -0,0 +1,331 @@
+# -*- coding: utf-8 -*-
+"""
+Automatic Mixed Precision
+*************************
+**Author**: `Michael Carilli <https://github.com/mcarilli>`_
+
+`torch.cuda.amp <https://pytorch.org/docs/stable/amp.html>`_ provides convenience methods for mixed precision,
+where some operations use the ``torch.float32`` (``float``) datatype and other operations
+use ``torch.float16`` (``half``). Some ops, like linear layers and convolutions,
+are much faster in ``float16`` or ``bfloat16``. Other ops, like reductions, often require the dynamic
+range of ``float32``.  Mixed precision tries to match each op to its appropriate datatype,
+which can reduce your network's runtime and memory footprint.
+
+Ordinarily, "automatic mixed precision training" uses `torch.autocast <https://pytorch.org/docs/stable/amp.html#torch.autocast>`_ and
+`torch.cuda.amp.GradScaler <https://pytorch.org/docs/stable/amp.html#torch.cuda.amp.GradScaler>`_ together.
+
+This recipe measures the performance of a simple network in default precision,
+then walks through adding ``autocast`` and ``GradScaler`` to run the same network in
+mixed precision with improved performance.
+
+You may download and run this recipe as a standalone Python script.
+The only requirements are PyTorch 1.6 or later and a CUDA-capable GPU.
+
+Mixed precision primarily benefits Tensor Core-enabled architectures (Volta, Turing, Ampere).
+This recipe should show significant (2-3X) speedup on those architectures.
+On earlier architectures (Kepler, Maxwell, Pascal), you may observe a modest speedup.
+Run ``nvidia-smi`` to display your GPU's architecture.
+"""
+
+import torch, time, gc
+
+# Timing utilities
+start_time = None
+
+def start_timer():
+    global start_time
+    gc.collect()
+    torch.cuda.empty_cache()
+    torch.cuda.reset_max_memory_allocated()
+    torch.cuda.synchronize()
+    start_time = time.time()
+
+def end_timer_and_print(local_msg):
+    torch.cuda.synchronize()
+    end_time = time.time()
+    print("\n" + local_msg)
+    print("Total execution time = {:.3f} sec".format(end_time - start_time))
+    print("Max memory used by tensors = {} bytes".format(torch.cuda.max_memory_allocated()))
+
+##########################################################
+# A simple network
+# ----------------
+# The following sequence of linear layers and ReLUs should show a speedup with mixed precision.
+
+def make_model(in_size, out_size, num_layers):
+    layers = []
+    for _ in range(num_layers - 1):
+        layers.append(torch.nn.Linear(in_size, in_size))
+        layers.append(torch.nn.ReLU())
+    layers.append(torch.nn.Linear(in_size, out_size))
+    return torch.nn.Sequential(*tuple(layers)).cuda()
+
+##########################################################
+# ``batch_size``, ``in_size``, ``out_size``, and ``num_layers`` are chosen to be large enough to saturate the GPU with work.
+# Typically, mixed precision provides the greatest speedup when the GPU is saturated.
+# Small networks may be CPU bound, in which case mixed precision won't improve performance.
+# Sizes are also chosen such that linear layers' participating dimensions are multiples of 8,
+# to permit Tensor Core usage on Tensor Core-capable GPUs (see :ref:`Troubleshooting<troubleshooting>` below).
+#
+# Exercise: Vary participating sizes and see how the mixed precision speedup changes.
+
+batch_size = 512 # Try, for example, 128, 256, 513.
+in_size = 4096
+out_size = 4096
+num_layers = 3
+num_batches = 50
+epochs = 3
+
+device = 'cuda' if torch.cuda.is_available() else 'cpu'
+torch.set_default_device(device)
+
+# Creates data in default precision.
+# The same data is used for both default and mixed precision trials below.
+# You don't need to manually change inputs' ``dtype`` when enabling mixed precision.
+data = [torch.randn(batch_size, in_size) for _ in range(num_batches)]
+targets = [torch.randn(batch_size, out_size) for _ in range(num_batches)]
+
+loss_fn = torch.nn.MSELoss().cuda()
+
+##########################################################
+# Default Precision
+# -----------------
+# Without ``torch.cuda.amp``, the following simple network executes all ops in default precision (``torch.float32``):
+
+net = make_model(in_size, out_size, num_layers)
+opt = torch.optim.SGD(net.parameters(), lr=0.001)
+
+start_timer()
+for epoch in range(epochs):
+    for input, target in zip(data, targets):
+        output = net(input)
+        loss = loss_fn(output, target)
+        loss.backward()
+        opt.step()
+        opt.zero_grad() # set_to_none=True here can modestly improve performance
+end_timer_and_print("Default precision:")
+
+##########################################################
+# Adding ``torch.autocast``
+# -------------------------
+# Instances of `torch.autocast <https://pytorch.org/docs/stable/amp.html#autocasting>`_
+# serve as context managers that allow regions of your script to run in mixed precision.
+#
+# In these regions, CUDA ops run in a ``dtype`` chosen by ``autocast``
+# to improve performance while maintaining accuracy.
+# See the `Autocast Op Reference <https://pytorch.org/docs/stable/amp.html#autocast-op-reference>`_
+# for details on what precision ``autocast`` chooses for each op, and under what circumstances.
+
+for epoch in range(0): # 0 epochs, this section is for illustration only
+    for input, target in zip(data, targets):
+        # Runs the forward pass under ``autocast``.
+        with torch.autocast(device_type=device, dtype=torch.float16):
+            output = net(input)
+            # output is float16 because linear layers ``autocast`` to float16.
+            assert output.dtype is torch.float16
+
+            loss = loss_fn(output, target)
+            # loss is float32 because ``mse_loss`` layers ``autocast`` to float32.
+            assert loss.dtype is torch.float32
+
+        # Exits ``autocast`` before backward().
+        # Backward passes under ``autocast`` are not recommended.
+        # Backward ops run in the same ``dtype`` ``autocast`` chose for corresponding forward ops.
+        loss.backward()
+        opt.step()
+        opt.zero_grad() # set_to_none=True here can modestly improve performance
+
+##########################################################
+# Adding ``GradScaler``
+# ---------------------
+# `Gradient scaling <https://pytorch.org/docs/stable/amp.html#gradient-scaling>`_
+# helps prevent gradients with small magnitudes from flushing to zero
+# ("underflowing") when training with mixed precision.
+#
+# `torch.cuda.amp.GradScaler <https://pytorch.org/docs/stable/amp.html#torch.cuda.amp.GradScaler>`_
+# performs the steps of gradient scaling conveniently.
+
+# Constructs a ``scaler`` once, at the beginning of the convergence run, using default arguments.
+# If your network fails to converge with default ``GradScaler`` arguments, please file an issue.
+# The same ``GradScaler`` instance should be used for the entire convergence run.
+# If you perform multiple convergence runs in the same script, each run should use
+# a dedicated fresh ``GradScaler`` instance. ``GradScaler`` instances are lightweight.
+scaler = torch.amp.GradScaler("cuda")
+
+for epoch in range(0): # 0 epochs, this section is for illustration only
+    for input, target in zip(data, targets):
+        with torch.autocast(device_type=device, dtype=torch.float16):
+            output = net(input)
+            loss = loss_fn(output, target)
+
+        # Scales loss. Calls ``backward()`` on scaled loss to create scaled gradients.
+        scaler.scale(loss).backward()
+
+        # ``scaler.step()`` first unscales the gradients of the optimizer's assigned parameters.
+        # If these gradients do not contain ``inf``s or ``NaN``s, optimizer.step() is then called,
+        # otherwise, optimizer.step() is skipped.
+        scaler.step(opt)
+
+        # Updates the scale for next iteration.
+        scaler.update()
+
+        opt.zero_grad() # set_to_none=True here can modestly improve performance
+
+##########################################################
+# All together: "Automatic Mixed Precision"
+# ------------------------------------------
+# (The following also demonstrates ``enabled``, an optional convenience argument to ``autocast`` and ``GradScaler``.
+# If False, ``autocast`` and ``GradScaler``\ 's calls become no-ops.
+# This allows switching between default precision and mixed precision without if/else statements.)
+
+use_amp = True
+
+net = make_model(in_size, out_size, num_layers)
+opt = torch.optim.SGD(net.parameters(), lr=0.001)
+scaler = torch.amp.GradScaler("cuda" ,enabled=use_amp)
+
+start_timer()
+for epoch in range(epochs):
+    for input, target in zip(data, targets):
+        with torch.autocast(device_type=device, dtype=torch.float16, enabled=use_amp):
+            output = net(input)
+            loss = loss_fn(output, target)
+        scaler.scale(loss).backward()
+        scaler.step(opt)
+        scaler.update()
+        opt.zero_grad() # set_to_none=True here can modestly improve performance
+end_timer_and_print("Mixed precision:")
+
+##########################################################
+# Inspecting/modifying gradients (e.g., clipping)
+# --------------------------------------------------------
+# All gradients produced by ``scaler.scale(loss).backward()`` are scaled.  If you wish to modify or inspect
+# the parameters' ``.grad`` attributes between ``backward()`` and ``scaler.step(optimizer)``, you should
+# unscale them first using `scaler.unscale_(optimizer) <https://pytorch.org/docs/stable/amp.html#torch.cuda.amp.GradScaler.unscale_>`_.
+
+for epoch in range(0): # 0 epochs, this section is for illustration only
+    for input, target in zip(data, targets):
+        with torch.autocast(device_type=device, dtype=torch.float16):
+            output = net(input)
+            loss = loss_fn(output, target)
+        scaler.scale(loss).backward()
+
+        # Unscales the gradients of optimizer's assigned parameters in-place
+        scaler.unscale_(opt)
+
+        # Since the gradients of optimizer's assigned parameters are now unscaled, clips as usual.
+        # You may use the same value for max_norm here as you would without gradient scaling.
+        torch.nn.utils.clip_grad_norm_(net.parameters(), max_norm=0.1)
+
+        scaler.step(opt)
+        scaler.update()
+        opt.zero_grad() # set_to_none=True here can modestly improve performance
+
+##########################################################
+# Saving/Resuming
+# ----------------
+# To save/resume Amp-enabled runs with bitwise accuracy, use
+# `scaler.state_dict <https://pytorch.org/docs/stable/amp.html#torch.cuda.amp.GradScaler.state_dict>`_ and
+# `scaler.load_state_dict <https://pytorch.org/docs/stable/amp.html#torch.cuda.amp.GradScaler.load_state_dict>`_.
+#
+# When saving, save the ``scaler`` state dict alongside the usual model and optimizer state ``dicts``.
+# Do this either at the beginning of an iteration before any forward passes, or at the end of
+# an iteration after ``scaler.update()``.
+
+checkpoint = {"model": net.state_dict(),
+              "optimizer": opt.state_dict(),
+              "scaler": scaler.state_dict()}
+# Write checkpoint as desired, e.g.,
+# torch.save(checkpoint, "filename")
+
+##########################################################
+# When resuming, load the ``scaler`` state dict alongside the model and optimizer state ``dicts``.
+# Read checkpoint as desired, for example:
+#
+# .. code-block::
+#
+#    dev = torch.cuda.current_device()
+#    checkpoint = torch.load("filename",
+#                            map_location = lambda storage, loc: storage.cuda(dev))
+#
+net.load_state_dict(checkpoint["model"])
+opt.load_state_dict(checkpoint["optimizer"])
+scaler.load_state_dict(checkpoint["scaler"])
+
+##########################################################
+# If a checkpoint was created from a run *without* Amp, and you want to resume training *with* Amp,
+# load model and optimizer states from the checkpoint as usual.  The checkpoint won't contain a saved ``scaler`` state, so
+# use a fresh instance of ``GradScaler``.
+#
+# If a checkpoint was created from a run *with* Amp and you want to resume training *without* ``Amp``,
+# load model and optimizer states from the checkpoint as usual, and ignore the saved ``scaler`` state.
+
+##########################################################
+# Inference/Evaluation
+# --------------------
+# ``autocast`` may be used by itself to wrap inference or evaluation forward passes. ``GradScaler`` is not necessary.
+
+##########################################################
+# .. _advanced-topics:
+#
+# Advanced topics
+# ---------------
+# See the `Automatic Mixed Precision Examples <https://pytorch.org/docs/stable/notes/amp_examples.html>`_ for advanced use cases including:
+#
+# * Gradient accumulation
+# * Gradient penalty/double backward
+# * Networks with multiple models, optimizers, or losses
+# * Multiple GPUs (``torch.nn.DataParallel`` or ``torch.nn.parallel.DistributedDataParallel``)
+# * Custom autograd functions (subclasses of ``torch.autograd.Function``)
+#
+# If you perform multiple convergence runs in the same script, each run should use
+# a dedicated fresh ``GradScaler`` instance. ``GradScaler`` instances are lightweight.
+#
+# If you're registering a custom C++ op with the dispatcher, see the
+# `autocast section <https://pytorch.org/tutorials/advanced/dispatcher.html#autocast>`_
+# of the dispatcher tutorial.
+
+##########################################################
+# .. _troubleshooting:
+#
+# Troubleshooting
+# ---------------
+# Speedup with Amp is minor
+# ~~~~~~~~~~~~~~~~~~~~~~~~~
+# 1. Your network may fail to saturate the GPU(s) with work, and is therefore CPU bound. Amp's effect on GPU performance
+#    won't matter.
+#
+#    * A rough rule of thumb to saturate the GPU is to increase batch and/or network size(s)
+#      as much as you can without running OOM.
+#    * Try to avoid excessive CPU-GPU synchronization (``.item()`` calls, or printing values from CUDA tensors).
+#    * Try to avoid sequences of many small CUDA ops (coalesce these into a few large CUDA ops if you can).
+# 2. Your network may be GPU compute bound (lots of ``matmuls``/convolutions) but your GPU does not have Tensor Cores.
+#    In this case a reduced speedup is expected.
+# 3. The ``matmul`` dimensions are not Tensor Core-friendly.  Make sure ``matmuls`` participating sizes are multiples of 8.
+#    (For NLP models with encoders/decoders, this can be subtle.  Also, convolutions used to have similar size constraints
+#    for Tensor Core use, but for CuDNN versions 7.3 and later, no such constraints exist.  See
+#    `here <https://github.com/NVIDIA/apex/issues/221#issuecomment-478084841>`_ for guidance.)
+#
+# Loss is inf/NaN
+# ~~~~~~~~~~~~~~~
+# First, check if your network fits an :ref:`advanced use case<advanced-topics>`.
+# See also `Prefer binary_cross_entropy_with_logits over binary_cross_entropy <https://pytorch.org/docs/stable/amp.html#prefer-binary-cross-entropy-with-logits-over-binary-cross-entropy>`_.
+#
+# If you're confident your Amp usage is correct, you may need to file an issue, but before doing so, it's helpful to gather the following information:
+#
+# 1. Disable ``autocast`` or ``GradScaler`` individually (by passing ``enabled=False`` to their constructor) and see if ``infs``/``NaNs`` persist.
+# 2. If you suspect part of your network (e.g., a complicated loss function) overflows , run that forward region in ``float32``
+#    and see if ``infs``/``NaN``s persist.
+#    `The autocast docstring <https://pytorch.org/docs/stable/amp.html#torch.autocast>`_'s last code snippet
+#    shows forcing a subregion to run in ``float32`` (by locally disabling ``autocast`` and casting the subregion's inputs).
+#
+# Type mismatch error (may manifest as ``CUDNN_STATUS_BAD_PARAM``)
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ``Autocast`` tries to cover all ops that benefit from or require casting.
+# `Ops that receive explicit coverage <https://pytorch.org/docs/stable/amp.html#autocast-op-reference>`_
+# are chosen based on numerical properties, but also on experience.
+# If you see a type mismatch error in an ``autocast`` enabled forward region or a backward pass following that region,
+# it's possible ``autocast`` missed an op.
+#
+# Please file an issue with the error backtrace.  ``export TORCH_SHOW_CPP_STACKTRACES=1`` before running your script to provide
+# fine-grained information on which backend op is failing.
diff --git a/recipes_source/recipes/benchmark.py b/recipes_source/recipes/benchmark.py
new file mode 100644
index 00000000000..96fdf109bde
--- /dev/null
+++ b/recipes_source/recipes/benchmark.py
@@ -0,0 +1,888 @@
+"""
+PyTorch Benchmark
+====================================
+This recipe provides a quick-start guide to using PyTorch
+``benchmark`` module to measure and compare code performance.
+
+Introduction
+------------
+Benchmarking is an important step in writing code. It helps
+us validate that our code meets performance expectations,
+compare different approaches to solving the same problem and
+prevent performance regressions.
+
+There are many options when it comes to benchmarking PyTorch code
+including the Python builtin ``timeit`` module. However, benchmarking
+PyTorch code has many caveats that can be easily overlooked such as
+managing the number of threads and synchronizing CUDA devices. Moreover,
+generating Tensor inputs for benchmarking can be quite tedious.
+
+This recipe demonstrates how to use PyTorch ``benchmark`` module to avoid
+common mistakes while making it easier to compare performance of
+different code, generate input for benchmarking and more.
+
+Setup
+-----
+Before we begin, install ``torch`` if it isn’t already available.
+
+::
+
+   pip install torch
+
+"""
+
+
+######################################################################
+# Steps
+# -----
+#
+# 1. Defining functions to benchmark
+# 2. Benchmarking with ``timeit.Timer``
+# 3. Benchmarking with ``torch.utils.benchmark.Timer``
+# 4. Benchmarking with ``Blocked Autorange``
+# 5. Comparing benchmark results
+# 6. Saving/Loading benchmark results
+# 7. Generating inputs with ``Fuzzed Parameters``
+# 8. Collecting instruction counts with ``Callgrind``
+#
+# 1. Defining functions to benchmark
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# As of the time of this writing, `torch.dot <https://pytorch.org/docs/stable/generated/torch.dot.html?highlight=dot#torch.dot>`__
+# does not support batched mode, so we will compare two approaches to
+# implementing it using existing ``torch`` operators: one approach uses a
+# combination of ``mul`` and ``sum`` while the other reduces the problem to ``bmm``.
+#
+
+import torch
+
+
+def batched_dot_mul_sum(a, b):
+    '''Computes batched dot by multiplying and summing'''
+    return a.mul(b).sum(-1)
+
+
+def batched_dot_bmm(a, b):
+    '''Computes batched dot by reducing to ``bmm``'''
+    a = a.reshape(-1, 1, a.shape[-1])
+    b = b.reshape(-1, b.shape[-1], 1)
+    return torch.bmm(a, b).flatten(-3)
+
+
+# Input for benchmarking
+x = torch.randn(10000, 64)
+
+# Ensure that both functions compute the same output
+assert batched_dot_mul_sum(x, x).allclose(batched_dot_bmm(x, x))
+
+
+######################################################################
+# 2. Benchmarking with ``timeit.Timer``
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# First, let's benchmark the code using Python's builtin ``timeit`` module.
+# We keep the benchmark code simple here so we can compare the defaults
+# of ``timeit`` and ``torch.utils.benchmark``.
+#
+
+import timeit
+
+t0 = timeit.Timer(
+    stmt='batched_dot_mul_sum(x, x)', 
+    setup='from __main__ import batched_dot_mul_sum',
+    globals={'x': x})
+
+t1 = timeit.Timer(
+    stmt='batched_dot_bmm(x, x)',
+    setup='from __main__ import batched_dot_bmm',
+    globals={'x': x})
+
+print(f'mul_sum(x, x):  {t0.timeit(100) / 100 * 1e6:>5.1f} us')
+print(f'bmm(x, x):      {t1.timeit(100) / 100 * 1e6:>5.1f} us')
+
+######################################################################
+# .. code-block:: none
+#    :caption: Output
+#
+#     mul_sum(x, x):  111.6 us
+#     bmm(x, x):       70.0 us
+#
+
+
+######################################################################
+# 3. Benchmarking with ``torch.utils.benchmark.Timer``
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# PyTorch ``benchmark`` module was designed to be familiar to those who
+# have used the ``timeit`` module before. However, its defaults make it
+# easier and safer to use for benchmarking PyTorch code. Let's first
+# compare the same basic API as above.
+#
+
+import torch.utils.benchmark as benchmark
+
+t0 = benchmark.Timer(
+    stmt='batched_dot_mul_sum(x, x)', 
+    setup='from __main__ import batched_dot_mul_sum',
+    globals={'x': x})
+
+t1 = benchmark.Timer(
+    stmt='batched_dot_bmm(x, x)',
+    setup='from __main__ import batched_dot_bmm',
+    globals={'x': x})
+
+print(t0.timeit(100))
+print(t1.timeit(100))
+
+######################################################################
+# .. code-block:: none
+#    :caption: Output
+#
+#     <torch.utils.benchmark.utils.common.Measurement object at 0x7fb10400d0f0>
+#     batched_dot_mul_sum(x, x)
+#     setup: from __main__ import batched_dot_mul_sum
+#       379.29 us
+#       1 measurement, 100 runs , 1 thread
+#     <torch.utils.benchmark.utils.common.Measurement object at 0x7fb103d67048>
+#     batched_dot_bmm(x, x)
+#     setup: from __main__ import batched_dot_bmm
+#       716.42 us
+#       1 measurement, 100 runs , 1 thread
+#
+
+######################################################################
+# Even though the APIs are the same for the basic functionality, there
+# are some important differences. ``benchmark.Timer.timeit()`` returns the
+# time per run as opposed to the total runtime like ``timeit.Timer.timeit()``
+# does. PyTorch ``benchmark`` module also provides formatted string
+# representations for printing the results.
+#
+# Another important difference, and the reason why the results diverge
+# is that PyTorch benchmark module runs in a single thread by default.
+# We can change the number of threads with the ``num_threads`` argument.
+#
+# ``torch.utils.benchmark.Timer`` takes several additional arguments
+# including: ``label``, ``sub_label``, ``description`` and ``env`` which change
+# the __repr__ of the measurement object returned and are used for
+# grouping the results (more on this later).
+#
+
+num_threads = torch.get_num_threads()
+print(f'Benchmarking on {num_threads} threads')
+
+t0 = benchmark.Timer(
+    stmt='batched_dot_mul_sum(x, x)', 
+    setup='from __main__ import batched_dot_mul_sum',
+    globals={'x': x},
+    num_threads=num_threads,
+    label='Multithreaded batch dot',
+    sub_label='Implemented using mul and sum')
+
+t1 = benchmark.Timer(
+    stmt='batched_dot_bmm(x, x)',
+    setup='from __main__ import batched_dot_bmm',
+    globals={'x': x},
+    num_threads=num_threads,
+    label='Multithreaded batch dot',
+    sub_label='Implemented using bmm')
+
+print(t0.timeit(100))
+print(t1.timeit(100))
+
+######################################################################
+# .. code-block:: none
+#    :caption: Output
+#
+#     Benchmarking on 40 threads
+#     <torch.utils.benchmark.utils.common.Measurement object at 0x7fb103d54080>
+#     Multithreaded batch dot: Implemented using mul and sum
+#     setup: from __main__ import batched_dot_mul_sum
+#       118.47 us
+#       1 measurement, 100 runs , 40 threads
+#     <torch.utils.benchmark.utils.common.Measurement object at 0x7fb16935d2e8>
+#     Multithreaded batch dot: Implemented using bmm
+#     setup: from __main__ import batched_dot_bmm
+#       68.21 us
+#       1 measurement, 100 runs , 40 threads
+
+######################################################################
+# Running ``benchmark`` with all threads available gives similar results
+# as the ``timeit`` module. More importantly, which version is faster
+# depends on how many threads we run the code with. This is why it's
+# important to benchmark the code with thread settings that are
+# representative of real use cases. Another important thing to remember
+# is to synchronize CPU and CUDA when benchmarking on the GPU. Let's run
+# the above benchmarks again on a CUDA tensor and see what happens.
+#
+
+x = torch.randn(10000, 1024, device='cuda')
+
+t0 = timeit.Timer(
+    stmt='batched_dot_mul_sum(x, x)', 
+    setup='from __main__ import batched_dot_mul_sum',
+    globals={'x': x})
+
+t1 = timeit.Timer(
+    stmt='batched_dot_bmm(x, x)',
+    setup='from __main__ import batched_dot_bmm',
+    globals={'x': x})
+
+# Ran each twice to show difference before/after warm-up
+print(f'mul_sum(x, x):  {t0.timeit(100) / 100 * 1e6:>5.1f} us')
+print(f'mul_sum(x, x):  {t0.timeit(100) / 100 * 1e6:>5.1f} us')
+print(f'bmm(x, x):      {t1.timeit(100) / 100 * 1e6:>5.1f} us')
+print(f'bmm(x, x):      {t1.timeit(100) / 100 * 1e6:>5.1f} us')
+
+######################################################################
+# .. code-block:: none
+#    :caption: Output
+#
+#     mul_sum(x, x):   27.6 us
+#     mul_sum(x, x):   25.3 us
+#     bmm(x, x):      2775.5 us
+#     bmm(x, x):       22.4 us
+#
+
+t0 = benchmark.Timer(
+    stmt='batched_dot_mul_sum(x, x)', 
+    setup='from __main__ import batched_dot_mul_sum',
+    globals={'x': x})
+
+t1 = benchmark.Timer(
+    stmt='batched_dot_bmm(x, x)',
+    setup='from __main__ import batched_dot_bmm',
+    globals={'x': x})
+
+# Run only once since benchmark module does warm-up for us
+print(t0.timeit(100))
+print(t1.timeit(100))
+
+######################################################################
+# .. code-block:: none
+#    :caption: Output
+#
+#     <torch.utils.benchmark.utils.common.Measurement object at 0x7fb10400d080>
+#     batched_dot_mul_sum(x, x)
+#     setup: from __main__ import batched_dot_mul_sum
+#       232.93 us
+#       1 measurement, 100 runs , 1 thread
+#     <torch.utils.benchmark.utils.common.Measurement object at 0x7fb10400d0f0>
+#     batched_dot_bmm(x, x)
+#     setup: from __main__ import batched_dot_bmm
+#       181.04 us
+#       1 measurement, 100 runs , 1 thread
+#
+
+######################################################################
+# The results reveal something interesting. The first run of the ``bmm``
+# version using the ``timeit`` module takes much longer than the second
+# run. This is because ``bmm`` calls into `cuBLAS` which needs to be
+# loaded the first time it's called which takes some time. This is why
+# it's important to do a warm-up run before benchmarking, luckily for
+# us, PyTorch's ``benchmark`` module takes care of that.
+#
+# The difference in the results between ``timeit`` and ``benchmark`` modules
+# is because the `timeit` module is not synchronizing CUDA and is thus only
+# timing the time to launch the kernel. PyTorch's ``benchmark`` module does
+# the synchronization for us.
+
+
+######################################################################
+# 4. Benchmarking with `Blocked Autorange`
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# While ``timeit.Timer.autorange`` takes a single continuous measurement
+# of at least 0.2 seconds, `torch.utils.benchmark.Timer.blocked_autorange`
+# takes many measurements whose times total at least 0.2 seconds (which
+# can be changed by the `min_run_time` parameter) subject to the constraint
+# that timing overhead is a small fraction of the overall measurement.
+# This is accomplished by first running with an increasing number of runs
+# per loop until the runtime is much larger than measurement overhead
+# (which also serves as a warm up), and then taking measurements until
+# the target time is reached. This has the useful properties that it wastes
+# less data and allows us to compute statistics to estimate the reliability
+# of the measurements.
+#
+
+m0 = t0.blocked_autorange()
+m1 = t1.blocked_autorange()
+
+print(m0)
+print(m1)
+
+######################################################################
+# .. code-block:: none
+#    :caption: Output
+#
+#     <torch.utils.benchmark.utils.common.Measurement object at 0x7fb10400d0f0>
+#     batched_dot_mul_sum(x, x)
+#     setup: from __main__ import batched_dot_mul_sum
+#       231.79 us
+#       1 measurement, 1000 runs , 1 thread
+#     <torch.utils.benchmark.utils.common.Measurement object at 0x7fb10400d080>
+#     batched_dot_bmm(x, x)
+#     setup: from __main__ import batched_dot_bmm
+#       Median: 162.08 us
+#       2 measurements, 1000 runs per measurement, 1 thread
+#
+
+######################################################################
+# We can also inspect the individual statistics from the returned
+# measurements object.
+
+print(f"Mean:   {m0.mean * 1e6:6.2f} us")
+print(f"Median: {m0.median * 1e6:6.2f} us")
+
+######################################################################
+# .. code-block:: none
+#    :caption: Output
+#
+#     Mean:   231.79 us
+#     Median: 231.79 us
+#
+
+######################################################################
+# 5. Comparing benchmark results
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# So far we've been comparing our two versions of batched dot against a
+# single input. In practice, we want to try a combination of inputs as
+# well as different number of threads. The ``Compare`` class helps display
+# the results of many measurements in a formatted table. It uses the
+# annotations described above (`label`, `sub_label`, `num_threads`, etc.) as
+# well as `description` to group and organize the table. Let's use
+# ``Compare`` to see how our functions perform for different input sizes
+# and number of threads.
+#
+
+from itertools import product
+
+# Compare takes a list of measurements which we'll save in results.
+results = []
+
+sizes = [1, 64, 1024, 10000]
+for b, n in product(sizes, sizes):
+    # label and sub_label are the rows
+    # description is the column
+    label = 'Batched dot'
+    sub_label = f'[{b}, {n}]'
+    x = torch.ones((b, n))
+    for num_threads in [1, 4, 16, 32]:
+        results.append(benchmark.Timer(
+            stmt='batched_dot_mul_sum(x, x)',
+            setup='from __main__ import batched_dot_mul_sum',
+            globals={'x': x},
+            num_threads=num_threads,
+            label=label,
+            sub_label=sub_label,
+            description='mul/sum',
+        ).blocked_autorange(min_run_time=1))
+        results.append(benchmark.Timer(
+            stmt='batched_dot_bmm(x, x)',
+            setup='from __main__ import batched_dot_bmm',
+            globals={'x': x},
+            num_threads=num_threads,
+            label=label,
+            sub_label=sub_label,
+            description='bmm',
+        ).blocked_autorange(min_run_time=1))
+
+compare = benchmark.Compare(results)
+compare.print()
+
+######################################################################
+# .. code-block:: none
+#    :caption: Output
+#
+#     [--------------- Batched dot ----------------]
+#                           |  mul/sum   |    bmm   
+#     1 threads: -----------------------------------
+#           [1, 1]          |       5.9  |      11.2
+#           [1, 64]         |       6.4  |      11.4
+#           [1, 1024]       |       6.7  |      14.2
+#           [1, 10000]      |      10.2  |      23.7
+#           [64, 1]         |       6.3  |      11.5
+#           [64, 64]        |       8.6  |      15.4
+#           [64, 1024]      |      39.4  |     204.4
+#           [64, 10000]     |     274.9  |     748.5
+#           [1024, 1]       |       7.7  |      17.8
+#           [1024, 64]      |      40.3  |      76.4
+#           [1024, 1024]    |     432.4  |    2795.9
+#           [1024, 10000]   |   22657.3  |   11899.5
+#           [10000, 1]      |      16.9  |      74.8
+#           [10000, 64]     |     300.3  |     609.4
+#           [10000, 1024]   |   23098.6  |   27246.1
+#           [10000, 10000]  |  267073.7  |  118823.7
+#     4 threads: -----------------------------------
+#           [1, 1]          |       6.0  |      11.5
+#           [1, 64]         |       6.2  |      11.2
+#           [1, 1024]       |       6.8  |      14.3
+#           [1, 10000]      |      10.2  |      23.7
+#           [64, 1]         |       6.3  |      16.2
+#           [64, 64]        |       8.8  |      18.2
+#           [64, 1024]      |      41.5  |     189.1
+#           [64, 10000]     |      91.7  |     849.1
+#           [1024, 1]       |       7.6  |      17.4
+#           [1024, 64]      |      43.5  |      33.5
+#           [1024, 1024]    |     135.4  |    2782.3
+#           [1024, 10000]   |    7471.1  |   11874.0
+#           [10000, 1]      |      16.8  |      33.9
+#           [10000, 64]     |     118.7  |     173.2
+#           [10000, 1024]   |    7264.6  |   27824.7
+#           [10000, 10000]  |  100060.9  |  121499.0
+#     16 threads: ----------------------------------
+#           [1, 1]          |       6.0  |      11.3
+#           [1, 64]         |       6.2  |      11.2
+#           [1, 1024]       |       6.9  |      14.2
+#           [1, 10000]      |      10.3  |      23.8
+#           [64, 1]         |       6.4  |      24.1
+#           [64, 64]        |       9.0  |      23.8
+#           [64, 1024]      |      54.1  |     188.5
+#           [64, 10000]     |      49.9  |     748.0
+#           [1024, 1]       |       7.6  |      23.4
+#           [1024, 64]      |      55.5  |      28.2
+#           [1024, 1024]    |      66.9  |    2773.9
+#           [1024, 10000]   |    6111.5  |   12833.7
+#           [10000, 1]      |      16.9  |      27.5
+#           [10000, 64]     |      59.5  |      73.7
+#           [10000, 1024]   |    6295.9  |   27062.0
+#           [10000, 10000]  |   71804.5  |  120365.8
+#     32 threads: ----------------------------------
+#           [1, 1]          |       5.9  |      11.3
+#           [1, 64]         |       6.2  |      11.3
+#           [1, 1024]       |       6.7  |      14.2
+#           [1, 10000]      |      10.5  |      23.8
+#           [64, 1]         |       6.3  |      31.7
+#           [64, 64]        |       9.1  |      30.4
+#           [64, 1024]      |      72.0  |     190.4
+#           [64, 10000]     |     103.1  |     746.9
+#           [1024, 1]       |       7.6  |      28.4
+#           [1024, 64]      |      70.5  |      31.9
+#           [1024, 1024]    |      65.6  |    2804.6
+#           [1024, 10000]   |    6764.0  |   11871.4
+#           [10000, 1]      |      17.8  |      31.8
+#           [10000, 64]     |     110.3  |      56.0
+#           [10000, 1024]   |    6640.2  |   27592.2
+#           [10000, 10000]  |   73003.4  |  120083.2
+#
+#     Times are in microseconds (us).
+#
+
+######################################################################
+# The results above indicate that the version which reduces to ``bmm``
+# is better for larger tensors running on multiple threads, while for
+# smaller and/or single thread code, the other version is better.
+#
+# ``Compare`` also provides functions for changing the table format
+#
+
+compare.trim_significant_figures()
+compare.colorize()
+compare.print()
+
+
+######################################################################
+# 6. Saving/Loading benchmark results
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# `Measurements` (and ``CallgrindStats`` which are described in section 8)
+# can be serialized by the ``pickle`` module. This makes A/B testing easy, as you can collect
+# measurements from two separate environments, pickle them, and then
+# load both in a single environment. Timer even takes an `env`
+# constructor argument so that such A/B testing works seamlessly.
+#
+# Let's imagine that rather than two Python functions, the add/sum
+# and ``bmm`` approaches were in two different builds of PyTorch.
+# The example below demonstrates how one might A/B test them. For
+# simplicity, we only use a subset of shapes, and simply round trip
+# results through pickle rather than actually using multiple environments
+# and writing results to disk.
+#
+
+import pickle
+
+ab_test_results = []
+for env in ('environment A: mul/sum', 'environment B: bmm'):
+    for b, n in ((1, 1), (1024, 10000), (10000, 1)):
+        x = torch.ones((b, n))
+        dot_fn = (batched_dot_mul_sum if env == 'environment A: mul/sum' else batched_dot_bmm)
+        m = benchmark.Timer(
+            stmt='batched_dot(x, x)',
+            globals={'x': x, 'batched_dot': dot_fn},
+            num_threads=1,
+            label='Batched dot',
+            description=f'[{b}, {n}]',
+            env=env,
+        ).blocked_autorange(min_run_time=1)
+        ab_test_results.append(pickle.dumps(m))
+
+ab_results = [pickle.loads(i) for i in ab_test_results]
+compare = benchmark.Compare(ab_results)
+compare.trim_significant_figures()
+compare.colorize()
+compare.print()
+
+######################################################################
+# .. code-block:: none
+#    :caption: Output
+#
+#     [------------------------------------- Batched dot -------------------------------------]
+#                                                    |  [1, 1]  |  [1024, 10000]  |  [10000, 1]
+#     1 threads: ------------------------------------------------------------------------------
+#       (environment A: mul/sum)  batched_dot(x, x)  |     7    |      36000      |      21
+#       (environment B: bmm)      batched_dot(x, x)  |    14    |      40000      |      85
+#
+#     Times are in microseconds (us).
+#
+
+# And just to show that we can round trip all of the results from earlier:
+round_tripped_results = pickle.loads(pickle.dumps(results))
+assert(str(benchmark.Compare(results)) == str(benchmark.Compare(round_tripped_results)))
+
+
+######################################################################
+# 7. Generating inputs with `Fuzzed Parameters`
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# As we've seen in the previous section, there can be some stark
+# performance differences depending on the input tensors. Hence, it
+# is a good idea to run benchmarks on a number of different inputs.
+# However, creating all these input tensors can be tedious which is
+# where ``torch.utils.benchmark.Fuzzer`` and related classes come in.
+# Let's take a look at how we can use the ``Fuzzer`` to create some test
+# cases for the benchmark.
+#
+
+from torch.utils.benchmark import Fuzzer, FuzzedParameter, FuzzedTensor, ParameterAlias
+
+# Generates random tensors with 128 to 10000000 elements and sizes k0 and k1 chosen from a
+# ``loguniform`` distribution in [1, 10000], 40% of which will be discontiguous on average.
+example_fuzzer = Fuzzer(
+    parameters = [
+        FuzzedParameter('k0', minval=1, maxval=10000, distribution='loguniform'),
+        FuzzedParameter('k1', minval=1, maxval=10000, distribution='loguniform'),
+    ],
+    tensors = [
+        FuzzedTensor('x', size=('k0', 'k1'), min_elements=128, max_elements=10000000, probability_contiguous=0.6)
+    ],
+    seed=0,
+)
+
+results = []
+for tensors, tensor_params, params in example_fuzzer.take(10):
+    # description is the column label
+    sub_label=f"{params['k0']:<6} x {params['k1']:<4} {'' if tensor_params['x']['is_contiguous'] else '(discontiguous)'}"
+    results.append(benchmark.Timer(
+        stmt='batched_dot_mul_sum(x, x)',
+        setup='from __main__ import batched_dot_mul_sum',
+        globals=tensors,
+        label='Batched dot',
+        sub_label=sub_label,
+        description='mul/sum',
+    ).blocked_autorange(min_run_time=1))
+    results.append(benchmark.Timer(
+        stmt='batched_dot_bmm(x, x)',
+        setup='from __main__ import batched_dot_bmm',
+        globals=tensors,
+        label='Batched dot',
+        sub_label=sub_label,
+        description='bmm',
+    ).blocked_autorange(min_run_time=1))
+
+compare = benchmark.Compare(results)
+compare.trim_significant_figures()
+compare.print()
+
+######################################################################
+# .. code-block:: none
+#    :caption: Output
+#
+#     [--------------------- Batched dot ---------------------]
+#                                          |  mul/sum  |   bmm 
+#     1 threads: ----------------------------------------------
+#           725    x 257                   |      87   |    180
+#           49     x 383                   |      15   |     30
+#           34     x 1468                  |      30   |    118
+#           187    x 5039                  |     400   |   1200
+#           2140   x 1296 (discontiguous)  |    2000   |  41000
+#           78     x 1598                  |      74   |    310
+#           519    x 763                   |     190   |   1500
+#           141    x 1082                  |      87   |    500
+#           78     x 5    (discontiguous)  |       9   |     20
+#           187    x 1                     |      12   |     10
+#
+#     Times are in microseconds (us). 
+#
+
+######################################################################
+# There is a lot of flexibility for defining your own ``fuzzers`` which
+# is great for creating a powerful set of inputs to benchmark. But to
+# make things even simpler, PyTorch benchmark module comes with some
+# built-in ``fuzzers`` for common benchmarking needs. Let's take a look at
+# how we can use one of these built-in ``fuzzers``.
+#
+
+from torch.utils.benchmark.op_fuzzers import binary
+
+results = []
+for tensors, tensor_params, params in binary.BinaryOpFuzzer(seed=0).take(10):
+    sub_label=f"{params['k0']:<6} x {params['k1']:<4} {'' if tensor_params['x']['is_contiguous'] else '(discontiguous)'}"
+    results.append(benchmark.Timer(
+        stmt='batched_dot_mul_sum(x, x)',
+        setup='from __main__ import batched_dot_mul_sum',
+        globals=tensors,
+        label='Batched dot',
+        sub_label=sub_label,
+        description='mul/sum',
+    ).blocked_autorange(min_run_time=1))
+    results.append(benchmark.Timer(
+        stmt='batched_dot_bmm(x, x)',
+        setup='from __main__ import batched_dot_bmm',
+        globals=tensors,
+        label='Batched dot',
+        sub_label=sub_label,
+        description='bmm',
+    ).blocked_autorange(min_run_time=1))
+
+compare = benchmark.Compare(results)
+compare.trim_significant_figures()
+compare.colorize(rowwise=True)
+compare.print()
+
+######################################################################
+# .. code-block:: none
+#    :caption: Output
+#
+#     [----------------------- Batched dot ------------------------]
+#                                              |  mul/sum  |   bmm  
+#     1 threads: ---------------------------------------------------
+#           64     x 473  (discontiguous)      |    10000  |   40000
+#           16384  x 12642115 (discontiguous)  |       31  |      78
+#           8192   x 892                       |     4800  |   20400
+#           512    x 64   (discontiguous)      |   110000  |  400000
+#           493    x 27   (discontiguous)      |     1100  |    2440
+#           118    x 32   (discontiguous)      |      870  |    2030
+#           16     x 495  (discontiguous)      |    23600  |   24000
+#           488    x 62374                     |    90000  |  100000
+#           240372 x 69                        |    40000  |   16000
+#           40156  x 32   (discontiguous)      |     2670  |    5000
+#    
+#     Times are in microseconds (us).
+#
+
+######################################################################
+# 8. Collecting instruction counts with ``Callgrind``
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# One of the challenges of optimizing code is the variation and opacity of
+# wall time. There are many sources of non-determinism, from adaptive clock
+# speeds to resource contention with other processes. Furthermore, end-to-end
+# time gives no insight into where time is being spent, which is really what
+# we're interested in when optimizing code.
+#
+# A complementary approach is to also collect instruction counts. These counts
+# are a proxy metric and do not capture all aspects of performance
+# (e.g. memory or I/O bound tasks), however they do have several useful
+# properties. Instruction counts are reproducible, insensitive to environmental
+# variation, and offer fine grained insight into where a program is spending
+# cycles.
+#
+# To see the utility of instruction counts, let us look at how we might
+# reduce the overhead of `batched_dot_mul_sum`. The obvious solution is to
+# move it to C++, so we avoid going between Python and C++ multiple times.
+#
+# Fortunately, the source is nearly identical. One question that we have to ask
+# in C++ is whether we should take arguments by value or reference.
+#
+
+batched_dot_src = """\
+/* ---- Python ---- */
+// def batched_dot_mul_sum(a, b):
+//     return a.mul(b).sum(-1)
+
+torch::Tensor batched_dot_mul_sum_v0(
+    const torch::Tensor a,
+    const torch::Tensor b) {
+  return a.mul(b).sum(-1);
+}
+
+torch::Tensor batched_dot_mul_sum_v1(
+    const torch::Tensor& a,
+    const torch::Tensor& b) {
+  return a.mul(b).sum(-1);
+}
+"""
+
+
+# PyTorch makes it easy to test our C++ implementations by providing a utility
+# to JIT compile C++ source into Python extensions:
+import os
+from torch.utils import cpp_extension
+cpp_lib = cpp_extension.load_inline(
+    name='cpp_lib',
+    cpp_sources=batched_dot_src,
+    extra_cflags=['-O3'],
+    extra_include_paths=[
+        # `load_inline` needs to know where to find ``pybind11`` headers.
+        os.path.join(os.getenv('CONDA_PREFIX'), 'include')
+    ],
+    functions=['batched_dot_mul_sum_v0', 'batched_dot_mul_sum_v1']
+)
+
+# `load_inline` will create a shared object that is loaded into Python. When we collect
+# instruction counts Timer will create a subprocess, so we need to re-import it. The
+# import process is slightly more complicated for C extensions, but that's all we're
+# doing here.
+module_import_str = f"""\
+# https://stackoverflow.com/questions/67631/how-to-import-a-module-given-the-full-path
+import importlib.util
+spec = importlib.util.spec_from_file_location("cpp_lib", {repr(cpp_lib.__file__)})
+cpp_lib = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(cpp_lib)"""
+
+import textwrap
+def pretty_print(result):
+    """Import machinery for ``cpp_lib.so`` can get repetitive to look at."""
+    print(repr(result).replace(textwrap.indent(module_import_str, "  "), "  import cpp_lib"))
+
+
+t_baseline = benchmark.Timer(
+    stmt='batched_dot_mul_sum(x, x)',
+    setup='''\
+from __main__ import batched_dot_mul_sum
+x = torch.randn(2, 2)''')
+
+t0 = benchmark.Timer(
+    stmt='cpp_lib.batched_dot_mul_sum_v0(x, x)',
+    setup=f'''\
+{module_import_str}
+x = torch.randn(2, 2)''')
+
+t1 = benchmark.Timer(
+    stmt='cpp_lib.batched_dot_mul_sum_v1(x, x)',
+    setup=f'''\
+{module_import_str}
+x = torch.randn(2, 2)''')
+
+# Moving to C++ did indeed reduce overhead, but it's hard to tell which
+# calling convention is more efficient. v1 (call with references) seems to
+# be a bit faster, but it's within measurement error.
+pretty_print(t_baseline.blocked_autorange())
+pretty_print(t0.blocked_autorange())
+pretty_print(t1.blocked_autorange())
+
+######################################################################
+# .. code-block:: none
+#    :caption: Output
+#
+#     <torch.utils.benchmark.utils.common.Measurement object at 0x7fb16935d2e8>
+#     batched_dot_mul_sum(x, x)
+#     setup:
+#       from __main__ import batched_dot_mul_sum
+#       x = torch.randn(2, 2)
+#    
+#       6.92 us
+#       1 measurement, 100000 runs , 1 thread
+#     <torch.utils.benchmark.utils.common.Measurement object at 0x7fb16935d2e8>
+#     cpp_lib.batched_dot_mul_sum_v0(x, x)
+#     setup:
+#       import cpp_lib
+#       x = torch.randn(2, 2)
+#    
+#       5.29 us
+#       1 measurement, 100000 runs , 1 thread
+#     <torch.utils.benchmark.utils.common.Measurement object at 0x7fb16935d2e8>
+#     cpp_lib.batched_dot_mul_sum_v1(x, x)
+#     setup:
+#       import cpp_lib
+#       x = torch.randn(2, 2)
+#    
+#       5.22 us
+#       1 measurement, 100000 runs , 1 thread
+#
+
+# Let's use ``Callgrind`` to determine which is better.
+stats_v0 = t0.collect_callgrind()
+stats_v1 = t1.collect_callgrind()
+
+pretty_print(stats_v0)
+pretty_print(stats_v1)
+
+# `.as_standardized` removes file names and some path prefixes, and makes
+# it easier to read the function symbols.
+stats_v0 = stats_v0.as_standardized()
+stats_v1 = stats_v1.as_standardized()
+
+# `.delta` diffs the instruction counts, and `.denoise` removes several
+# functions in the Python interpreter that are known to have significant
+# jitter.
+delta = stats_v1.delta(stats_v0).denoise()
+
+# `.transform` is a convenience API for transforming function names. It is
+# useful for increasing cancelation when ``diff-ing`` instructions, as well as
+# just generally improving readability.
+replacements = (
+    ("???:void pybind11", "pybind11"),
+    ("batched_dot_mul_sum_v0", "batched_dot_mul_sum_v1"),
+    ("at::Tensor, at::Tensor", "..."),
+    ("at::Tensor const&, at::Tensor const&", "..."),
+    ("auto torch::detail::wrap_pybind_function_impl_", "wrap_pybind_function_impl_"),
+)
+for before, after in replacements:
+    delta = delta.transform(lambda l: l.replace(before, after))
+
+# We can use print options to control how much of the function to display.
+torch.set_printoptions(linewidth=160)
+
+# Once parsed, the instruction counts make clear that passing `a` and `b`
+# by reference is more efficient as it skips some ``c10::TensorImpl`` bookkeeping
+# for the intermediate Tensors, and is also works better with ``pybind11``. This
+# is consistent with our noisy wall time observations.
+print(delta)
+
+######################################################################
+# .. code-block::
+#
+#     <torch.utils.benchmark.utils.valgrind_wrapper.timer_interface.CallgrindStats object at 0x7fb0f06e7630>
+#     cpp_lib.batched_dot_mul_sum_v0(x, x)
+#     setup:
+#       import cpp_lib
+#       x = torch.randn(2, 2)
+#                                All          Noisy symbols removed
+#         Instructions:      2392671                    2392671
+#         Baseline:             4367                       4367
+#     100 runs per measurement, 1 thread
+#     Warning: PyTorch was not built with debug symbols.
+#              Source information may be limited. Rebuild with
+#              REL_WITH_DEB_INFO=1 for more detailed results.
+#     <torch.utils.benchmark.utils.valgrind_wrapper.timer_interface.CallgrindStats object at 0x7fb10400d208>
+#     cpp_lib.batched_dot_mul_sum_v1(x, x)
+#     setup:
+#       import cpp_lib
+#       x = torch.randn(2, 2)
+#                                All          Noisy symbols removed
+#         Instructions:      2378978                    2378978
+#         Baseline:             4367                       4367
+#         100 runs per measurement, 1 thread
+#         Warning: PyTorch was not built with debug symbols.
+#                  Source information may be limited. Rebuild with
+#                  REL_WITH_DEB_INFO=1 for more detailed results.
+#         <torch.utils.benchmark.utils.valgrind_wrapper.timer_interface.FunctionCounts object at 0x7fb1000ab358>
+#               86  ???:0x000000000020d9e0
+#           56  ???:0x000000000020db10
+#        -1100  pybind11::cpp_function::initialize<wrap_pybind_function_impl_<at::Tensor ... r (&)(...), std::integer_sequence<unsigned long, 0ul, 1ul>)::{lambda(...)
+#        -1600  ???:wrap_pybind_function_impl_<at::Tensor (&)(...), 0ul, 1ul>(at::Tensor (&)(...), std::integer_sequence<unsigned long, 0ul, 1ul>)::{lambda(...)
+#        -5200  ???:c10::intrusive_ptr<c10::TensorImpl, c10::UndefinedTensorImpl>::reset_()
+#        -5935  ???:0x000000000022c0e0
+#     Total: -13693
+#
+
+
+######################################################################
+# Learn More
+# ----------
+#
+# Take a look at these other recipes to continue your learning:
+#
+# -  `PyTorch Profiler <https://docs.pytorch.org/tutorials/recipes/recipes/profiler_recipe.html>`_
+#
diff --git a/recipes_source/recipes/changing_default_device.py b/recipes_source/recipes/changing_default_device.py
new file mode 100644
index 00000000000..103560fd743
--- /dev/null
+++ b/recipes_source/recipes/changing_default_device.py
@@ -0,0 +1,50 @@
+"""
+Changing default device
+=======================
+
+It is common practice to write PyTorch code in a device-agnostic way,
+and then switch between CPU and CUDA depending on what hardware is available.
+Typically, to do this you might have used if-statements and ``cuda()`` calls
+to do this:
+
+.. note::
+   This recipe requires PyTorch 2.0.0 or later.
+
+"""
+import torch
+
+USE_CUDA = False
+
+mod = torch.nn.Linear(20, 30)
+if USE_CUDA:
+    mod.cuda()
+
+device = 'cpu'
+if USE_CUDA:
+    device = 'cuda'
+inp = torch.randn(128, 20, device=device)
+print(mod(inp).device)
+
+###################################################################
+# PyTorch now also has a context manager which can take care of the
+# device transfer automatically. Here is an example:
+
+with torch.device('cuda'):
+    mod = torch.nn.Linear(20, 30)
+    print(mod.weight.device)
+    print(mod(torch.randn(128, 20)).device)
+
+#########################################
+# You can also set it globally like this: 
+
+torch.set_default_device('cuda')
+
+mod = torch.nn.Linear(20, 30)
+print(mod.weight.device)
+print(mod(torch.randn(128, 20)).device)
+
+################################################################
+# This function imposes a slight performance cost on every Python
+# call to the torch API (not just factory functions). If this
+# is causing problems for you, please comment on
+# `this issue <https://github.com/pytorch/pytorch/issues/92701>`__
diff --git a/recipes_source/recipes/defining_a_neural_network.py b/recipes_source/recipes/defining_a_neural_network.py
new file mode 100644
index 00000000000..da58a1c5752
--- /dev/null
+++ b/recipes_source/recipes/defining_a_neural_network.py
@@ -0,0 +1,183 @@
+"""
+Defining a Neural Network in PyTorch
+====================================
+Deep learning uses artificial neural networks (models), which are
+computing systems that are composed of many layers of interconnected
+units. By passing data through these interconnected units, a neural
+network is able to learn how to approximate the computations required to
+transform inputs into outputs. In PyTorch, neural networks can be
+constructed using the ``torch.nn`` package.
+
+Introduction
+------------
+PyTorch provides the elegantly designed modules and classes, including
+``torch.nn``, to help you create and train neural networks. An
+``nn.Module`` contains layers, and a method ``forward(input)`` that
+returns the ``output``.
+
+In this recipe, we will use ``torch.nn`` to define a neural network
+intended for the `MNIST
+dataset <hhttps://pytorch.org/vision/stable/generated/torchvision.datasets.MNIST.html#torchvision.datasets.MNIST>`__.
+
+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. Specify how data will pass through your model
+# 4. [Optional] Pass data through your model to test
+# 
+# 1. Import necessary libraries for loading our data
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# 
+# For this recipe, we will use ``torch`` and its subsidiaries ``torch.nn``
+# and ``torch.nn.functional``.
+# 
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+######################################################################
+# 2. Define and initialize the neural network
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# 
+# Our network will recognize images. We will use a process built into
+# PyTorch called convolution. Convolution adds each element of an image to
+# its local neighbors, weighted by a kernel, or a small matrix, that
+# helps us extract certain features (like edge detection, sharpness,
+# blurriness, etc.) from the input image.
+# 
+# There are two requirements for defining the ``Net`` class of your model.
+# The first is writing an __init__ function that references
+# ``nn.Module``. This function is where you define the fully connected
+# layers in your neural network.
+# 
+# Using convolution, we will define our model to take 1 input image
+# channel, and output match our target of 10 labels representing numbers 0
+# through 9. This algorithm is yours to create, we will follow a standard
+# MNIST algorithm.
+# 
+
+class Net(nn.Module):
+    def __init__(self):
+      super(Net, self).__init__()
+
+      # First 2D convolutional layer, taking in 1 input channel (image),
+      # outputting 32 convolutional features, with a square kernel size of 3
+      self.conv1 = nn.Conv2d(1, 32, 3, 1)
+      # Second 2D convolutional layer, taking in the 32 input layers,
+      # outputting 64 convolutional features, with a square kernel size of 3
+      self.conv2 = nn.Conv2d(32, 64, 3, 1)
+
+      # Designed to ensure that adjacent pixels are either all 0s or all active
+      # with an input probability
+      self.dropout1 = nn.Dropout2d(0.25)
+      self.dropout2 = nn.Dropout2d(0.5)
+
+      # First fully connected layer
+      self.fc1 = nn.Linear(9216, 128)
+      # Second fully connected layer that outputs our 10 labels
+      self.fc2 = nn.Linear(128, 10)
+
+my_nn = Net()
+print(my_nn)
+
+
+######################################################################
+# We have finished defining our neural network, now we have to define how
+# our data will pass through it.
+# 
+# 3. Specify how data will pass through your model
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# 
+# When you use PyTorch to build a model, you just have to define the
+# ``forward`` function, that will pass the data into the computation graph
+# (i.e. our neural network). This will represent our feed-forward
+# algorithm.
+# 
+# You can use any of the Tensor operations in the ``forward`` function.
+# 
+
+class Net(nn.Module):
+    def __init__(self):
+      super(Net, self).__init__()
+      self.conv1 = nn.Conv2d(1, 32, 3, 1)
+      self.conv2 = nn.Conv2d(32, 64, 3, 1)
+      self.dropout1 = nn.Dropout2d(0.25)
+      self.dropout2 = nn.Dropout2d(0.5)
+      self.fc1 = nn.Linear(9216, 128)
+      self.fc2 = nn.Linear(128, 10)
+
+    # x represents our data
+    def forward(self, x):
+      # Pass data through conv1
+      x = self.conv1(x)
+      # Use the rectified-linear activation function over x
+      x = F.relu(x)
+
+      x = self.conv2(x)
+      x = F.relu(x)
+
+      # Run max pooling over x
+      x = F.max_pool2d(x, 2)
+      # Pass data through dropout1
+      x = self.dropout1(x)
+      # Flatten x with start_dim=1
+      x = torch.flatten(x, 1)
+      # Pass data through ``fc1``
+      x = self.fc1(x)
+      x = F.relu(x)
+      x = self.dropout2(x)
+      x = self.fc2(x)
+
+      # Apply softmax to x 
+      output = F.log_softmax(x, dim=1)
+      return output
+
+
+######################################################################
+# 4. [Optional] Pass data through your model to test
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# 
+# To ensure we receive our desired output, let’s test our model by passing
+# some random data through it.
+# 
+
+# Equates to one random 28x28 image
+random_data = torch.rand((1, 1, 28, 28))
+
+my_nn = Net()
+result = my_nn(random_data)
+print (result)
+
+
+######################################################################
+# Each number in this resulting tensor equates to the prediction of the
+# label the random tensor is associated to.
+# 
+# Congratulations! You have successfully defined a neural network in
+# PyTorch.
+# 
+# Learn More
+# ----------
+# 
+# Take a look at these other recipes to continue your learning:
+# 
+# - `What is a state_dict in PyTorch <https://pytorch.org/tutorials/recipes/recipes/what_is_state_dict.html>`__
+# - `Saving and loading models for inference in PyTorch <https://pytorch.org/tutorials/recipes/recipes/saving_and_loading_models_for_inference.html>`__
diff --git a/recipes_source/recipes/module_load_state_dict_tips.py b/recipes_source/recipes/module_load_state_dict_tips.py
new file mode 100644
index 00000000000..70e9830cb3c
--- /dev/null
+++ b/recipes_source/recipes/module_load_state_dict_tips.py
@@ -0,0 +1,172 @@
+"""
+
+Tips for Loading an ``nn.Module`` from a Checkpoint
+===================================================
+**Author:** `Mikayla Gawarecki <https://github.com/mikaylagawarecki>`_
+
+If you're loading a checkpoint and want to reduce compute and memory as much as possible,
+this tutorial shares some recommended practices. In particular, we will discuss
+
+1.  The ``mmap`` keyword argument on ``torch.load``
+2.  The ``torch.device()`` context manager
+3.  The ``assign`` keyword argument on ``nn.Module.load_state_dict()``
+
+.. note::
+   This recipe requires PyTorch 2.1.0 or later.
+"""
+
+
+###############################################################################
+# Let us consider a simple ``nn.Module`` that contains a list of Linear layers:
+import torch
+from torch import nn
+import time
+
+class SomeModule(torch.nn.Module):
+    def __init__(self, size):
+        super().__init__()
+        self.linears = nn.ModuleList([nn.Linear(size, size) for i in range(10)])
+
+    def forward(self, x):
+        return self.linears(x)
+
+
+m = SomeModule(1000)
+torch.save(m.state_dict(), 'checkpoint.pth')
+
+#################################################################################
+# The following snippet demonstrates the use of the the ``mmap`` keyword argument
+# to ``torch.load``, the ``torch.device()`` context manager and the ``assign``
+# keyword argument to ``nn.Module.load_state_dict()``.
+
+state_dict = torch.load('checkpoint.pth', mmap=True, weights_only=True)
+with torch.device('meta'):
+  meta_m = SomeModule(1000)
+meta_m.load_state_dict(state_dict, assign=True)
+
+#############################################################################
+# Compare the snippet below to the one above:
+
+state_dict = torch.load('checkpoint.pth', weights_only=True)
+m = SomeModule(1000)
+m.load_state_dict(state_dict)
+
+#############################################################################
+# The second example does not use any of the features listed above and will be
+# less compute and memory efficient for loading a checkpoint. In the following
+# sections, we will discuss each of the features in further detail.
+
+#####################################################################################
+# Using ``torch.load(mmap=True)``
+# -------------------------------
+# First, let us consider what happens when we load the checkpoint with ``torch.load``.
+# When we save a checkpoint with ``torch.save``, tensor storages are tagged with the device they are
+# saved on. With ``torch.load``, tensor storages will be loaded to the device
+# they were tagged with (unless this behavior is overridden using the
+# ``map_location`` flag). For ease of explanation, let us assume that the tensors
+# were saved on CPU. This means that on the first line all tensor storages will be
+# loaded into CPU RAM, which can be undesirable when:
+#
+# * CPU RAM is smaller than the size of the checkpoint.
+# * Waiting for the entire checkpoint to be loaded into RAM before performing, for example, some per-tensor processing.
+
+start_time = time.time()
+state_dict = torch.load('checkpoint.pth', weights_only=True)
+end_time = time.time()
+print(f"loading time without mmap={end_time - start_time}")
+
+#################################################################################
+# The ``mmap`` keyword argument to ``torch.load`` attempts to solve the above two
+# problems. As its name implies, the ``mmap`` keyword argument to ``torch.load``
+# makes use of an `mmap call <https://man7.org/linux/man-pages/man2/mmap.2.html>`_
+# which maps a file on disk into virtual memory and lets the OS handle loading and
+# unloading into physical memory automatically. When this flag is passed, tensor
+# storages will be memory-mapped.
+
+start_time = time.time()
+state_dict = torch.load('checkpoint.pth', mmap=True, weights_only=True)
+end_time = time.time()
+print(f"loading time with mmap={end_time - start_time}")
+
+######################################################################################
+# As mentioned above, one can use this argument to do per-tensor processing on a
+# checkpoint without loading all tensor storages into CPU memory upfront. For example:
+def my_special_routine(t, device):
+    # this could be a much fancier operation
+    return t.to(dtype=torch.bfloat16, device=device)
+
+def my_processing_function(key, device):
+    t = state_dict[key]
+    processed_t = my_special_routine(t, device)
+    del t
+    state_dict[key] = processed_t
+
+for key in state_dict.keys():
+    device = torch.device('cuda')
+    my_processing_function(key, device)
+
+##################################################
+# Using ``torch.device('meta')``
+# ------------------------------
+# Next, let's consider the creation of the module.
+m = SomeModule(1000)
+
+#######################################################################################################
+# This allocates memory for all parameters/buffers and initializes them per
+# the default initialization schemes defined in ``SomeModule.__init__()``, which
+# is wasteful when we want to load a checkpoint for the following reasons:
+#
+# * The result of the initialization kernels will be overwritten by ``load_state_dict()`` without ever being used, so
+#   initialization is wasteful.
+# * We are allocating memory for these parameters/buffers in RAM while ``torch.load`` of the saved state dictionary also
+#   allocates memory in RAM for the parameters/buffers in the checkpoint.
+#
+# In order to solve these two problems, we can use the ``torch.device()``
+# context manager with ``device='meta'`` when we instantiate the ``nn.Module()``.
+#
+# The `torch.device() <https://pytorch.org/docs/main/tensor_attributes.html#torch-device>`_
+# context manager makes sure that factory calls will be performed as if they
+# were passed the specified ``device`` as an argument. Tensors on ``torch.device('meta')`` do not
+# carry data. However, they possess all other metadata a tensor carries such as ``.size()``, ``.stride()``,
+# ``.requires_grad``, and others.
+with torch.device('meta'):
+  new_m = SomeModule(1000)
+
+########################################################
+# Using ``load_state_dict(assign=True)``
+# --------------------------------------
+# Next, we consider the loading of the state dictionary.
+
+m.load_state_dict(state_dict)
+
+######################################################################################
+# ``nn.Module.load_state_dict()`` is usually implemented via an in-place
+# ``param_in_model.copy_(param_in_state_dict)``. This means that the parameter/buffer
+# with the corresponding key in the state dictionary is copied into the
+# parameter/buffer in the ``nn.Module``.
+#
+# However, an in-place copy into a tensor on the ``meta`` device is a no-op.
+# In order to avoid this, we can pass the ``assign=True`` keyword argument to
+# ``load_state_dict()``.
+#
+# A caveat here is that since optimizers hold a reference to
+# ``nn.Module.parameters()``, the optimizer must be initialized after the module
+# is loaded from state dict if ``assign=True`` is passed.
+
+# As of PyTorch 2.3.0, one can use ``torch.__future__.set_swap_module_params_on_conversion`` to
+# avoid this caveat. This `recipe <https://pytorch.org/tutorials/recipes/recipes/swap_tensors.html>`_
+# provides more details.
+
+new_m.load_state_dict(state_dict, assign=True)
+# Before 2.3.0, this MUST be done AFTER the load_state_dict with assign.
+# In versions >= 2.3.0, one can consider setting ``torch.__future__.set_swap_module_params_on_conversion``
+opt = torch.optim.SGD(new_m.parameters(), lr=1e-3)
+
+###############################################################################
+# Conclusion
+# -------------
+#
+# To recap, in this tutorial we learned about ``torch.load(mmap=True)``, the
+# ``torch.device()`` context manager with ``device=meta``, and
+# ``nn.Module.load_state_dict(assign=True)`` as well as how these tools could
+# be used to aid when loading a model from a checkpoint.
diff --git a/recipes_source/recipes/profiler_recipe.py b/recipes_source/recipes/profiler_recipe.py
new file mode 100644
index 00000000000..a8d1a4dc6b3
--- /dev/null
+++ b/recipes_source/recipes/profiler_recipe.py
@@ -0,0 +1,483 @@
+"""
+PyTorch Profiler
+====================================
+**Author:** `Shivam Raikundalia <https://github.com/sraikund16>`_
+"""
+
+######################################################################
+# This recipe explains how to use PyTorch profiler and measure the time and
+# memory consumption of the model's operators.
+#
+# Introduction
+# ------------
+# PyTorch includes a simple profiler API that is useful when the user needs
+# to determine the most expensive operators in the model.
+#
+# In this recipe, we will use a simple Resnet model to demonstrate how to
+# use the profiler to analyze model performance.
+#
+# Prerequisites
+# ---------------
+# - ``torch >= 2.3.0``
+#
+# Setup
+# -----
+# To install ``torch`` and ``torchvision`` use the following command:
+#
+# .. code-block:: sh
+#
+#    pip install torch torchvision
+#
+
+######################################################################
+# Steps
+# -----
+#
+# 1. Import all necessary libraries
+# 2. Instantiate a simple Resnet model
+# 3. Using profiler to analyze execution time
+# 4. Using profiler to analyze memory consumption
+# 5. Using tracing functionality
+# 6. Examining stack traces
+# 7. Using profiler to analyze long-running jobs
+#
+# 1. Import all necessary libraries
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# In this recipe we will use ``torch``, ``torchvision.models``
+# and ``profiler`` modules:
+#
+
+import torch
+import torchvision.models as models
+from torch.profiler import profile, ProfilerActivity, record_function
+
+
+######################################################################
+# 2. Instantiate a simple Resnet model
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# Let's create an instance of a Resnet model and prepare an input
+# for it:
+#
+
+model = models.resnet18()
+inputs = torch.randn(5, 3, 224, 224)
+
+######################################################################
+# 3. Using profiler to analyze execution time
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# PyTorch profiler is enabled through the context manager and accepts
+# a number of parameters, some of the most useful are:
+#
+# - ``activities`` - a list of activities to profile:
+#    - ``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;
+#
+# Note: when using CUDA, profiler also shows the runtime CUDA events
+# occurring on the host.
+
+######################################################################
+# Let's see how we can use profiler to analyze the execution time:
+
+with profile(activities=[ProfilerActivity.CPU], record_shapes=True) as prof:
+    with record_function("model_inference"):
+        model(inputs)
+
+######################################################################
+# Note that we can use ``record_function`` context manager to label
+# arbitrary code ranges with user provided names
+# (``model_inference`` is used as a label in the example above).
+#
+# Profiler allows one to check which operators were called during the
+# execution of a code range wrapped with a profiler context manager.
+# If multiple profiler ranges are active at the same time (e.g. in
+# parallel PyTorch threads), each profiling context manager tracks only
+# the operators of its corresponding range.
+# Profiler also automatically profiles the asynchronous tasks launched
+# with ``torch.jit._fork`` and (in case of a backward pass)
+# the backward pass operators launched with ``backward()`` call.
+#
+# Let's print out the stats for the execution above:
+
+print(prof.key_averages().table(sort_by="cpu_time_total", row_limit=10))
+
+######################################################################
+# The output will look like (omitting some columns):
+#
+# .. code-block:: sh
+#
+#    ---------------------------------  ------------  ------------  ------------  ------------
+#                                 Name      Self CPU     CPU total  CPU time avg    # of Calls
+#    ---------------------------------  ------------  ------------  ------------  ------------
+#                      model_inference       5.509ms      57.503ms      57.503ms             1
+#                         aten::conv2d     231.000us      31.931ms       1.597ms            20
+#                    aten::convolution     250.000us      31.700ms       1.585ms            20
+#                   aten::_convolution     336.000us      31.450ms       1.573ms            20
+#             aten::mkldnn_convolution      30.838ms      31.114ms       1.556ms            20
+#                     aten::batch_norm     211.000us      14.693ms     734.650us            20
+#         aten::_batch_norm_impl_index     319.000us      14.482ms     724.100us            20
+#              aten::native_batch_norm       9.229ms      14.109ms     705.450us            20
+#                           aten::mean     332.000us       2.631ms     125.286us            21
+#                         aten::select       1.668ms       2.292ms       8.988us           255
+#    ---------------------------------  ------------  ------------  ------------  ------------
+#    Self CPU time total: 57.549m
+#
+
+######################################################################
+# Here we see that, as expected, most of the time is spent in convolution (and specifically in ``mkldnn_convolution``
+# for PyTorch compiled with ``MKL-DNN`` support).
+# Note the difference between self cpu time and cpu time - operators can call other operators, self cpu time excludes time
+# spent in children operator calls, while total cpu time includes it. You can choose to sort by the self cpu time by passing
+# ``sort_by="self_cpu_time_total"`` into the ``table`` call.
+#
+# To get a finer granularity of results and include operator input shapes, pass ``group_by_input_shape=True``
+# (note: this requires running the profiler with ``record_shapes=True``):
+
+print(
+    prof.key_averages(group_by_input_shape=True).table(
+        sort_by="cpu_time_total", row_limit=10
+    )
+)
+
+########################################################################################
+# The output might look like this (omitting some columns):
+#
+# .. code-block:: sh
+#
+#    ---------------------------------  ------------  -------------------------------------------
+#                                 Name     CPU total                                 Input Shapes
+#    ---------------------------------  ------------  -------------------------------------------
+#                      model_inference      57.503ms                                           []
+#                         aten::conv2d       8.008ms      [5,64,56,56], [64,64,3,3], [], ..., []]
+#                    aten::convolution       7.956ms     [[5,64,56,56], [64,64,3,3], [], ..., []]
+#                   aten::_convolution       7.909ms     [[5,64,56,56], [64,64,3,3], [], ..., []]
+#             aten::mkldnn_convolution       7.834ms     [[5,64,56,56], [64,64,3,3], [], ..., []]
+#                         aten::conv2d       6.332ms    [[5,512,7,7], [512,512,3,3], [], ..., []]
+#                    aten::convolution       6.303ms    [[5,512,7,7], [512,512,3,3], [], ..., []]
+#                   aten::_convolution       6.273ms    [[5,512,7,7], [512,512,3,3], [], ..., []]
+#             aten::mkldnn_convolution       6.233ms    [[5,512,7,7], [512,512,3,3], [], ..., []]
+#                         aten::conv2d       4.751ms  [[5,256,14,14], [256,256,3,3], [], ..., []]
+#    ---------------------------------  ------------  -------------------------------------------
+#    Self CPU time total: 57.549ms
+#
+
+######################################################################
+# Note the occurrence of ``aten::convolution`` twice with different input shapes.
+
+######################################################################
+# Profiler can also be used to analyze performance of models executed on GPUs:
+# Users could switch between cpu, cuda and xpu
+activities = [ProfilerActivity.CPU]
+if torch.cuda.is_available():
+    device = "cuda"
+    activities += [ProfilerActivity.CUDA]
+elif torch.xpu.is_available():
+    device = "xpu"
+    activities += [ProfilerActivity.XPU]
+else:
+    print(
+        "Neither CUDA nor XPU devices are available to demonstrate profiling on acceleration devices"
+    )
+    import sys
+
+    sys.exit(0)
+
+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=sort_by_keyword, row_limit=10))
+
+######################################################################
+# (Note: the first use of CUDA profiling may bring an extra overhead.)
+
+######################################################################
+# The resulting table output (omitting some columns):
+#
+# .. code-block:: sh
+#
+#    -------------------------------------------------------  ------------  ------------
+#                                                       Name     Self CUDA    CUDA total
+#    -------------------------------------------------------  ------------  ------------
+#                                            model_inference       0.000us      11.666ms
+#                                               aten::conv2d       0.000us      10.484ms
+#                                          aten::convolution       0.000us      10.484ms
+#                                         aten::_convolution       0.000us      10.484ms
+#                                 aten::_convolution_nogroup       0.000us      10.484ms
+#                                          aten::thnn_conv2d       0.000us      10.484ms
+#                                  aten::thnn_conv2d_forward      10.484ms      10.484ms
+#    void at::native::im2col_kernel<float>(long, float co...       3.844ms       3.844ms
+#                                          sgemm_32x32x32_NN       3.206ms       3.206ms
+#                                      sgemm_32x32x32_NN_vec       3.093ms       3.093ms
+#    -------------------------------------------------------  ------------  ------------
+#    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`` for CUDA or ``gen_conv`` for XPU).
+
+######################################################################
+# 4. Using profiler to analyze memory consumption
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# PyTorch profiler can also show the amount of memory (used by the model's tensors)
+# that was allocated (or released) during the execution of the model's operators.
+# In the output below, 'self' memory corresponds to the memory allocated (released)
+# by the operator, excluding the children calls to the other operators.
+# To enable memory profiling functionality pass ``profile_memory=True``.
+
+model = models.resnet18()
+inputs = torch.randn(5, 3, 224, 224)
+
+with profile(
+    activities=[ProfilerActivity.CPU], profile_memory=True, record_shapes=True
+) as prof:
+    model(inputs)
+
+print(prof.key_averages().table(sort_by="self_cpu_memory_usage", row_limit=10))
+
+# (omitting some columns)
+# ---------------------------------  ------------  ------------  ------------
+#                              Name       CPU Mem  Self CPU Mem    # of Calls
+# ---------------------------------  ------------  ------------  ------------
+#                       aten::empty      94.79 Mb      94.79 Mb           121
+#     aten::max_pool2d_with_indices      11.48 Mb      11.48 Mb             1
+#                       aten::addmm      19.53 Kb      19.53 Kb             1
+#               aten::empty_strided         572 b         572 b            25
+#                     aten::resize_         240 b         240 b             6
+#                         aten::abs         480 b         240 b             4
+#                         aten::add         160 b         160 b            20
+#               aten::masked_select         120 b         112 b             1
+#                          aten::ne         122 b          53 b             6
+#                          aten::eq          60 b          30 b             2
+# ---------------------------------  ------------  ------------  ------------
+# Self CPU time total: 53.064ms
+
+print(prof.key_averages().table(sort_by="cpu_memory_usage", row_limit=10))
+
+#############################################################################
+# The output might look like this (omitting some columns):
+#
+# .. code-block:: sh
+#
+#    ---------------------------------  ------------  ------------  ------------
+#                                 Name       CPU Mem  Self CPU Mem    # of Calls
+#    ---------------------------------  ------------  ------------  ------------
+#                          aten::empty      94.79 Mb      94.79 Mb           121
+#                     aten::batch_norm      47.41 Mb           0 b            20
+#         aten::_batch_norm_impl_index      47.41 Mb           0 b            20
+#              aten::native_batch_norm      47.41 Mb           0 b            20
+#                         aten::conv2d      47.37 Mb           0 b            20
+#                    aten::convolution      47.37 Mb           0 b            20
+#                   aten::_convolution      47.37 Mb           0 b            20
+#             aten::mkldnn_convolution      47.37 Mb           0 b            20
+#                     aten::max_pool2d      11.48 Mb           0 b             1
+#        aten::max_pool2d_with_indices      11.48 Mb      11.48 Mb             1
+#    ---------------------------------  ------------  ------------  ------------
+#    Self CPU time total: 53.064ms
+#
+
+######################################################################
+# 5. Using tracing functionality
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# Profiling results can be outputted as a ``.json`` trace file:
+# Tracing CUDA or XPU kernels
+# Users could switch between cpu, cuda and xpu
+activities = [ProfilerActivity.CPU]
+if torch.cuda.is_available():
+    device = "cuda"
+    activities += [ProfilerActivity.CUDA]
+elif torch.xpu.is_available():
+    device = "xpu"
+    activities += [ProfilerActivity.XPU]
+else:
+    print(
+        "Neither CUDA nor XPU devices are available to demonstrate profiling on acceleration devices"
+    )
+    import sys
+
+    sys.exit(0)
+
+model = models.resnet18().to(device)
+inputs = torch.randn(5, 3, 224, 224).to(device)
+
+with profile(activities=activities) as prof:
+    model(inputs)
+
+prof.export_chrome_trace("trace.json")
+
+######################################################################
+# You can examine the sequence of profiled operators and CUDA/XPU kernels
+# in Chrome trace viewer (``chrome://tracing``):
+#
+# .. image:: ../../_static/img/trace_img.png
+#    :scale: 25 %
+
+######################################################################
+# 6. Examining stack traces
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# Profiler can be used to analyze Python and TorchScript stack traces:
+sort_by_keyword = "self_" + device + "_time_total"
+
+with profile(
+    activities=activities,
+    with_stack=True,
+    experimental_config=torch._C._profiler._ExperimentalConfig(verbose=True),
+) as prof:
+    model(inputs)
+
+# Print aggregated stats
+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):
+#
+# .. code-block:: sh
+#
+#    -------------------------  -----------------------------------------------------------
+#                         Name  Source Location
+#    -------------------------  -----------------------------------------------------------
+#    aten::thnn_conv2d_forward  .../torch/nn/modules/conv.py(439): _conv_forward
+#                               .../torch/nn/modules/conv.py(443): forward
+#                               .../torch/nn/modules/module.py(1051): _call_impl
+#                               .../site-packages/torchvision/models/resnet.py(63): forward
+#                               .../torch/nn/modules/module.py(1051): _call_impl
+#    aten::thnn_conv2d_forward  .../torch/nn/modules/conv.py(439): _conv_forward
+#                               .../torch/nn/modules/conv.py(443): forward
+#                               .../torch/nn/modules/module.py(1051): _call_impl
+#                               .../site-packages/torchvision/models/resnet.py(59): forward
+#                               .../torch/nn/modules/module.py(1051): _call_impl
+#    -------------------------  -----------------------------------------------------------
+#    Self CPU time total: 34.016ms
+#    Self CUDA time total: 11.659ms
+#
+
+######################################################################
+# Note the two convolutions and the two call sites in ``torchvision/models/resnet.py`` script.
+#
+# (Warning: stack tracing adds an extra profiling overhead.)
+
+######################################################################
+# 7. Using profiler to analyze long-running jobs
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# PyTorch profiler offers an additional API to handle long-running jobs
+# (such as training loops). Tracing all of the execution can be
+# slow and result in very large trace files. To avoid this, use optional
+# arguments:
+#
+# - ``schedule`` - specifies a function that takes an integer argument (step number)
+#   as an input and returns an action for the profiler, the best way to use this parameter
+#   is to use ``torch.profiler.schedule`` helper function that can generate a schedule for you;
+# - ``on_trace_ready`` - specifies a function that takes a reference to the profiler as
+#   an input and is called by the profiler each time the new trace is ready.
+#
+# To illustrate how the API works, let's first consider the following example with
+# ``torch.profiler.schedule`` helper function:
+
+from torch.profiler import schedule
+
+my_schedule = schedule(skip_first=10, wait=5, warmup=1, active=3, repeat=2)
+
+######################################################################
+# Profiler assumes that the long-running job is composed of steps, numbered
+# starting from zero. The example above defines the following sequence of actions
+# for the profiler:
+#
+# 1. Parameter ``skip_first`` tells profiler that it should ignore the first 10 steps
+#    (default value of ``skip_first`` is zero);
+# 2. After the first ``skip_first`` steps, profiler starts executing profiler cycles;
+# 3. Each cycle consists of three phases:
+#
+#    - idling (``wait=5`` steps), during this phase profiler is not active;
+#    - warming up (``warmup=1`` steps), during this phase profiler starts tracing, but
+#      the results are discarded; this phase is used to discard the samples obtained by
+#      the profiler at the beginning of the trace since they are usually skewed by an extra
+#      overhead;
+#    - active tracing (``active=3`` steps), during this phase profiler traces and records data;
+# 4. An optional ``repeat`` parameter specifies an upper bound on the number of cycles.
+#    By default (zero value), profiler will execute cycles as long as the job runs.
+
+######################################################################
+# Thus, in the example above, profiler will skip the first 15 steps, spend the next step on the warm up,
+# actively record the next 3 steps, skip another 5 steps, spend the next step on the warm up, actively
+# record another 3 steps. Since the ``repeat=2`` parameter value is specified, the profiler will stop
+# the recording after the first two cycles.
+#
+# At the end of each cycle profiler calls the specified ``on_trace_ready`` function and passes itself as
+# an argument. This function is used to process the new trace - either by obtaining the table output or
+# by saving the output on disk as a trace file.
+#
+# 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 for CUDA and XPU Kernels:
+
+sort_by_keyword = "self_" + device + "_time_total"
+
+
+def trace_handler(p):
+    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=activities,
+    schedule=torch.profiler.schedule(wait=1, warmup=1, active=2),
+    on_trace_ready=trace_handler,
+) as p:
+    for idx in range(8):
+        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>`_
+# - `Visualizing models, data, and training with TensorBoard <https://pytorch.org/tutorials/intermediate/tensorboard_tutorial.html>`_ tutorial
+#
diff --git a/recipes_source/recipes/reasoning_about_shapes.py b/recipes_source/recipes/reasoning_about_shapes.py
new file mode 100644
index 00000000000..12c85dcb447
--- /dev/null
+++ b/recipes_source/recipes/reasoning_about_shapes.py
@@ -0,0 +1,88 @@
+"""
+Reasoning about Shapes in PyTorch
+=================================
+
+When writing models with PyTorch, it is commonly the case that the parameters
+to a given layer depend on the shape of the output of the previous layer. For
+example, the ``in_features`` of an ``nn.Linear`` layer must match the
+``size(-1)`` of the input. For some layers, the shape computation involves
+complex equations, for example convolution operations.
+
+One way around this is to run the forward pass with random inputs, but this is
+wasteful in terms of memory and compute.
+
+Instead, we can make use of the ``meta`` device to determine the output shapes
+of a layer without materializing any data.
+"""
+
+import torch
+import timeit
+
+t = torch.rand(2, 3, 10, 10, device="meta")
+conv = torch.nn.Conv2d(3, 5, 2, device="meta")
+start = timeit.default_timer()
+out = conv(t)
+end = timeit.default_timer()
+
+print(out)
+print(f"Time taken: {end-start}")
+
+
+##########################################################################
+# Observe that since data is not materialized, passing arbitrarily large
+# inputs will not significantly alter the time taken for shape computation.
+
+t_large = torch.rand(2**10, 3, 2**16, 2**16, device="meta")
+start = timeit.default_timer()
+out = conv(t_large)
+end = timeit.default_timer()
+
+print(out)
+print(f"Time taken: {end-start}")
+
+
+######################################################
+# Consider an arbitrary network such as the following:
+
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class Net(nn.Module):
+    def __init__(self):
+        super().__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 = torch.flatten(x, 1) # flatten all dimensions except batch
+        x = F.relu(self.fc1(x))
+        x = F.relu(self.fc2(x))
+        x = self.fc3(x)
+        return x
+
+
+###############################################################################
+# We can view the intermediate shapes within an entire network by registering a
+# forward hook to each layer that prints the shape of the output.
+
+def fw_hook(module, input, output):
+    print(f"Shape of output to {module} is {output.shape}.")
+
+
+# Any tensor created within this torch.device context manager will be
+# on the meta device.
+with torch.device("meta"):
+    net = Net()
+    inp = torch.randn((1024, 3, 32, 32))
+
+for name, layer in net.named_modules():
+    layer.register_forward_hook(fw_hook)
+
+out = net(inp)
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 00000000000..fbda1562201
--- /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.rst b/recipes_source/recipes/saving_and_loading_a_general_checkpoint.rst
new file mode 100644
index 00000000000..b868c26a6cd
--- /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.rst b/recipes_source/recipes/saving_and_loading_models_for_inference.rst
new file mode 100644
index 00000000000..19e1405dd81
--- /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.rst b/recipes_source/recipes/saving_multiple_models_in_one_file.rst
new file mode 100644
index 00000000000..33040e6c87b
--- /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/recipes/swap_tensors.py b/recipes_source/recipes/swap_tensors.py
new file mode 100644
index 00000000000..d3b90c6ebea
--- /dev/null
+++ b/recipes_source/recipes/swap_tensors.py
@@ -0,0 +1,241 @@
+"""
+Extension points in ``nn.Module`` for ``load_state_dict`` and tensor subclasses
+===============================================================================
+**Author:** `Mikayla Gawarecki <https://github.com/mikaylagawarecki>`_
+
+This recipe introduces a new utility function ``torch.utils.swap_tensors``
+as well as two new extension points where it has been integrated in
+``nn.Module``:
+
+* ``nn.Module.to()`` and related methods
+* ``nn.Module.load_state_dict()``
+
+.. note::
+    This recipe requires PyTorch 2.3.0 or later.
+"""
+
+###############################################################################
+# ``torch.utils.swap_tensors``
+# ----------------------------
+# ``torch.utils.swap_tensors`` (hereafter referred to as ``swap_tensors``) is a
+# utility function that takes in two Python tensors and swaps them.
+
+import torch
+import torch.nn as nn
+t1 = torch.arange(2)
+t2 = torch.arange(3)
+print(f"Before swapping, t1: {t1}, t2: {t2}")
+torch.utils.swap_tensors(t1, t2)
+print(f"After swapping, t1: {t1}, t2: {t2}")
+
+################################################################################
+# More specifically, ``swap_tensors`` swaps the Python ``__class__``, ``__dict__``
+# and ``__slots__`` of the two tensors, as well as their associated ``at::Tensor``.
+#
+#
+# Application to ``nn.Module``
+# ----------------------------
+# This utility is pertinent to ``nn.Module`` when a Python object outside
+# of the module holds a reference to parameters of the module. If an ``nn.Module``
+# modifies any of its parameters out of place, the object holding references to
+# the parameters will not see the change. A classic example of this is the
+# optimizer, which holds a reference to the parameters of the ``nn.Module``.
+# This leads to a silent correctness issue where the ``optimizer.step()`` will
+# run without error but the weights of the ``nn.Module`` will not be updated.
+
+mod = torch.nn.Linear(1, 2, bias=False)
+optimizer = torch.optim.SGD(mod.parameters())
+print(f"weight in mod: {mod.weight}")
+print(f"weight in optimizer: {optimizer.param_groups[0]['params']}")
+mod.weight = torch.nn.Parameter(2 * mod.weight)
+print(f"weight in mod: {mod.weight}")
+print(f"weight in optimizer: {optimizer.param_groups[0]['params']}")
+
+################################################################################
+# ``nn.Module.to()`` and related methods
+# --------------------------------------
+# This includes methods that change the device of the module (such as ``nn.Module.cpu()``),
+# methods that change the ``dtype`` of the module (such as ``nn.Module.float()``)
+# as well as methods that allow the module to be materialized
+# (such as ``nn.Module.to_empty()``).
+#
+# At first glance, it might be non-intuitive that these methods are able to
+# modify the parameters of the module in-place. The existing approach has been
+# to use a nasty hack dating back from the first days of PyTorch.
+#
+# Notably, the existing approach does not work in these cases:
+#
+# * when using ``__torch_dispatch__`` subclasses
+# * when ``param`` and ``new_param`` do not have the same Python ``type()``
+# * For tensors with special C++ representations (such as sparse tensors and ``XLA`` tensors)
+#
+# In the following part of this recipe, we will define a toy ``__torch_dispatch__``
+# subclass ``MyQuantizedLinearWeight`` that represents quantized linear weights.
+# This subclass will be used for illustration purposes throughout the rest of
+# the tutorial. For brevity, we omit most of the ``__torch_dispatch__``
+# implementation.
+aten = torch.ops.aten
+
+class MyQuantizedLinearWeight(torch.Tensor):
+    @staticmethod
+    def __new__(cls, elem, scale):
+        return torch.Tensor._make_wrapper_subclass(
+            cls,
+            elem.shape,
+            dtype=elem.dtype,
+            layout=elem.layout,
+            device=elem.device,
+            strides=elem.stride(),
+            storage_offset=elem.storage_offset())
+
+    def __init__(self, elem: torch.Tensor, scale: float):
+        self.elem = elem
+        self.scale = scale
+
+    def __repr__(self):
+        return f"MyQuantizedLinearWeight({self.elem}, scale={self.scale})"
+
+    @classmethod
+    def __torch_dispatch__(cls, func, types, args, kwargs):
+        if func in (aten.detach.default, aten._to_copy.default):
+            new_elem = func(args[0].elem, *args[1:], **kwargs)
+            return cls(new_elem, args[0].scale)
+        # Implementations for certain ops would be added to ``OP_TABLE``.
+        # We omit this for brevity.
+        OP_TABLE = dict()
+        if func in OP_TABLE:
+          return OP_TABLE[func](func, args, kwargs)
+        raise NotImplementedError(f"Unsupported function {func}")
+
+#################################################################################
+# Let us create an ``nn.Linear`` layer of ``dtype`` ``torch.float32`` where the weight is
+# a ``MyQuantizedLinearWeight`` and try to convert it to ``torch.bfloat16``.
+# Observe that the weight's ``dtype`` changes as expected. However, the ``dtype``
+# of the subclass' payload (``elem``) does not change.
+
+m = nn.Linear(3, 5, dtype=torch.float32)
+m.weight = torch.nn.Parameter(MyQuantizedLinearWeight(m.weight, 0.5))
+print(f"Before: id(m.weight)={id(m.weight)}, id(m.bias)={id(m.bias)}")
+m.bfloat16()
+print(f"After: id(m.weight)={id(m.weight)}, id(m.bias)={id(m.bias)}")
+print(f"m.weight.dtype: {m.weight.dtype}")
+print(f"m.weight.elem.dtype: {m.weight.elem.dtype}")
+print(f"m.bias.dtype: {m.bias.dtype}")
+
+################################################################################
+# To this end, we introduce a global config
+# ``torch.__future__.set_swap_module_params_on_conversion`` that will use
+# ``swap_tensors`` to swap the parameters of the module while preserving
+# references in place of ``.data`` setting. When this config is set,
+# ``swap_tensors`` will be used during the conversion, which ensures that
+# the ``dtype`` of the payload is properly converted.
+
+torch.__future__.set_swap_module_params_on_conversion(True)
+m = nn.Linear(3, 5, dtype=torch.float32)
+m.weight = torch.nn.Parameter(MyQuantizedLinearWeight(m.weight, 0.5))
+print(f"Before: id(m.weight)={id(m.weight)}, id(m.bias)={id(m.bias)}")
+m.bfloat16()
+print(f"After: id(m.weight)={id(m.weight)}, id(m.bias)={id(m.bias)}")
+print(f"m.weight.dtype: {m.weight.dtype}")
+print(f"m.weight.elem.dtype: {m.weight.elem.dtype}")
+print(f"m.bias.dtype: {m.bias.dtype}")
+torch.__future__.set_swap_module_params_on_conversion(False)
+
+################################################################################
+# ``nn.Module.load_state_dict()``
+# --------------------------------
+# Depending on the value of the ``assign`` keyword argument passed
+# to ``load_state_dict()``, there are two ways to load the ``state_dict``:
+#
+# * ``assign=False``: preserves the properties of ``module.param`` and only takes the values
+#   from ``state_dict['param_name']``
+# * ``assign=True``: preserves the properties and values of ``state_dict['param_name']``.
+#
+#
+# Previously, these were implemented with in-place ``copy_`` and ``__setattr__`` respectively.
+# With the existing implementation, each approach had its own limitations -- ``assign=False``
+# imposes the constraint that the type of the parameter in the ``state_dict`` must
+# be the same as the type of the parameter in the module while ``assign=True`` imposes
+# the constraint that anything that holds references to the module's parameters must
+# be initialized after ``nn.Module.load_state_dict()``.
+#
+# Now, we address both constraints by adding a ``swap_tensors`` path to ``load_state_dict()``
+# and introducing a new extension point ``torch.Tensor.module_load(self, other, assign=False)``.
+# When the ``swap_tensors`` path is enabled via the ``__future__`` mentioned above,
+# we can use a ``__torch_function__`` handler for ``module_load`` to apply a
+# custom transformation to the value in the ``state_dict``. The result of this
+# transformation will be swapped with the parameter in the module.
+#
+# In the following example, we will use the ``MyQuantizedLinearWeight`` subclass
+# defined above to illustrate how we can use these features to apply a
+# custom quantization scheme to the weights of a linear layer when
+# loading the ``state_dict``.
+#
+# Recall that the ``__torch_function__`` handler for ``module_load`` will be
+# invoked if either ``self`` or ``other`` (in this case ``param`` or
+# ``state_dict[param_key]``) are ``MyQuantizedLinearWeight`` subclasses.
+#
+# Assume that we expect the ``state_dict`` to contain plain tensors and the
+# module to contain ``MyQuantizedLinearWeight`` parameters where we want the
+# tensors in the ``state_dict`` to be transformed into the subclass. Then we
+# can define a ``__torch_function__`` handler for ``torch.Tensor.module_load``
+# as such:
+
+@classmethod
+def custom_torch_function(cls, func, types, args=(), kwargs=None):
+    kwargs = {} if kwargs is None else kwargs
+
+    if func is torch.Tensor.module_load:
+        dest, src = args[0], args[1]
+        assert type(dest) == cls and type(src) == torch.Tensor
+        return MyQuantizedLinearWeight(src, dest.scale)
+    else:
+        with torch._C.DisableTorchFunctionSubclass():
+                return func(*args, **kwargs)
+
+MyQuantizedLinearWeight.__torch_function__ = custom_torch_function
+
+#################################################################################
+# First, let us create a skeleton of a model on the meta device to avoid
+# materializing storages. We convert all weights in the modules to
+# ``MyQuantizedLinearWeight`` subclasses while leaving biases intact.
+
+def fn(m):
+    if isinstance(m, nn.Linear):
+        requires_grad = m.weight.requires_grad
+        m.weight = torch.nn.Parameter(
+                    MyQuantizedLinearWeight(m.weight, 0.5), requires_grad=requires_grad
+                   )
+
+with torch.device("meta"):
+    m = nn.Linear(3, 5)
+    m.apply(fn)
+
+#################################################################################
+# We can then load the ``state_dict``. Observe that we use ``assign=True`` because
+# for biases, we want to preserve the properties of the tensor in the ``state_dict``
+# (for example, we do not want the bias to be on the ``meta`` device after loading).
+
+torch.__future__.set_swap_module_params_on_conversion(True)
+print(f"Before: id(weight)={id(m.weight)}, id(bias)={id(m.bias)}")
+print(f"m.state_dict() before load_state_dict():\n {m.state_dict()}")
+state_dict = nn.Linear(3, 5).state_dict()
+print(f"state_dict:\n {state_dict}")
+m.load_state_dict(state_dict, assign=True)
+print(f"After: id(weight)={id(m.weight)}, id(bias)={id(m.bias)}")
+print(f"m.state_dict() after load_state_dict():\n {m.state_dict()}")
+
+#################################################################################
+# The above is a toy example of how we can use the new extension point in
+# ``nn.Module.load_state_dict()``. One can also imagine alternate scenarios such
+# as when we have tensor subclasses in the ``state_dict`` and plain ``nn.Parameters``/
+# tensors in the module or when both are tensor subclasses. Based on the use
+# case, we can define the ``__torch_function__`` handler for ``module_load``
+# to apply the transforms as needed.
+#
+# Conclusion
+# ----------
+# In this recipe, we learned about ``swap_tensors``, the importance
+# of preserving references for parameters in ``nn.Module`` as well as how to
+# use the two new extension points that are gated by
+# ``torch.__future__.set_swap_module_params_on_conversion``.
diff --git a/recipes_source/recipes/tensorboard_with_pytorch.py b/recipes_source/recipes/tensorboard_with_pytorch.py
new file mode 100644
index 00000000000..4bceda81eaf
--- /dev/null
+++ b/recipes_source/recipes/tensorboard_with_pytorch.py
@@ -0,0 +1,130 @@
+"""
+How to use TensorBoard with PyTorch
+===================================
+TensorBoard is a visualization toolkit for machine learning experimentation. 
+TensorBoard allows tracking and visualizing metrics such as loss and accuracy, 
+visualizing the model graph, viewing histograms, displaying images and much more. 
+In this tutorial we are going to cover TensorBoard installation, 
+basic usage with PyTorch, and how to visualize data you logged in TensorBoard UI.
+
+Installation
+----------------------
+PyTorch should be installed to log models and metrics into TensorBoard log 
+directory. The following command will install PyTorch 1.4+ via 
+Anaconda (recommended):
+
+.. code-block:: sh
+
+   $ conda install pytorch torchvision -c pytorch 
+   
+
+or pip
+
+.. code-block:: sh
+
+   $ pip install torch torchvision
+
+"""
+
+######################################################################
+# Using TensorBoard in PyTorch
+# -----------------------------
+# 
+# Let’s now try using TensorBoard with PyTorch! Before logging anything, 
+# we need to create a ``SummaryWriter`` instance.
+#   
+
+import torch
+from torch.utils.tensorboard import SummaryWriter
+writer = SummaryWriter()
+
+######################################################################
+# Writer will output to ``./runs/`` directory by default.
+# 
+
+
+######################################################################
+# Log scalars
+# -----------
+# 
+# In machine learning, it’s important to understand key metrics such as 
+# loss and how they change during training. Scalar helps to save 
+# the loss value of each training step, or the accuracy after each epoch. 
+#
+# To log a scalar value, use 
+# ``add_scalar(tag, scalar_value, global_step=None, walltime=None)``. 
+# For example, lets create a simple linear regression training, and 
+# log loss value using ``add_scalar``
+#
+
+x = torch.arange(-5, 5, 0.1).view(-1, 1)
+y = -5 * x + 0.1 * torch.randn(x.size())
+
+model = torch.nn.Linear(1, 1)
+criterion = torch.nn.MSELoss()
+optimizer = torch.optim.SGD(model.parameters(), lr = 0.1)
+
+def train_model(iter):
+    for epoch in range(iter):
+        y1 = model(x)
+        loss = criterion(y1, y)
+        writer.add_scalar("Loss/train", loss, epoch)
+        optimizer.zero_grad()
+        loss.backward()
+        optimizer.step()
+        
+train_model(10)
+writer.flush()
+
+
+###################################################################### 
+# Call ``flush()`` method to make sure that all pending events 
+# have been written to disk.
+# 
+# See `torch.utils.tensorboard tutorials <https://pytorch.org/docs/stable/tensorboard.html>`_ 
+# to find more TensorBoard visualization types you can log.
+# 
+# If you do not need the summary writer anymore, call ``close()`` method.
+#
+
+writer.close()
+
+######################################################################
+# Run TensorBoard
+# ----------------
+# 
+# Install TensorBoard through the command line to visualize data you logged
+#
+# .. code-block:: sh
+#
+#    pip install tensorboard
+#
+#
+# Now, start TensorBoard, specifying the root log directory you used above. 
+# Argument ``logdir`` points to directory where TensorBoard will look to find 
+# event files that it can display. TensorBoard will recursively walk 
+# the directory structure rooted at ``logdir``, looking for ``.*tfevents.*`` files.
+#
+# .. code-block:: sh
+#
+#    tensorboard --logdir=runs
+#
+# Go to the URL it provides OR to `http://localhost:6006/ <http://localhost:6006/>`_
+#
+# .. image:: ../../_static/img/thumbnails/tensorboard_scalars.png
+#    :scale: 40 %
+#
+# This dashboard shows how the loss and accuracy change with every epoch. 
+# You can use it to also track training speed, learning rate, and other 
+# scalar values. It’s helpful to compare these metrics across different 
+# training runs to improve your model.
+#
+
+
+########################################################################
+# Learn More
+# ----------------------------
+# 
+# -  `torch.utils.tensorboard <https://pytorch.org/docs/stable/tensorboard.html>`_ docs
+# -  `Visualizing models, data, and training with TensorBoard <https://pytorch.org/tutorials/intermediate/tensorboard_tutorial.html>`_ tutorial
+#
diff --git a/recipes_source/recipes/timer_quick_start.py b/recipes_source/recipes/timer_quick_start.py
new file mode 100644
index 00000000000..d6b79e094c7
--- /dev/null
+++ b/recipes_source/recipes/timer_quick_start.py
@@ -0,0 +1,397 @@
+"""
+Timer quick start
+=================
+
+In this tutorial, we're going to cover the primary APIs of
+`torch.utils.benchmark.Timer`. The PyTorch Timer is based on the
+`timeit.Timer <https://docs.python.org/3/library/timeit.html#timeit.Timer>`__
+API, with several PyTorch specific modifications. Familiarity with the
+builtin `Timer` class is not required for this tutorial, however we assume
+that the reader is familiar with the fundamentals of performance work.
+
+For a more comprehensive performance tuning tutorial, see
+`PyTorch Benchmark <https://pytorch.org/tutorials/recipes/recipes/benchmark.html>`__.
+
+
+**Contents:**
+    1. `Defining a Timer <#defining-a-timer>`__
+    2. `Wall time: Timer.blocked_autorange(...) <#wall-time-timer-blocked-autorange>`__
+    3. `C++ snippets <#c-snippets>`__
+    4. `Instruction counts: Timer.collect_callgrind(...) <#instruction-counts-timer-collect-callgrind>`__
+    5. `Instruction counts: Delving deeper <#instruction-counts-delving-deeper>`__
+    6. `A/B testing with Callgrind <#a-b-testing-with-callgrind>`__
+    7. `Wrapping up <#wrapping-up>`__
+    8. `Footnotes <#footnotes>`__
+"""
+
+
+###############################################################################
+# 1. Defining a Timer
+# ~~~~~~~~~~~~~~~~~~~
+#
+# A `Timer` serves as a task definition.
+#
+
+from torch.utils.benchmark import Timer
+
+timer = Timer(
+    # The computation which will be run in a loop and timed.
+    stmt="x * y",
+
+    # `setup` will be run before calling the measurement loop, and is used to
+    # populate any state which is needed by `stmt`
+    setup="""
+        x = torch.ones((128,))
+        y = torch.ones((128,))
+    """,
+
+    # Alternatively, ``globals`` can be used to pass variables from the outer scope.
+    # 
+    #    globals={
+    #        "x": torch.ones((128,)),
+    #        "y": torch.ones((128,)),
+    #    },
+
+    # Control the number of threads that PyTorch uses. (Default: 1)
+    num_threads=1,
+)
+
+###############################################################################
+# 2. Wall time: ``Timer.blocked_autorange(...)``
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# This method will handle details such as picking a suitable number if repeats,
+# fixing the number of threads, and providing a convenient representation of
+# the results.
+#
+
+# Measurement objects store the results of multiple repeats, and provide
+# various utility features.
+from torch.utils.benchmark import Measurement
+
+m: Measurement = timer.blocked_autorange(min_run_time=1)
+print(m)
+
+###############################################################################
+# .. code-block:: none
+#    :caption: **Snippet wall time.**
+#
+#         <torch.utils.benchmark.utils.common.Measurement object at 0x7f1929a38ed0>
+#         x * y
+#         setup:
+#           x = torch.ones((128,))
+#           y = torch.ones((128,))
+#
+#           Median: 2.34 us
+#           IQR:    0.07 us (2.31 to 2.38)
+#           424 measurements, 1000 runs per measurement, 1 thread
+#
+
+###############################################################################
+# 3. C++ snippets
+# ~~~~~~~~~~~~~~~
+#
+
+from torch.utils.benchmark import Language
+
+cpp_timer = Timer(
+    "x * y;",
+    """
+        auto x = torch::ones({128});
+        auto y = torch::ones({128});
+    """,
+    language=Language.CPP,
+)
+
+print(cpp_timer.blocked_autorange(min_run_time=1))
+
+###############################################################################
+# .. code-block:: none
+#    :caption: **C++ snippet wall time.**
+#
+#         <torch.utils.benchmark.utils.common.Measurement object at 0x7f192b019ed0>
+#         x * y;
+#         setup:
+#           auto x = torch::ones({128});
+#           auto y = torch::ones({128});
+#
+#           Median: 1.21 us
+#           IQR:    0.03 us (1.20 to 1.23)
+#           83 measurements, 10000 runs per measurement, 1 thread
+#
+
+###############################################################################
+# Unsurprisingly, the C++ snippet is both faster and has lower variation.
+#
+
+###############################################################################
+# 4. Instruction counts: ``Timer.collect_callgrind(...)``
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# For deep dive investigations, ``Timer.collect_callgrind`` wraps
+# `Callgrind <https://valgrind.org/docs/manual/cl-manual.html>`__ in order to
+# collect instruction counts. These are useful as they offer fine grained and
+# deterministic (or very low noise in the case of Python) insights into how a
+# snippet is run.
+#
+
+from torch.utils.benchmark import CallgrindStats, FunctionCounts
+
+stats: CallgrindStats = cpp_timer.collect_callgrind()
+print(stats)
+
+###############################################################################
+# .. code-block:: none
+#    :caption: **C++ Callgrind stats (summary)**
+#
+#         <torch.utils.benchmark.utils.valgrind_wrapper.timer_interface.CallgrindStats object at 0x7f1929a35850>
+#         x * y;
+#         setup:
+#           auto x = torch::ones({128});
+#           auto y = torch::ones({128});
+#
+#                                 All          Noisy symbols removed
+#             Instructions:       563600                     563600
+#             Baseline:                0                          0
+#         100 runs per measurement, 1 thread
+#
+
+###############################################################################
+# 5. Instruction counts: Delving deeper
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# The string representation of ``CallgrindStats`` is similar to that of
+# Measurement. `Noisy symbols` are a Python concept (removing calls in the
+# CPython interpreter which are known to be noisy).
+#
+# For more detailed analysis, however, we will want to look at specific calls.
+# ``CallgrindStats.stats()`` returns a ``FunctionCounts`` object to make this easier.
+# Conceptually, ``FunctionCounts`` can be thought of as a tuple of pairs with some
+# utility methods, where each pair is `(number of instructions, file path and
+# function name)`.
+#
+# A note on paths:
+#   One generally doesn't care about absolute path. For instance, the full path
+#   and function name for a multiply call is something like:
+#
+# .. code-block:: sh
+#
+#    /the/prefix/to/your/pytorch/install/dir/pytorch/build/aten/src/ATen/core/TensorMethods.cpp:at::Tensor::mul(at::Tensor const&) const [/the/path/to/your/conda/install/miniconda3/envs/ab_ref/lib/python3.7/site-packages/torch/lib/libtorch_cpu.so]
+#
+#   when in reality, all of the information that we're interested in can be
+#   represented in:
+#
+# .. code-block:: sh
+#
+#    build/aten/src/ATen/core/TensorMethods.cpp:at::Tensor::mul(at::Tensor const&) const
+#
+#   ``CallgrindStats.as_standardized()`` makes a best effort to strip low signal
+#   portions of the file path, as well as the shared object and is generally
+#   recommended.
+#
+
+inclusive_stats = stats.as_standardized().stats(inclusive=False)
+print(inclusive_stats[:10])
+
+###############################################################################
+# .. code-block:: none
+#    :caption: **C++ Callgrind stats (detailed)**
+#
+#         torch.utils.benchmark.utils.valgrind_wrapper.timer_interface.FunctionCounts object at 0x7f192a6dfd90>
+#           47264  ???:_int_free
+#           25963  ???:_int_malloc
+#           19900  build/../aten/src/ATen/TensorIter ... (at::TensorIteratorConfig const&)
+#           18000  ???:__tls_get_addr
+#           13500  ???:malloc
+#           11300  build/../c10/util/SmallVector.h:a ... (at::TensorIteratorConfig const&)
+#           10345  ???:_int_memalign
+#           10000  build/../aten/src/ATen/TensorIter ... (at::TensorIteratorConfig const&)
+#            9200  ???:free
+#            8000  build/../c10/util/SmallVector.h:a ... IteratorBase::get_strides() const
+#
+#         Total: 173472
+#
+
+###############################################################################
+# That's still quite a lot to digest. Let's use the `FunctionCounts.transform`
+# method to trim some of the function path, and discard the function called.
+# When we do, the counts of any collisions (e.g. `foo.h:a()` and `foo.h:b()`
+# will both map to `foo.h`) will be added together.
+#
+
+import os
+import re
+
+def group_by_file(fn_name: str):
+    if fn_name.startswith("???"):
+        fn_dir, fn_file = fn_name.split(":")[:2]
+    else:
+        fn_dir, fn_file = os.path.split(fn_name.split(":")[0])
+        fn_dir = re.sub("^.*build/../", "", fn_dir)
+        fn_dir = re.sub("^.*torch/", "torch/", fn_dir)
+
+    return f"{fn_dir:<15} {fn_file}"
+
+print(inclusive_stats.transform(group_by_file)[:10])
+
+###############################################################################
+# .. code-block:: none
+#    :caption: **Callgrind stats (condensed)**
+#
+#         <torch.utils.benchmark.utils.valgrind_wrapper.timer_interface.FunctionCounts object at 0x7f192995d750>
+#           118200  aten/src/ATen   TensorIterator.cpp
+#            65000  c10/util        SmallVector.h
+#            47264  ???             _int_free
+#            25963  ???             _int_malloc
+#            20900  c10/util        intrusive_ptr.h
+#            18000  ???             __tls_get_addr
+#            15900  c10/core        TensorImpl.h
+#            15100  c10/core        CPUAllocator.cpp
+#            13500  ???             malloc
+#            12500  c10/core        TensorImpl.cpp
+#
+#         Total: 352327
+#
+
+###############################################################################
+# 6. A/B testing with ``Callgrind``
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# One of the most useful features of instruction counts is they allow fine
+# grained comparison of computation, which is critical when analyzing
+# performance.
+#
+# To see this in action, lets compare our multiplication of two size 128
+# Tensors with a {128} x {1} multiplication, which will broadcast the second
+# Tensor:
+#   result = {a0 * b0, a1 * b0, ..., a127 * b0}
+#
+
+broadcasting_stats = Timer(
+    "x * y;",
+    """
+        auto x = torch::ones({128});
+        auto y = torch::ones({1});
+    """,
+    language=Language.CPP,
+).collect_callgrind().as_standardized().stats(inclusive=False)
+
+###############################################################################
+# Often we want to A/B test two different environments. (e.g. testing a PR, or
+# experimenting with compile flags.) This is quite simple, as ``CallgrindStats``,
+# ``FunctionCounts``, and Measurement are all pickleable. Simply save measurements
+# from each environment, and load them in a single process for analysis.
+#
+
+import pickle
+
+# Let's round trip `broadcasting_stats` just to show that we can.
+broadcasting_stats = pickle.loads(pickle.dumps(broadcasting_stats))
+
+
+# And now to diff the two tasks:
+delta = broadcasting_stats - inclusive_stats
+
+def extract_fn_name(fn: str):
+    """Trim everything except the function name."""
+    fn = ":".join(fn.split(":")[1:])
+    return re.sub(r"\(.+\)", "(...)", fn)
+
+# We use `.transform` to make the diff readable:
+print(delta.transform(extract_fn_name))
+
+
+###############################################################################
+# .. code-block:: none
+#    :caption: **Instruction count delta**
+#
+#         <torch.utils.benchmark.utils.valgrind_wrapper.timer_interface.FunctionCounts object at 0x7f192995d750>
+#             17600  at::TensorIteratorBase::compute_strides(...)
+#             12700  at::TensorIteratorBase::allocate_or_resize_outputs()
+#             10200  c10::SmallVectorImpl<long>::operator=(...)
+#              7400  at::infer_size(...)
+#              6200  at::TensorIteratorBase::invert_perm(...) const
+#              6064  _int_free
+#              5100  at::TensorIteratorBase::reorder_dimensions()
+#              4300  malloc
+#              4300  at::TensorIteratorBase::compatible_stride(...) const
+#               ...
+#               -28  _int_memalign
+#              -100  c10::impl::check_tensor_options_and_extract_memory_format(...)
+#              -300  __memcmp_avx2_movbe
+#              -400  at::detail::empty_cpu(...)
+#             -1100  at::TensorIteratorBase::numel() const
+#             -1300  void at::native::(...)
+#             -2400  c10::TensorImpl::is_contiguous(...) const
+#             -6100  at::TensorIteratorBase::compute_fast_setup_type(...)
+#            -22600  at::TensorIteratorBase::fast_set_up(...)
+#
+#         Total: 58091
+#
+
+###############################################################################
+# So the broadcasting version takes an extra 580 instructions per call (recall
+# that we're collecting 100 runs per sample), or about 10%. There are quite a
+# few ``TensorIterator`` calls, so lets drill down to those. ``FunctionCounts.filter``
+# makes this easy.
+#
+
+print(delta.transform(extract_fn_name).filter(lambda fn: "TensorIterator" in fn))
+
+###############################################################################
+# .. code-block:: none
+#    :caption: **Instruction count delta (filter)**
+#
+#         <torch.utils.benchmark.utils.valgrind_wrapper.timer_interface.FunctionCounts object at 0x7f19299544d0>
+#             17600  at::TensorIteratorBase::compute_strides(...)
+#             12700  at::TensorIteratorBase::allocate_or_resize_outputs()
+#              6200  at::TensorIteratorBase::invert_perm(...) const
+#              5100  at::TensorIteratorBase::reorder_dimensions()
+#              4300  at::TensorIteratorBase::compatible_stride(...) const
+#              4000  at::TensorIteratorBase::compute_shape(...)
+#              2300  at::TensorIteratorBase::coalesce_dimensions()
+#              1600  at::TensorIteratorBase::build(...)
+#             -1100  at::TensorIteratorBase::numel() const
+#             -6100  at::TensorIteratorBase::compute_fast_setup_type(...)
+#            -22600  at::TensorIteratorBase::fast_set_up(...)
+#
+#         Total: 24000
+#
+
+###############################################################################
+# This makes plain what is going on: there is a fast path in ``TensorIterator``
+# setup, but in the {128} x {1} case we miss it and have to do a more general
+# analysis which is more expensive. The most prominent call omitted by the
+# filter is `c10::SmallVectorImpl<long>::operator=(...)`, which is also part
+# of the more general setup.
+#
+
+###############################################################################
+# 7. Wrapping up
+# ~~~~~~~~~~~~~~
+#
+# In summary, use `Timer.blocked_autorange` to collect wall times. If timing
+# variation is too high, increase `min_run_time`, or move to C++ snippets if
+# convenient.
+#
+# For fine grained analysis, use `Timer.collect_callgrind` to measure
+# instruction counts and `FunctionCounts.(__add__ / __sub__ / transform / filter)`
+# to slice-and-dice them.
+#
+
+###############################################################################
+# 8. Footnotes
+# ~~~~~~~~~~~~
+#
+#   - Implied ``import torch``
+#       If `globals` does not contain "torch", Timer will automatically
+#       populate it. This means that ``Timer("torch.empty(())")`` will work.
+#       (Though other imports should be placed in `setup`,
+#       e.g. ``Timer("np.zeros(())", "import numpy as np")``)
+#
+#   - ``REL_WITH_DEB_INFO``
+#       In order to provide full information about the PyTorch internals which
+#       are executed, ``Callgrind`` needs access to C++ debug symbols. This is
+#       accomplished by setting ``REL_WITH_DEB_INFO=1`` when building PyTorch.
+#       Otherwise function calls will be opaque. (The resultant ``CallgrindStats``
+#       will warn if debug symbols are missing.)
diff --git a/recipes_source/recipes/tuning_guide.py b/recipes_source/recipes/tuning_guide.py
new file mode 100644
index 00000000000..dd13b47a6dd
--- /dev/null
+++ b/recipes_source/recipes/tuning_guide.py
@@ -0,0 +1,534 @@
+"""
+Performance Tuning Guide
+*************************
+**Author**: `Szymon Migacz <https://github.com/szmigacz>`_
+
+Performance Tuning Guide is a set of optimizations and best practices which can
+accelerate training and inference of deep learning models in PyTorch. Presented
+techniques often can be implemented by changing only a few lines of code and can
+be applied to a wide range of deep learning models across all domains.
+
+.. grid:: 2
+
+    .. grid-item-card:: :octicon:`mortar-board;1em;` What you will learn
+       :class-card: card-prerequisites
+
+       * General optimization techniques for PyTorch models
+       * CPU-specific performance optimizations
+       * GPU acceleration strategies
+       * Distributed training optimizations
+
+    .. grid-item-card:: :octicon:`list-unordered;1em;` Prerequisites
+       :class-card: card-prerequisites
+
+       * PyTorch 2.0 or later
+       * Python 3.8 or later
+       * CUDA-capable GPU (recommended for GPU optimizations)
+       * Linux, macOS, or Windows operating system
+
+Overview
+--------
+
+Performance optimization is crucial for efficient deep learning model training and inference.
+This tutorial covers a comprehensive set of techniques to accelerate PyTorch workloads across
+different hardware configurations and use cases.
+
+General optimizations
+---------------------
+"""
+
+import torch
+import torchvision
+
+###############################################################################
+# Enable asynchronous data loading and augmentation
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# `torch.utils.data.DataLoader <https://pytorch.org/docs/stable/data.html#torch.utils.data.DataLoader>`_
+# supports asynchronous data loading and data augmentation in separate worker
+# subprocesses. The default setting for ``DataLoader`` is ``num_workers=0``,
+# which means that the data loading is synchronous and done in the main process.
+# As a result the main training process has to wait for the data to be available
+# to continue the execution.
+#
+# Setting ``num_workers > 0`` enables asynchronous data loading and overlap
+# between the training and data loading. ``num_workers`` should be tuned
+# depending on the workload, CPU, GPU, and location of training data.
+#
+# ``DataLoader`` accepts ``pin_memory`` argument, which defaults to ``False``.
+# When using a GPU it's better to set ``pin_memory=True``, this instructs
+# ``DataLoader`` to use pinned memory and enables faster and asynchronous memory
+# copy from the host to the GPU.
+
+###############################################################################
+# Disable gradient calculation for validation or inference
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# PyTorch saves intermediate buffers from all operations which involve tensors
+# that require gradients. Typically gradients aren't needed for validation or
+# inference.
+# `torch.no_grad() <https://pytorch.org/docs/stable/generated/torch.no_grad.html#torch.no_grad>`_
+# context manager can be applied to disable gradient calculation within a
+# specified block of code, this accelerates execution and reduces the amount of
+# required memory.
+# `torch.no_grad() <https://pytorch.org/docs/stable/generated/torch.no_grad.html#torch.no_grad>`_
+# can also be used as a function decorator.
+
+###############################################################################
+# Disable bias for convolutions directly followed by a batch norm
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# `torch.nn.Conv2d() <https://pytorch.org/docs/stable/generated/torch.nn.Conv2d.html#torch.nn.Conv2d>`_
+# has ``bias`` parameter which defaults to ``True`` (the same is true for
+# `Conv1d <https://pytorch.org/docs/stable/generated/torch.nn.Conv1d.html#torch.nn.Conv1d>`_
+# and
+# `Conv3d <https://pytorch.org/docs/stable/generated/torch.nn.Conv3d.html#torch.nn.Conv3d>`_
+# ).
+#
+# If a ``nn.Conv2d`` layer is directly followed by a ``nn.BatchNorm2d`` layer,
+# then the bias in the convolution is not needed, instead use
+# ``nn.Conv2d(..., bias=False, ....)``. Bias is not needed because in the first
+# step ``BatchNorm`` subtracts the mean, which effectively cancels out the
+# effect of bias.
+#
+# This is also applicable to 1d and 3d convolutions as long as ``BatchNorm`` (or
+# other normalization layer) normalizes on the same dimension as convolution's
+# bias.
+#
+# Models available from `torchvision <https://github.com/pytorch/vision>`_
+# already implement this optimization.
+
+###############################################################################
+# Use parameter.grad = None instead of model.zero_grad() or optimizer.zero_grad()
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# Instead of calling:
+model.zero_grad()
+# or
+optimizer.zero_grad()
+
+###############################################################################
+# to zero out gradients, use the following method instead:
+
+for param in model.parameters():
+    param.grad = None
+
+###############################################################################
+# The second code snippet does not zero the memory of each individual parameter,
+# also the subsequent backward pass uses assignment instead of addition to store
+# gradients, this reduces the number of memory operations.
+#
+# Setting gradient to ``None`` has a slightly different numerical behavior than
+# setting it to zero, for more details refer to the
+# `documentation <https://pytorch.org/docs/master/optim.html#torch.optim.Optimizer.zero_grad>`_.
+#
+# Alternatively, call ``model`` or
+# ``optimizer.zero_grad(set_to_none=True)``.
+
+###############################################################################
+# Fuse operations
+# ~~~~~~~~~~~~~~~~~~~~~~~~~
+# Pointwise operations such as elementwise addition, multiplication, and math
+# functions like `sin()`, `cos()`, `sigmoid()`, etc., can be combined into a
+# single kernel. This fusion helps reduce memory access and kernel launch times.
+# Typically, pointwise operations are memory-bound; PyTorch eager-mode initiates
+# a separate kernel for each operation, which involves loading data from memory,
+# executing the operation (often not the most time-consuming step), and writing
+# the results back to memory.
+# 
+# By using a fused operator, only one kernel is launched for multiple pointwise
+# operations, and data is loaded and stored just once. This efficiency is
+# particularly beneficial for activation functions, optimizers, and custom RNN cells etc.
+#
+# PyTorch 2 introduces a compile-mode facilitated by TorchInductor, an underlying compiler
+# that automatically fuses kernels. TorchInductor extends its capabilities beyond simple
+# element-wise operations, enabling advanced fusion of eligible pointwise and reduction
+# operations for optimized performance.
+#
+# In the simplest case fusion can be enabled by applying
+# `torch.compile <https://pytorch.org/docs/stable/generated/torch.compile.html>`_
+# decorator to the function definition, for example:
+
+@torch.compile
+def gelu(x):
+    return x * 0.5 * (1.0 + torch.erf(x / 1.41421))
+
+###############################################################################
+# Refer to
+# `Introduction to torch.compile <https://pytorch.org/tutorials/intermediate/torch_compile_tutorial.html>`_
+# for more advanced use cases.
+
+###############################################################################
+# Enable channels_last memory format for computer vision models
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# PyTorch supports ``channels_last`` memory format for
+# convolutional networks. This format is meant to be used in conjunction with
+# `AMP <https://pytorch.org/docs/stable/amp.html>`_ to further accelerate
+# convolutional neural networks with
+# `Tensor Cores <https://www.nvidia.com/en-us/data-center/tensor-cores/>`_.
+#
+# Support for ``channels_last`` is experimental, but it's expected to work for
+# standard computer vision models (e.g. ResNet-50, SSD). To convert models to
+# ``channels_last`` format follow
+# `Channels Last Memory Format Tutorial <https://pytorch.org/tutorials/intermediate/memory_format_tutorial.html>`_.
+# The tutorial includes a section on
+# `converting existing models <https://pytorch.org/tutorials/intermediate/memory_format_tutorial.html#converting-existing-models>`_.
+
+###############################################################################
+# Checkpoint intermediate buffers
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# Buffer checkpointing is a technique to mitigate the memory capacity burden of
+# model training. Instead of storing inputs of all layers to compute upstream
+# gradients in backward propagation, it stores the inputs of a few layers and
+# the others are recomputed during backward pass. The reduced memory
+# requirements enables increasing the batch size that can improve utilization.
+#
+# Checkpointing targets should be selected carefully. The best is not to store
+# large layer outputs that have small re-computation cost. The example target
+# layers are activation functions (e.g. ``ReLU``, ``Sigmoid``, ``Tanh``),
+# up/down sampling and matrix-vector operations with small accumulation depth.
+#
+# PyTorch supports a native
+# `torch.utils.checkpoint <https://pytorch.org/docs/stable/checkpoint.html>`_
+# API to automatically perform checkpointing and recomputation.
+
+###############################################################################
+# Disable debugging APIs
+# ~~~~~~~~~~~~~~~~~~~~~~
+# Many PyTorch APIs are intended for debugging and should be disabled for
+# regular training runs:
+#
+# * anomaly detection:
+#   `torch.autograd.detect_anomaly <https://pytorch.org/docs/stable/autograd.html#torch.autograd.detect_anomaly>`_
+#   or
+#   `torch.autograd.set_detect_anomaly(True) <https://pytorch.org/docs/stable/autograd.html#torch.autograd.set_detect_anomaly>`_
+# * profiler related:
+#   `torch.autograd.profiler.emit_nvtx <https://pytorch.org/docs/stable/autograd.html#torch.autograd.profiler.emit_nvtx>`_,
+#   `torch.autograd.profiler.profile <https://pytorch.org/docs/stable/autograd.html#torch.autograd.profiler.profile>`_
+# * autograd ``gradcheck``:
+#   `torch.autograd.gradcheck <https://pytorch.org/docs/stable/autograd.html#torch.autograd.gradcheck>`_
+#   or
+#   `torch.autograd.gradgradcheck <https://pytorch.org/docs/stable/autograd.html#torch.autograd.gradgradcheck>`_
+#
+
+###############################################################################
+# CPU specific optimizations
+# --------------------------
+
+###############################################################################
+# Utilize Non-Uniform Memory Access (NUMA) Controls
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# NUMA or non-uniform memory access is a memory layout design used in data center machines meant to take advantage of locality of memory in multi-socket machines with multiple memory controllers and blocks. Generally speaking, all deep learning workloads, training or inference, get better performance without accessing hardware resources across NUMA nodes. Thus, inference can be run with multiple instances, each instance runs on one socket, to raise throughput. For training tasks on single node, distributed training is recommended to make each training process run on one socket.
+#
+# In general cases the following command executes a PyTorch script on cores on the Nth node only, and avoids cross-socket memory access to reduce memory access overhead.
+#
+# .. code-block:: sh
+#
+#    numactl --cpunodebind=N --membind=N python <pytorch_script>
+
+###############################################################################
+# More detailed descriptions can be found `here <https://intel.github.io/intel-extension-for-pytorch/cpu/latest/tutorials/performance_tuning/tuning_guide.html>`_.
+
+###############################################################################
+# Utilize OpenMP
+# ~~~~~~~~~~~~~~
+# OpenMP is utilized to bring better performance for parallel computation tasks.
+# ``OMP_NUM_THREADS`` is the easiest switch that can be used to accelerate computations. It determines number of threads used for OpenMP computations.
+# CPU affinity setting controls how workloads are distributed over multiple cores. It affects communication overhead, cache line invalidation overhead, or page thrashing, thus proper setting of CPU affinity brings performance benefits. ``GOMP_CPU_AFFINITY`` or ``KMP_AFFINITY`` determines how to bind OpenMP* threads to physical processing units. Detailed information can be found `here <https://intel.github.io/intel-extension-for-pytorch/cpu/latest/tutorials/performance_tuning/tuning_guide.html>`_.
+
+###############################################################################
+# With the following command, PyTorch run the task on N OpenMP threads.
+#
+# .. code-block:: sh
+#
+#    export OMP_NUM_THREADS=N
+
+###############################################################################
+# Typically, the following environment variables are used to set for CPU affinity with GNU OpenMP implementation. ``OMP_PROC_BIND`` specifies whether threads may be moved between processors. Setting it to CLOSE keeps OpenMP threads close to the primary thread in contiguous place partitions. ``OMP_SCHEDULE`` determines how OpenMP threads are scheduled. ``GOMP_CPU_AFFINITY`` binds threads to specific CPUs.
+# An important tuning parameter is core pinning which prevent the threads of migrating between multiple CPUs, enhancing data location and minimizing inter core communication.
+#
+# .. code-block:: sh
+#
+#    export OMP_SCHEDULE=STATIC
+#    export OMP_PROC_BIND=CLOSE
+#    export GOMP_CPU_AFFINITY="N-M"
+
+###############################################################################
+# Intel OpenMP Runtime Library (``libiomp``)
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# By default, PyTorch uses GNU OpenMP (GNU ``libgomp``) for parallel computation. On Intel platforms, Intel OpenMP Runtime Library (``libiomp``) provides OpenMP API specification support. It sometimes brings more performance benefits compared to ``libgomp``. Utilizing environment variable ``LD_PRELOAD`` can switch OpenMP library to ``libiomp``:
+#
+# .. code-block:: sh
+#
+#    export LD_PRELOAD=<path>/libiomp5.so:$LD_PRELOAD
+
+###############################################################################
+# Similar to CPU affinity settings in GNU OpenMP, environment variables are provided in ``libiomp`` to control CPU affinity settings.
+# ``KMP_AFFINITY`` binds OpenMP threads to physical processing units. ``KMP_BLOCKTIME`` sets the time, in milliseconds, that a thread should wait, after completing the execution of a parallel region, before sleeping. In most cases, setting ``KMP_BLOCKTIME`` to 1 or 0 yields good performances.
+# The following commands show a common settings with Intel OpenMP Runtime Library.
+#
+# .. code-block:: sh
+#
+#    export KMP_AFFINITY=granularity=fine,compact,1,0
+#    export KMP_BLOCKTIME=1
+
+###############################################################################
+# Switch Memory allocator
+# ~~~~~~~~~~~~~~~~~~~~~~~
+# For deep learning workloads, ``Jemalloc`` or ``TCMalloc`` can get better performance by reusing memory as much as possible than default ``malloc`` function. `Jemalloc <https://github.com/jemalloc/jemalloc>`_ is a general purpose ``malloc`` implementation that emphasizes fragmentation avoidance and scalable concurrency support. `TCMalloc <https://google.github.io/tcmalloc/overview.html>`_ also features a couple of optimizations to speed up program executions. One of them is holding memory in caches to speed up access of commonly-used objects. Holding such caches even after deallocation also helps avoid costly system calls if such memory is later re-allocated.
+# Use environment variable ``LD_PRELOAD`` to take advantage of one of them.
+#
+# .. code-block:: sh
+#
+#    export LD_PRELOAD=<jemalloc.so/tcmalloc.so>:$LD_PRELOAD
+
+
+###############################################################################
+# Train a model on CPU with PyTorch ``DistributedDataParallel``(DDP) functionality
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# For small scale models or memory-bound models, such as DLRM, training on CPU is also a good choice. On a machine with multiple sockets, distributed training brings a high-efficient hardware resource usage to accelerate the training process. `Torch-ccl <https://github.com/intel/torch-ccl>`_, optimized with Intel(R) ``oneCCL`` (collective communications library) for efficient distributed deep learning training implementing such collectives like ``allreduce``, ``allgather``, ``alltoall``, implements PyTorch C10D ``ProcessGroup`` API and can be dynamically loaded as external ``ProcessGroup``. Upon optimizations implemented in PyTorch DDP module, ``torch-ccl`` accelerates communication operations. Beside the optimizations made to communication kernels, ``torch-ccl`` also features simultaneous computation-communication functionality.
+
+###############################################################################
+# GPU specific optimizations
+# --------------------------
+
+###############################################################################
+# Enable Tensor cores
+# ~~~~~~~~~~~~~~~~~~~~~~~
+# Tensor cores are specialized hardware designed to compute matrix-matrix multiplication
+# operations, primarily utilized in deep learning and AI workloads. Tensor cores have
+# specific precision requirements which can be adjusted manually or via the Automatic
+# Mixed Precision API.
+#
+# In particular, tensor operations take advantage of lower precision workloads.
+# Which can be controlled via ``torch.set_float32_matmul_precision``.
+# The default format is set to 'highest,' which utilizes the tensor data type. 
+# However, PyTorch offers alternative precision settings: 'high' and 'medium.'
+# These options prioritize computational speed over numerical precision."
+
+###############################################################################
+# Use CUDA Graphs
+# ~~~~~~~~~~~~~~~~~~~~~~~
+# At the time of using a GPU, work first must be launched from the CPU and
+# in some cases the context switch between CPU and GPU can lead to bad resource
+# utilization. CUDA graphs are a way to keep computation within the GPU without
+# paying the extra cost of kernel launches and host synchronization.
+
+# It can be enabled using 
+torch.compile(m, "reduce-overhead")
+# or
+torch.compile(m, "max-autotune")
+
+###############################################################################
+# Support for CUDA graph is in development, and its usage can incur in increased
+# device memory consumption and some models might not compile.
+
+###############################################################################
+# Enable cuDNN auto-tuner
+# ~~~~~~~~~~~~~~~~~~~~~~~
+# `NVIDIA cuDNN <https://developer.nvidia.com/cudnn>`_ supports many algorithms
+# to compute a convolution. Autotuner runs a short benchmark and selects the
+# kernel with the best performance on a given hardware for a given input size.
+#
+# For convolutional networks (other types currently not supported), enable cuDNN
+# autotuner before launching the training loop by setting:
+
+torch.backends.cudnn.benchmark = True
+###############################################################################
+#
+# * the auto-tuner decisions may be non-deterministic; different algorithm may
+#   be selected for different runs.  For more details see
+#   `PyTorch: Reproducibility <https://pytorch.org/docs/stable/notes/randomness.html?highlight=determinism>`_
+# * in some rare cases, such as with highly variable input sizes,  it's better
+#   to run convolutional networks with autotuner disabled to avoid the overhead
+#   associated with algorithm selection for each input size.
+#
+
+###############################################################################
+# Avoid unnecessary CPU-GPU synchronization
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# Avoid unnecessary synchronizations, to let the CPU run ahead of the
+# accelerator as much as possible to make sure that the accelerator work queue
+# contains many operations.
+#
+# When possible, avoid operations which require synchronizations, for example:
+#
+# * ``print(cuda_tensor)``
+# * ``cuda_tensor.item()``
+# * memory copies: ``tensor.cuda()``,  ``cuda_tensor.cpu()`` and equivalent
+#   ``tensor.to(device)`` calls
+# * ``cuda_tensor.nonzero()``
+# * python control flow which depends on results of operations performed on CUDA
+#   tensors e.g. ``if (cuda_tensor != 0).all()``
+#
+
+###############################################################################
+# Create tensors directly on the target device
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# Instead of calling ``torch.rand(size).cuda()`` to generate a random tensor,
+# produce the output directly on the target device:
+# ``torch.rand(size, device='cuda')``.
+#
+# This is applicable to all functions which create new tensors and accept
+# ``device`` argument:
+# `torch.rand() <https://pytorch.org/docs/stable/generated/torch.rand.html#torch.rand>`_,
+# `torch.zeros() <https://pytorch.org/docs/stable/generated/torch.zeros.html#torch.zeros>`_,
+# `torch.full() <https://pytorch.org/docs/stable/generated/torch.full.html#torch.full>`_
+# and similar.
+
+###############################################################################
+# Use mixed precision and AMP
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# Mixed precision leverages
+# `Tensor Cores <https://www.nvidia.com/en-us/data-center/tensor-cores/>`_
+# and offers up to 3x overall speedup on Volta and newer GPU architectures. To
+# use Tensor Cores AMP should be enabled and matrix/tensor dimensions should
+# satisfy requirements for calling kernels that use Tensor Cores.
+#
+# To use Tensor Cores:
+#
+# * set sizes to multiples of 8 (to map onto dimensions of Tensor Cores)
+#
+#   * see
+#     `Deep Learning Performance Documentation
+#     <https://docs.nvidia.com/deeplearning/performance/index.html#optimizing-performance>`_
+#     for more details and guidelines specific to layer type
+#   * if layer size is derived from other parameters rather than fixed, it can
+#     still be explicitly padded e.g. vocabulary size in NLP models
+#
+# * enable AMP
+#
+#   * Introduction to Mixed Precision Training and AMP:
+#     `slides <https://nvlabs.github.io/eccv2020-mixed-precision-tutorial/files/dusan_stosic-training-neural-networks-with-tensor-cores.pdf>`_
+#   * native PyTorch AMP is available:
+#     `documentation <https://pytorch.org/docs/stable/amp.html>`_,
+#     `examples <https://pytorch.org/docs/stable/notes/amp_examples.html#amp-examples>`_,
+#     `tutorial <https://pytorch.org/tutorials/recipes/recipes/amp_recipe.html>`_
+#
+#
+
+###############################################################################
+# Preallocate memory in case of variable input length
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# Models for speech recognition or for NLP are often trained on input tensors
+# with variable sequence length. Variable length can be problematic for PyTorch
+# caching allocator and can lead to reduced performance or to unexpected
+# out-of-memory errors. If a batch with a short sequence length is followed by
+# an another batch with longer sequence length, then PyTorch is forced to
+# release intermediate buffers from previous iteration and to re-allocate new
+# buffers. This process is time consuming and causes fragmentation in the
+# caching allocator which may result in out-of-memory errors.
+#
+# A typical solution is to implement preallocation. It consists of the
+# following steps:
+#
+# #. generate a (usually random) batch of inputs with maximum sequence length
+#    (either corresponding to max length in the training dataset or to some
+#    predefined threshold)
+# #. execute a forward and a backward pass with the generated batch, do not
+#    execute an optimizer or a learning rate scheduler, this step preallocates
+#    buffers of maximum size, which can be reused in subsequent
+#    training iterations
+# #. zero out gradients
+# #. proceed to regular training
+#
+
+###############################################################################
+# Distributed optimizations
+# -------------------------
+
+###############################################################################
+# Use efficient data-parallel backend
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# PyTorch has two ways to implement data-parallel training:
+#
+# * `torch.nn.DataParallel <https://pytorch.org/docs/stable/generated/torch.nn.DataParallel.html#torch.nn.DataParallel>`_
+# * `torch.nn.parallel.DistributedDataParallel <https://pytorch.org/docs/stable/generated/torch.nn.parallel.DistributedDataParallel.html#torch.nn.parallel.DistributedDataParallel>`_
+#
+# ``DistributedDataParallel`` offers much better performance and scaling to
+# multiple-GPUs. For more information refer to the
+# `relevant section of CUDA Best Practices <https://pytorch.org/docs/stable/notes/cuda.html#use-nn-parallel-distributeddataparallel-instead-of-multiprocessing-or-nn-dataparallel>`_
+# from PyTorch documentation.
+
+###############################################################################
+# Skip unnecessary all-reduce if training with ``DistributedDataParallel`` and gradient accumulation
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# By default
+# `torch.nn.parallel.DistributedDataParallel <https://pytorch.org/docs/stable/generated/torch.nn.parallel.DistributedDataParallel.html#torch.nn.parallel.DistributedDataParallel>`_
+# executes gradient all-reduce after every backward pass to compute the average
+# gradient over all workers participating in the training. If training uses
+# gradient accumulation over N steps, then all-reduce is not necessary after
+# every training step, it's only required to perform all-reduce after the last
+# call to backward, just before the execution of the optimizer.
+#
+# ``DistributedDataParallel`` provides
+# `no_sync() <https://pytorch.org/docs/stable/generated/torch.nn.parallel.DistributedDataParallel.html#torch.nn.parallel.DistributedDataParallel.no_sync>`_
+# context manager which disables gradient all-reduce for particular iteration.
+# ``no_sync()`` should be applied to first ``N-1`` iterations of gradient
+# accumulation, the last iteration should follow the default execution and
+# perform the required gradient all-reduce.
+
+###############################################################################
+# Match the order of layers in constructors and during the execution if using ``DistributedDataParallel(find_unused_parameters=True)``
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# `torch.nn.parallel.DistributedDataParallel <https://pytorch.org/docs/stable/generated/torch.nn.parallel.DistributedDataParallel.html#torch.nn.parallel.DistributedDataParallel>`_
+# with ``find_unused_parameters=True`` uses the order of layers and parameters
+# from model constructors to build buckets for ``DistributedDataParallel``
+# gradient all-reduce. ``DistributedDataParallel`` overlaps all-reduce with the
+# backward pass. All-reduce for a particular bucket is asynchronously triggered
+# only when all gradients for parameters in a given bucket are available.
+#
+# To maximize the amount of overlap, the order in model constructors should
+# roughly match the order during the execution. If the order doesn't match, then
+# all-reduce for the entire bucket waits for the gradient which is the last to
+# arrive, this may reduce the overlap between backward pass and all-reduce,
+# all-reduce may end up being exposed, which slows down the training.
+#
+# ``DistributedDataParallel`` with ``find_unused_parameters=False`` (which is
+# the default setting) relies on automatic bucket formation based on order of
+# operations encountered during the backward pass. With
+# ``find_unused_parameters=False`` it's not necessary to reorder layers or
+# parameters to achieve optimal performance.
+
+###############################################################################
+# Load-balance workload in a distributed setting
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# Load imbalance typically may happen for models processing sequential data
+# (speech recognition, translation, language models etc.). If one device
+# receives a batch of data with sequence length longer than sequence lengths for
+# the remaining devices, then all devices wait for the worker which finishes
+# last. Backward pass functions as an implicit synchronization point in a
+# distributed setting with
+# `DistributedDataParallel <https://pytorch.org/docs/stable/generated/torch.nn.parallel.DistributedDataParallel.html#torch.nn.parallel.DistributedDataParallel>`_
+# backend.
+#
+# There are multiple ways to solve the load balancing problem. The core idea is
+# to distribute workload over all workers as uniformly as possible within each
+# global batch. For example Transformer solves imbalance by forming batches with
+# approximately constant number of tokens (and variable number of sequences in a
+# batch), other models solve imbalance by bucketing samples with similar
+# sequence length or even by sorting dataset by sequence length.
+
+###############################################################################
+# Conclusion
+# ----------
+# 
+# This tutorial covered a comprehensive set of performance optimization techniques
+# for PyTorch models. The key takeaways include:
+#
+# * **General optimizations**: Enable async data loading, disable gradients for
+#   inference, fuse operations with ``torch.compile``, and use efficient memory formats
+# * **CPU optimizations**: Leverage NUMA controls, optimize OpenMP settings, and
+#   use efficient memory allocators
+# * **GPU optimizations**: Enable Tensor cores, use CUDA graphs, enable cuDNN
+#   autotuner, and implement mixed precision training
+# * **Distributed optimizations**: Use DistributedDataParallel, optimize gradient
+#   synchronization, and balance workloads across devices
+#
+# Many of these optimizations can be applied with minimal code changes and provide
+# significant performance improvements across a wide range of deep learning models.
+#
+# Further Reading
+# ---------------
+#
+# * `PyTorch Performance Tuning Documentation <https://pytorch.org/tutorials/recipes/recipes/tuning_guide.html>`_
+# * `CUDA Best Practices <https://pytorch.org/docs/stable/notes/cuda.html>`_
+# * `Distributed Training Documentation <https://pytorch.org/tutorials/intermediate/ddp_tutorial.html>`_
+# * `Mixed Precision Training <https://pytorch.org/docs/stable/amp.html>`_
+# * `torch.compile Tutorial <https://pytorch.org/tutorials/intermediate/torch_compile_tutorial.html>`_
diff --git a/recipes_source/recipes/warmstarting_model_using_parameters_from_a_different_model.py b/recipes_source/recipes/warmstarting_model_using_parameters_from_a_different_model.py
new file mode 100644
index 00000000000..a0752bfc67d
--- /dev/null
+++ b/recipes_source/recipes/warmstarting_model_using_parameters_from_a_different_model.py
@@ -0,0 +1,142 @@
+"""
+Warmstarting model using parameters from a different model in PyTorch
+=====================================================================
+Partially loading a model or loading a partial model are common
+scenarios when transfer learning or training a new complex model.
+Leveraging trained parameters, even if only a few are usable, will help
+to warmstart the training process and hopefully help your model converge
+much faster than training from scratch.
+
+Introduction
+------------
+Whether you are loading from a partial ``state_dict``, which is missing
+some keys, or loading a ``state_dict`` with more keys than the model
+that you are loading into, you can set the strict argument to ``False``
+in the ``load_state_dict()`` function to ignore non-matching keys.
+In this recipe, we will experiment with warmstarting a model using
+parameters of a different model.
+
+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 A and B
+# 3. Save model A
+# 4. Load into model B
+# 
+# 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 A and B
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# 
+# For sake of example, we will create a neural network for training
+# images. To learn more see the Defining a Neural Network recipe. We will
+# create two neural networks for sake of loading one parameter of type A
+# into type B.
+# 
+
+class NetA(nn.Module):
+    def __init__(self):
+        super(NetA, 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 = NetA()
+
+class NetB(nn.Module):
+    def __init__(self):
+        super(NetB, 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
+
+netB = NetB()
+
+
+######################################################################
+# 3. Save model A
+# ~~~~~~~~~~~~~~~~~~~
+# 
+
+# Specify a path to save to
+PATH = "model.pt"
+
+torch.save(netA.state_dict(), PATH)
+
+
+######################################################################
+# 4. Load into model B
+# ~~~~~~~~~~~~~~~~~~~~~~~~
+# 
+# If you want to load parameters from one layer to another, but some keys
+# do not match, simply change the name of the parameter keys in the
+# state_dict that you are loading to match the keys in the model that you
+# are loading into.
+# 
+
+netB.load_state_dict(torch.load(PATH, weights_only=True), strict=False)
+
+
+######################################################################
+# You can see that all keys matched successfully!
+# 
+# Congratulations! You have successfully warmstarted a model using
+# parameters from a different model in PyTorch.
+# 
+# Learn More
+# ----------
+# 
+# Take a look at these other recipes to continue your learning:
+# 
+# - `Saving and loading multiple models in one file using PyTorch <https://pytorch.org/tutorials/recipes/recipes/saving_multiple_models_in_one_file.html>`__
+# - `Saving and loading models across devices in PyTorch <https://pytorch.org/tutorials/recipes/recipes/save_load_across_devices.html>`__
diff --git a/recipes_source/recipes/what_is_state_dict.py b/recipes_source/recipes/what_is_state_dict.py
new file mode 100644
index 00000000000..bd9b1d31b62
--- /dev/null
+++ b/recipes_source/recipes/what_is_state_dict.py
@@ -0,0 +1,133 @@
+"""
+What is a state_dict in PyTorch
+===============================
+In PyTorch, the learnable parameters (i.e. weights and biases) of a
+``torch.nn.Module`` model are contained in the model’s parameters
+(accessed with ``model.parameters()``). A ``state_dict`` is simply a
+Python dictionary object that maps each layer to its parameter tensor.
+
+Introduction
+------------
+A ``state_dict`` is an integral entity if you are interested in saving
+or loading models from PyTorch.
+Because ``state_dict`` objects are Python dictionaries, they can be
+easily saved, updated, altered, and restored, adding a great deal of
+modularity to PyTorch models and optimizers.
+Note that only layers with learnable parameters (convolutional layers,
+linear layers, etc.) and registered buffers (batchnorm’s running_mean)
+have entries in the model’s ``state_dict``. Optimizer objects
+(``torch.optim``) also have a ``state_dict``, which contains information
+about the optimizer’s state, as well as the hyperparameters used.
+In this recipe, we will see how ``state_dict`` is used with a simple
+model.
+
+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. Access the model and optimizer ``state_dict``
+# 
+# 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.nn.functional as F
+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. Access the model and optimizer ``state_dict``
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# 
+# Now that we have constructed our model and optimizer, we can understand
+# what is preserved in their respective ``state_dict`` properties.
+# 
+
+# Print model's state_dict
+print("Model's state_dict:")
+for param_tensor in net.state_dict():
+    print(param_tensor, "\t", net.state_dict()[param_tensor].size())
+
+print()
+
+# Print optimizer's state_dict
+print("Optimizer's state_dict:")
+for var_name in optimizer.state_dict():
+    print(var_name, "\t", optimizer.state_dict()[var_name])
+
+
+######################################################################
+# This information is relevant for saving and loading the model and
+# optimizers for future use.
+# 
+# Congratulations! You have successfully used ``state_dict`` in PyTorch.
+# 
+# Learn More
+# ----------
+# 
+# Take a look at these other recipes to continue your learning:
+# 
+# - `Saving and loading models for inference in PyTorch <https://pytorch.org/tutorials/recipes/recipes/saving_and_loading_models_for_inference.html>`__
+# - `Saving and loading a general checkpoint in PyTorch <https://pytorch.org/tutorials/recipes/recipes/saving_and_loading_a_general_checkpoint.html>`__
diff --git a/recipes_source/recipes/zeroing_out_gradients.py b/recipes_source/recipes/zeroing_out_gradients.py
new file mode 100644
index 00000000000..a4f80354961
--- /dev/null
+++ b/recipes_source/recipes/zeroing_out_gradients.py
@@ -0,0 +1,193 @@
+"""
+Zeroing out gradients in PyTorch
+================================
+It is beneficial to zero out gradients when building a neural network.
+This is because by default, gradients are accumulated in buffers (i.e,
+not overwritten) whenever ``.backward()`` is called.
+
+Introduction
+------------
+When training your neural network, models are able to increase their
+accuracy through gradient descent. In short, gradient descent is the
+process of minimizing our loss (or error) by tweaking the weights and
+biases in our model.
+
+``torch.Tensor`` is the central class of PyTorch. When you create a
+tensor, if you set its attribute ``.requires_grad`` as ``True``, the
+package tracks all operations on it. This happens on subsequent backward
+passes. The gradient for this tensor will be accumulated into ``.grad``
+attribute. The accumulation (or sum) of all the gradients is calculated
+when .backward() is called on the loss tensor.
+
+There are cases where it may be necessary to zero-out the gradients of a
+tensor. For example: when you start your training loop, you should zero
+out the gradients so that you can perform this tracking correctly.
+In this recipe, we will learn how to zero out gradients using the
+PyTorch library. We will demonstrate how to do this by training a neural
+network on the ``CIFAR10`` dataset built into PyTorch.
+
+Setup
+-----
+Since we will be training data in this recipe, if you are in a runnable
+notebook, it is best to switch the runtime to GPU or TPU.
+Before we begin, we need to install ``torch`` and ``torchvision`` if
+they aren’t already available.
+
+.. code-block:: sh
+
+   pip install torchvision
+
+
+"""
+
+
+######################################################################
+# Steps
+# -----
+#
+# Steps 1 through 4 set up our data and neural network for training. The
+# process of zeroing out the gradients happens in step 5. If you already
+# have your data and neural network built, skip to 5.
+#
+# 1. Import all necessary libraries for loading our data
+# 2. Load and normalize the dataset
+# 3. Build the neural network
+# 4. Define the loss function
+# 5. Zero the gradients while training the network
+#
+# 1. Import necessary libraries for loading our data
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# For this recipe, we will just be using ``torch`` and ``torchvision`` to
+# access the dataset.
+#
+
+import torch
+
+import torch.nn as nn
+import torch.nn.functional as F
+
+import torch.optim as optim
+
+import torchvision
+import torchvision.transforms as transforms
+
+
+######################################################################
+# 2. Load and normalize the dataset
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# PyTorch features various built-in datasets (see the Loading Data recipe
+# for more information).
+#
+
+transform = transforms.Compose(
+    [transforms.ToTensor(),
+     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
+
+trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
+                                        download=True, transform=transform)
+trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
+                                          shuffle=True, num_workers=2)
+
+testset = torchvision.datasets.CIFAR10(root='./data', train=False,
+                                       download=True, transform=transform)
+testloader = torch.utils.data.DataLoader(testset, batch_size=4,
+                                         shuffle=False, num_workers=2)
+
+classes = ('plane', 'car', 'bird', 'cat',
+           'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
+
+
+######################################################################
+# 3. Build the neural network
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# We will use a convolutional neural network. 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
+
+
+######################################################################
+# 4. Define a Loss function and optimizer
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# Let’s use a Classification Cross-Entropy loss and SGD with momentum.
+#
+
+net = Net()
+criterion = nn.CrossEntropyLoss()
+optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
+
+
+######################################################################
+# 5. Zero the gradients while training the network
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# This is when things start to get interesting. We simply have to loop
+# over our data iterator, and feed the inputs to the network and optimize.
+#
+# Notice that for each entity of data, we zero out the gradients. This is
+# to ensure that we aren’t tracking any unnecessary information when we
+# train our neural network.
+#
+
+for epoch in range(2):  # loop over the dataset multiple times
+
+    running_loss = 0.0
+    for i, data in enumerate(trainloader, 0):
+        # get the inputs; data is a list of [inputs, labels]
+        inputs, labels = data
+
+        # zero the parameter gradients
+        optimizer.zero_grad()
+
+        # forward + backward + optimize
+        outputs = net(inputs)
+        loss = criterion(outputs, labels)
+        loss.backward()
+        optimizer.step()
+
+        # print statistics
+        running_loss += loss.item()
+        if i % 2000 == 1999:    # print every 2000 mini-batches
+            print('[%d, %5d] loss: %.3f' %
+                  (epoch + 1, i + 1, running_loss / 2000))
+            running_loss = 0.0
+
+print('Finished Training')
+
+
+######################################################################
+# You can also use ``model.zero_grad()``. This is the same as using
+# ``optimizer.zero_grad()`` as long as all your model parameters are in
+# that optimizer. Use your best judgment to decide which one to use.
+#
+# Congratulations! You have successfully zeroed out gradients in PyTorch.
+#
+# Learn More
+# ----------
+#
+# Take a look at these other recipes to continue your learning:
+#
+# - `Loading data in PyTorch <https://pytorch.org/tutorials/beginner/basics/data_tutorial.html>`__
+# - `Saving and loading models across devices in PyTorch <https://pytorch.org/tutorials/recipes/recipes/save_load_across_devices.html>`__
diff --git a/recipes_source/regional_aot.py b/recipes_source/regional_aot.py
new file mode 100644
index 00000000000..cee8465d9bc
--- /dev/null
+++ b/recipes_source/regional_aot.py
@@ -0,0 +1,241 @@
+
+"""
+Reducing AoT cold start compilation time with regional compilation
+============================================================================
+
+**Author:** `Sayak Paul <https://huggingface.co/sayakpaul>`_, `Charles Bensimon <https://huggingface.co/cbensimon>`_, `Angela Yi <https://github.com/angelayi>`_
+
+In the `regional compilation recipe <https://docs.pytorch.org/tutorials/recipes/regional_compilation.html>`__, we showed
+how to reduce cold start compilation times while retaining (almost) full compilation benefits. This was demonstrated for
+just-in-time (JIT) compilation.
+
+This recipe shows how to apply similar principles when compiling a model ahead-of-time (AoT). If you
+are not familiar with AOTInductor and ``torch.export``, we recommend you to check out `this tutorial <https://docs.pytorch.org/tutorials/recipes/torch_export_aoti_python.html>`__.
+
+Prerequisites
+----------------
+
+* Pytorch 2.6 or later
+* Familiarity with regional compilation
+* Familiarity with AOTInductor and ``torch.export``
+
+Setup
+-----
+Before we begin, we need to install ``torch`` if it is not already
+available.
+
+.. code-block:: sh
+
+   pip install torch
+"""
+
+######################################################################
+# Steps
+# -----
+#
+# In this recipe, we will follow the same steps as the regional compilation recipe mentioned above:
+#
+# 1. Import all necessary libraries.
+# 2. Define and initialize a neural network with repeated regions.
+# 3. Measure the compilation time of the full model and the regional compilation with AoT.
+#
+# First, let's import the necessary libraries for loading our data:
+#
+
+import torch
+torch.set_grad_enabled(False)
+
+from time import perf_counter
+
+###################################################################################
+# Defining the Neural Network
+# ---------------------------
+#
+# We will use the same neural network structure as the regional compilation recipe.
+#
+# We will use a network, composed of repeated layers. This mimics a
+# large language model, that typically is composed of many Transformer blocks. In this recipe,
+# we will create a ``Layer`` using the ``nn.Module`` class as a proxy for a repeated region.
+# We will then create a ``Model`` which is composed of 64 instances of this
+# ``Layer`` class.
+#
+class Layer(torch.nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.linear1 = torch.nn.Linear(10, 10)
+        self.relu1 = torch.nn.ReLU()
+        self.linear2 = torch.nn.Linear(10, 10)
+        self.relu2 = torch.nn.ReLU()
+
+    def forward(self, x):
+        a = self.linear1(x)
+        a = self.relu1(a)
+        a = torch.sigmoid(a)
+        b = self.linear2(a)
+        b = self.relu2(b)
+        return b
+
+
+class Model(torch.nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.linear = torch.nn.Linear(10, 10)
+        self.layers = torch.nn.ModuleList([Layer() for _ in range(64)])
+
+    def forward(self, x):
+        # In regional compilation, the self.linear is outside of the scope of ``torch.compile``.
+        x = self.linear(x)
+        for layer in self.layers:
+            x = layer(x)
+        return x
+
+
+##################################################################################
+# Compiling the model ahead-of-time
+# ---------------------------------
+#
+# Since we're compiling the model ahead-of-time, we need to prepare representative
+# input examples, that we expect the model to see during actual deployments.
+#
+# Let's create an instance of ``Model`` and pass it some sample input data.
+#
+
+model = Model().cuda()
+input = torch.randn(10, 10, device="cuda")
+output = model(input)
+print(f"{output.shape=}")
+
+###############################################################################################
+# Now, let's compile our model ahead-of-time. We will use ``input`` created above to pass
+# to ``torch.export``. This will yield a ``torch.export.ExportedProgram`` which we can compile.
+
+path = torch._inductor.aoti_compile_and_package(
+    torch.export.export(model, args=(input,))
+)
+
+#################################################################
+# We can load from this ``path`` and use it to perform inference.
+
+compiled_binary = torch._inductor.aoti_load_package(path)
+output_compiled = compiled_binary(input)
+print(f"{output_compiled.shape=}")
+
+######################################################################################
+# Compiling _regions_ of the model ahead-of-time
+# ----------------------------------------------
+#
+# Compiling model regions ahead-of-time, on the other hand, requires a few key changes.
+#
+# Since the compute pattern is shared by all the blocks that
+# are repeated in a model (``Layer`` instances in this cases), we can just
+# compile a single block and let the inductor reuse it.
+
+model = Model().cuda()
+path = torch._inductor.aoti_compile_and_package(
+    torch.export.export(model.layers[0], args=(input,)),
+    inductor_configs={
+        # compile artifact w/o saving params in the artifact
+        "aot_inductor.package_constants_in_so": False,
+    }
+)
+
+###################################################
+# An exported program (``torch.export.ExportedProgram``) contains the Tensor computation,
+# a ``state_dict`` containing tensor values of all lifted parameters and buffer alongside
+# other metadata. We specify the ``aot_inductor.package_constants_in_so`` to be ``False`` to
+# not serialize the model parameters in the generated artifact.
+#
+# Now, when loading the compiled binary, we can reuse the existing parameters of
+# each block. This lets us take advantage of the compiled binary obtained above.
+#
+
+for layer in model.layers:
+    compiled_layer = torch._inductor.aoti_load_package(path)
+    compiled_layer.load_constants(
+        layer.state_dict(), check_full_update=True, user_managed=True
+    )
+    layer.forward = compiled_layer
+
+output_regional_compiled = model(input)
+print(f"{output_regional_compiled.shape=}")
+
+#####################################################
+# Just like JIT regional compilation, compiling regions within a model ahead-of-time
+# leads to significantly reduced cold start times. The actual number will vary from
+# model to model.
+#
+# Even though full model compilation offers the fullest scope of optimizations,
+# for practical purposes and depending on the type of model, we have seen regional
+# compilation (both JiT and AoT) providing similar speed benefits, while drastically
+# reducing the cold start times.
+
+###################################################
+# Measuring compilation time
+# --------------------------
+# Next, let's measure the compilation time of the full model and the regional compilation.
+#
+
+def measure_compile_time(input, regional=False):
+    start = perf_counter()
+    model = aot_compile_load_model(regional=regional)
+    torch.cuda.synchronize()
+    end = perf_counter()
+    # make sure the model works.
+    _ = model(input)
+    return end - start
+
+def aot_compile_load_model(regional=False) -> torch.nn.Module:
+    input = torch.randn(10, 10, device="cuda")
+    model = Model().cuda()
+
+    inductor_configs = {}
+    if regional:
+        inductor_configs = {"aot_inductor.package_constants_in_so": False}
+
+    # Reset the compiler caches to ensure no reuse between different runs
+    torch.compiler.reset()
+    with torch._inductor.utils.fresh_inductor_cache():
+        path = torch._inductor.aoti_compile_and_package(
+            torch.export.export(
+                model.layers[0] if regional else model,
+                args=(input,)
+            ),
+            inductor_configs=inductor_configs,
+        )
+
+        if regional:
+            for layer in model.layers:
+                compiled_layer = torch._inductor.aoti_load_package(path)
+                compiled_layer.load_constants(
+                    layer.state_dict(), check_full_update=True, user_managed=True
+                )
+                layer.forward = compiled_layer
+        else:
+            model = torch._inductor.aoti_load_package(path)
+    return model
+
+input = torch.randn(10, 10, device="cuda")
+full_model_compilation_latency = measure_compile_time(input, regional=False)
+print(f"Full model compilation time = {full_model_compilation_latency:.2f} seconds")
+
+regional_compilation_latency = measure_compile_time(input, regional=True)
+print(f"Regional compilation time = {regional_compilation_latency:.2f} seconds")
+
+assert regional_compilation_latency < full_model_compilation_latency
+
+############################################################################
+# There may also be layers in a model incompatible with compilation. So,
+# full compilation will result in a fragmented computation graph resulting
+# in potential latency degradation. In these case, regional compilation
+# can be beneficial.
+#
+
+############################################################################
+# Conclusion
+# -----------
+#
+# This recipe shows how to control the cold start time when compiling your
+# model ahead-of-time. This becomes effective when your model has repeated
+# blocks, which is typically seen in large generative models. We used this
+# recipe on various models to speed up real-time performance. Learn more
+# `here <https://huggingface.co/blog/zerogpu-aoti>`__.
diff --git a/recipes_source/regional_compilation.py b/recipes_source/regional_compilation.py
new file mode 100644
index 00000000000..0a665e04b52
--- /dev/null
+++ b/recipes_source/regional_compilation.py
@@ -0,0 +1,178 @@
+"""
+Reducing torch.compile cold start compilation time with regional compilation
+============================================================================
+
+**Author:** `Animesh Jain <https://github.com/anijain2305>`_
+
+As deep learning models get larger, the compilation time of these models also
+increases. This extended compilation time can result in a large startup time in
+inference services or wasted resources in large-scale training. This recipe
+shows an example of how to reduce the cold start compilation time by choosing to
+compile a repeated region of the model instead of the entire model.
+
+Prerequisites
+----------------
+
+* Pytorch 2.5 or later
+
+Setup
+-----
+Before we begin, we need to install ``torch`` if it is not already
+available.
+
+.. code-block:: sh
+
+   pip install torch
+
+.. note::
+   This feature is available starting with the 2.5 release. If you are using version 2.4,
+   you can enable the configuration flag ``torch._dynamo.config.inline_inbuilt_nn_modules=True``
+   to prevent recompilations during regional compilation. In version 2.5, this flag is enabled by default.
+"""
+
+from time import perf_counter
+
+######################################################################
+# Steps
+# -----
+#
+# In this recipe, we will follow these steps:
+#
+# 1. Import all necessary libraries.
+# 2. Define and initialize a neural network with repeated regions.
+# 3. Understand the difference between the full model and the regional compilation.
+# 4. Measure the compilation time of the full model and the regional compilation.
+#
+# First, let's import the necessary libraries for loading our data:
+#
+#
+#
+
+import torch
+import torch.nn as nn
+
+
+##########################################################
+# Next, let's define and initialize a neural network with repeated regions.
+#
+# Typically, neural networks are composed of repeated layers. For example, a
+# large language model is composed of many Transformer blocks. In this recipe,
+# we will create a ``Layer`` using the ``nn.Module`` class as a proxy for a repeated region.
+# We will then create a ``Model`` which is composed of 64 instances of this
+# ``Layer`` class.
+#
+class Layer(torch.nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.linear1 = torch.nn.Linear(10, 10)
+        self.relu1 = torch.nn.ReLU()
+        self.linear2 = torch.nn.Linear(10, 10)
+        self.relu2 = torch.nn.ReLU()
+
+    def forward(self, x):
+        a = self.linear1(x)
+        a = self.relu1(a)
+        a = torch.sigmoid(a)
+        b = self.linear2(a)
+        b = self.relu2(b)
+        return b
+
+
+class Model(torch.nn.Module):
+    def __init__(self, apply_regional_compilation):
+        super().__init__()
+        self.linear = torch.nn.Linear(10, 10)
+        # Apply compile only to the repeated layers.
+        if apply_regional_compilation:
+            self.layers = torch.nn.ModuleList(
+                [torch.compile(Layer()) for _ in range(64)]
+            )
+        else:
+            self.layers = torch.nn.ModuleList([Layer() for _ in range(64)])
+
+    def forward(self, x):
+        # In regional compilation, the self.linear is outside of the scope of `torch.compile`.
+        x = self.linear(x)
+        for layer in self.layers:
+            x = layer(x)
+        return x
+
+
+####################################################
+# Next, let's review the difference between the full model and the regional compilation.
+#
+# In full model compilation, the entire model is compiled as a whole. This is the common approach
+# most users take with ``torch.compile``. In this example, we apply ``torch.compile`` to
+# the ``Model`` object. This will effectively inline the 64 layers, producing a
+# large graph to compile. You can look at the full graph by running this recipe
+# with ``TORCH_LOGS=graph_code``.
+#
+#
+
+model = Model(apply_regional_compilation=False).cuda()
+full_compiled_model = torch.compile(model)
+
+
+###################################################
+# The regional compilation, on the other hand, compiles a region of the model.
+# By strategically choosing to compile a repeated region of the model, we can compile a
+# much smaller graph and then reuse the compiled graph for all the regions.
+# In the example, ``torch.compile`` is applied only to the ``layers`` and not the full model.
+#
+
+regional_compiled_model = Model(apply_regional_compilation=True).cuda()
+
+#####################################################
+# Applying compilation to a repeated region, instead of full model, leads to
+# large savings in compile time. Here, we will just compile a layer instance and
+# then reuse it 64 times in the ``Model`` object.
+#
+# Note that with repeated regions, some part of the model might not be compiled.
+# For example, the ``self.linear`` in the ``Model`` is outside of the scope of
+# regional compilation.
+#
+# Also, note that there is a tradeoff between performance speedup and compile
+# time. Full model compilation involves a larger graph and,
+# theoretically, offers more scope for optimizations. However, for practical
+# purposes and depending on the model, we have observed many cases with minimal
+# speedup differences between the full model and regional compilation.
+
+
+###################################################
+# Next, let's measure the compilation time of the full model and the regional compilation.
+#
+# ``torch.compile`` is a JIT compiler, which means that it compiles on the first invocation.
+# In the code below, we measure the total time spent in the first invocation. While this method is not
+# precise, it provides a good estimate since the majority of the time is spent in
+# compilation.
+
+
+def measure_latency(fn, input):
+    # Reset the compiler caches to ensure no reuse between different runs
+    torch.compiler.reset()
+    with torch._inductor.utils.fresh_inductor_cache():
+        start = perf_counter()
+        fn(input)
+        torch.cuda.synchronize()
+        end = perf_counter()
+        return end - start
+
+
+input = torch.randn(10, 10, device="cuda")
+full_model_compilation_latency = measure_latency(full_compiled_model, input)
+print(f"Full model compilation time = {full_model_compilation_latency:.2f} seconds")
+
+regional_compilation_latency = measure_latency(regional_compiled_model, input)
+print(f"Regional compilation time = {regional_compilation_latency:.2f} seconds")
+
+assert regional_compilation_latency < full_model_compilation_latency
+
+############################################################################
+# Conclusion
+# -----------
+#
+# This recipe shows how to control the cold start compilation time if your model
+# has repeated regions. This approach requires user modifications to apply `torch.compile` to
+# the repeated regions instead of more commonly used full model compilation. We
+# are continually working on reducing cold start compilation time.
+#
diff --git a/recipes_source/script_optimized.rst b/recipes_source/script_optimized.rst
new file mode 100644
index 00000000000..ed64419ff41
--- /dev/null
+++ b/recipes_source/script_optimized.rst
@@ -0,0 +1,11 @@
+Script and Optimize for Mobile Recipe
+=====================================
+
+This tutorial has been deprecated. There is a new tutorial on this topic.
+
+Redirecting in 3 seconds...
+
+.. raw:: html
+
+   <meta http-equiv="Refresh" content="3; url='https://pytorch.org/executorch/stable/tutorials/export-to-executorch-tutorial.html'" />
+
diff --git a/recipes_source/torch_compile_caching_configuration_tutorial.rst b/recipes_source/torch_compile_caching_configuration_tutorial.rst
new file mode 100644
index 00000000000..21565d0562d
--- /dev/null
+++ b/recipes_source/torch_compile_caching_configuration_tutorial.rst
@@ -0,0 +1,78 @@
+Compile Time Caching Configuration
+=========================================================
+**Authors:** `Oguz Ulgen <https://github.com/oulgen>`_ and `Sam Larsen <https://github.com/masnesral>`_
+
+Introduction
+------------------
+
+PyTorch Compiler implements several caches to reduce compilation latency.
+This recipe demonstrates how you can configure various parts of the caching in ``torch.compile``.
+
+Prerequisites
+-------------------
+
+Before starting this recipe, make sure that you have the following:
+
+* Basic understanding of ``torch.compile``. See:
+
+  * `torch.compiler API documentation <https://pytorch.org/docs/stable/torch.compiler.html#torch-compiler>`__
+  * `Introduction to torch.compile <https://pytorch.org/tutorials/intermediate/torch_compile_tutorial.html>`__
+  * `Compile Time Caching in torch.compile <https://pytorch.org/tutorials/recipes/torch_compile_caching_tutorial.html>`__
+
+* PyTorch 2.4 or later
+
+Inductor Cache Settings
+----------------------------
+
+Most of these caches are in-memory, only used within the same process, and are transparent to the user. An exception is caches that store compiled FX graphs (``FXGraphCache``, ``AOTAutogradCache``). These caches allow Inductor to avoid recompilation across process boundaries when it encounters the same graph with the same Tensor input shapes (and the same configuration). The default implementation stores compiled artifacts in the system temp directory. An optional feature also supports sharing those artifacts within a cluster by storing them in a Redis database.
+
+There are a few settings relevant to caching and to FX graph caching in particular.
+The settings are accessible via environment variables listed below or can be hard-coded in the Inductor’s config file.
+
+TORCHINDUCTOR_FX_GRAPH_CACHE
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+This setting enables the local FX graph cache feature, which stores artifacts in the host’s temp directory. Setting it to ``1`` enables the feature while any other value disables it. By default, the disk location is per username, but users can enable sharing across usernames by specifying ``TORCHINDUCTOR_CACHE_DIR`` (below).
+
+TORCHINDUCTOR_AUTOGRAD_CACHE
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+This setting extends ``FXGraphCache`` to store cached results at the ``AOTAutograd`` level, rather than at the Inductor level. Setting it to ``1`` enables this feature, while any other value disables it.
+By default, the disk location is per username, but users can enable sharing across usernames by specifying ``TORCHINDUCTOR_CACHE_DIR`` (below).
+``TORCHINDUCTOR_AUTOGRAD_CACHE`` requires ``TORCHINDUCTOR_FX_GRAPH_CACHE`` to work. The same cache dir stores cache entries for ``AOTAutogradCache`` (under ``{TORCHINDUCTOR_CACHE_DIR}/aotautograd``) and ``FXGraphCache`` (under ``{TORCHINDUCTOR_CACHE_DIR}/fxgraph``).
+
+TORCHINDUCTOR_CACHE_DIR
+~~~~~~~~~~~~~~~~~~~~~~~~
+This setting specifies the location of all on-disk caches. By default, the location is in the system temp directory under ``torchinductor_<username>``, for example, ``/tmp/torchinductor_myusername``.
+
+Note that if ``TRITON_CACHE_DIR`` is not set in the environment, Inductor sets the ``Triton`` cache directory to this same temp location, under the Triton sub-directory.
+
+TORCHINDUCTOR_FX_GRAPH_REMOTE_CACHE
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+This setting enables the remote FX graph cache feature. The current implementation uses ``Redis``. ``1`` enables caching, and any other value disables it. The following environment variables configure the host and port of the Redis server:
+
+``TORCHINDUCTOR_REDIS_HOST`` (defaults to ``localhost``)
+``TORCHINDUCTOR_REDIS_PORT`` (defaults to ``6379``)
+
+.. note::
+
+    Note that if Inductor locates a remote cache entry, it stores the compiled artifact in the local on-disk cache; that local artifact would be served on subsequent runs on the same machine.
+
+TORCHINDUCTOR_AUTOGRAD_REMOTE_CACHE
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Similar to ``TORCHINDUCTOR_FX_GRAPH_REMOTE_CACHE``, this setting enables the remote ``AOTAutogradCache`` feature. The current implementation uses Redis. Setting it to ``1`` enables caching, while any other value disables it. The following environment variables are used to configure the host and port of the ``Redis`` server:
+* ``TORCHINDUCTOR_REDIS_HOST`` (defaults to ``localhost``)
+* ``TORCHINDUCTOR_REDIS_PORT`` (defaults to ``6379``)
+
+`TORCHINDUCTOR_AUTOGRAD_REMOTE_CACHE`` requires ``TORCHINDUCTOR_FX_GRAPH_REMOTE_CACHE`` to be enabled in order to function. The same Redis server can be used to store both AOTAutograd and FXGraph cache results.
+
+TORCHINDUCTOR_AUTOTUNE_REMOTE_CACHE
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+This setting enables a remote cache for ``TorchInductor``’s autotuner. Similar to remote FX graph cache, the current implementation uses Redis. Setting it to ``1`` enables caching, while any other value disables it. The same host / port environment variables mentioned above apply to this cache.
+
+TORCHINDUCTOR_FORCE_DISABLE_CACHES
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Set this value to ``1`` to disable all Inductor caching. This setting is useful for tasks like experimenting with cold-start compile times or forcing recompilation for debugging purposes.
+
+Conclusion
+-------------
+In this recipe, we have learned how to configure PyTorch Compiler's caching mechanisms. Additionally, we explored the various settings and environment variables that allow users to configure and optimize these caching features according to their specific needs.
+
diff --git a/recipes_source/torch_compile_caching_tutorial.rst b/recipes_source/torch_compile_caching_tutorial.rst
new file mode 100644
index 00000000000..e846817cbc0
--- /dev/null
+++ b/recipes_source/torch_compile_caching_tutorial.rst
@@ -0,0 +1,107 @@
+Compile Time Caching in ``torch.compile``
+=========================================================
+**Author:** `Oguz Ulgen <https://github.com/oulgen>`_
+
+Introduction
+------------------
+
+PyTorch Compiler provides several caching offerings to reduce compilation latency.
+This recipe will explain these offerings in detail to help users pick the best option for their use case.
+
+Check out `Compile Time Caching Configurations <https://pytorch.org/tutorials/recipes/torch_compile_caching_configuration_tutorial.html>`__ for how to configure these caches.
+
+Also check out our caching benchmark at `PT CacheBench Benchmarks <https://hud.pytorch.org/benchmark/llms?repoName=pytorch%2Fpytorch&benchmarkName=TorchCache+Benchmark>`__.
+
+Prerequisites
+-------------------
+
+Before starting this recipe, make sure that you have the following:
+
+* Basic understanding of ``torch.compile``. See:
+
+  * `torch.compiler API documentation <https://pytorch.org/docs/stable/torch.compiler.html#torch-compiler>`__
+  * `Introduction to torch.compile <https://pytorch.org/tutorials/intermediate/torch_compile_tutorial.html>`__
+  * `Triton language documentation <https://triton-lang.org/main/index.html>`__
+
+* PyTorch 2.4 or later
+
+Caching Offerings
+---------------------
+
+``torch.compile`` provides the following caching offerings:
+
+* End to end caching (also known as ``Mega-Cache``)
+* Modular caching of ``TorchDynamo``, ``TorchInductor``, and ``Triton``
+
+It is important to note that caching validates that the cache artifacts are used with the same PyTorch and Triton version, as well as, same GPU when device is set to be cuda.
+
+``torch.compile`` end-to-end caching (``Mega-Cache``)
+------------------------------------------------------------
+
+End to end caching, from here onwards referred to ``Mega-Cache``, is the ideal solution for users looking for a portable caching solution that can be stored in a database and can later be fetched possibly on a separate machine.
+
+``Mega-Cache`` provides two compiler APIs:
+
+* ``torch.compiler.save_cache_artifacts()``
+* ``torch.compiler.load_cache_artifacts()``
+
+The intended use case is after compiling and executing a model, the user calls ``torch.compiler.save_cache_artifacts()`` which will return the compiler artifacts in a portable form. Later, potentially on a different machine, the user may call ``torch.compiler.load_cache_artifacts()`` with these artifacts to pre-populate the ``torch.compile`` caches in order to jump-start their cache.
+
+Consider the following example. First, compile and save the cache artifacts.
+
+.. code-block:: python
+
+    @torch.compile
+    def fn(x, y):
+        return x.sin() @ y
+
+    a = torch.rand(100, 100, dtype=dtype, device=device)
+    b = torch.rand(100, 100, dtype=dtype, device=device)
+
+    result = fn(a, b)
+
+    artifacts = torch.compiler.save_cache_artifacts()
+
+    assert artifacts is not None
+    artifact_bytes, cache_info = artifacts
+
+    # Now, potentially store artifact_bytes in a database
+    # You can use cache_info for logging
+
+Later, you can jump-start the cache by the following:
+
+.. code-block:: python 
+
+    # Potentially download/fetch the artifacts from the database
+    torch.compiler.load_cache_artifacts(artifact_bytes)
+
+This operation populates all the modular caches that will be discussed in the next section, including ``PGO``, ``AOTAutograd``, ``Inductor``, ``Triton``, and ``Autotuning``.
+
+
+Modular caching of ``TorchDynamo``, ``TorchInductor``, and ``Triton``
+-----------------------------------------------------------
+
+The aforementioned ``Mega-Cache`` is composed of individual components that can be used without any user intervention. By default, PyTorch Compiler comes with local on-disk caches for ``TorchDynamo``, ``TorchInductor``, and ``Triton``. These caches include:
+
+* ``FXGraphCache``: A cache of graph-based IR components used in compilation.
+* ``TritonCache``: A cache of Triton-compilation results, including ``cubin`` files generated by ``Triton`` and other caching artifacts.
+* ``InductorCache``: A bundle of ``FXGraphCache`` and ``Triton`` cache.
+* ``AOTAutogradCache``: A cache of joint graph artifacts.
+* ``PGO-cache``: A cache of dynamic shape decisions to reduce number of recompilations.
+* `AutotuningCache <https://github.com/pytorch/pytorch/blob/795a6a0affd349adfb4e3df298b604b74f27b44e/torch/_inductor/runtime/autotune_cache.py#L116>`__: 
+    * ``Inductor`` generates ``Triton`` kernels and benchmarks them to select the fastest kernels.
+    * ``torch.compile``'s built-in ``AutotuningCache`` caches these results.
+
+All these cache artifacts are written to ``TORCHINDUCTOR_CACHE_DIR`` which by default will look like ``/tmp/torchinductor_myusername``.
+
+
+Remote Caching
+----------------
+
+We also provide a remote caching option for users who would like to take advantage of a Redis based cache. Check out `Compile Time Caching Configurations <https://pytorch.org/tutorials/recipes/torch_compile_caching_configuration_tutorial.html>`__ to learn more about how to enable the Redis-based caching.
+
+
+Conclusion
+-------------
+In this recipe, we have learned that PyTorch Inductor's caching mechanisms significantly reduce compilation latency by utilizing both local and remote caches, which operate seamlessly in the background without requiring user intervention.
+
diff --git a/recipes_source/torch_compile_torch_function_modes.py b/recipes_source/torch_compile_torch_function_modes.py
new file mode 100644
index 00000000000..7808579563e
--- /dev/null
+++ b/recipes_source/torch_compile_torch_function_modes.py
@@ -0,0 +1,77 @@
+"""
+(beta) Utilizing Torch Function modes with torch.compile
+============================================================
+
+**Author:** `Michael Lazos <https://github.com/mlazos>`_
+"""
+
+#########################################################
+#  This recipe covers how to use a key torch extensibility point, 
+#  torch function modes, in tandem with ``torch.compile`` to override 
+#  the behavior of torch operators, also know as **ops**, at trace time, with no runtime overhead.
+#
+# .. note::
+#
+#    This recipe requires PyTorch 2.7.0 or later.
+
+
+#####################################################################
+# Rewriting a torch op (torch.add -> torch.mul)
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# For this example, we'll use torch function modes to rewrite occurences
+# of addition with multiply instead. This type of override can be common 
+# if a certain backend has a custom implementation that should be dispatched
+# for a given op. 
+import torch
+
+# exit cleanly if we are on a device that doesn't support ``torch.compile``
+if torch.cuda.get_device_capability() < (7, 0):
+    print("Exiting because torch.compile is not supported on this device.")
+    import sys
+    sys.exit(0)
+
+from torch.overrides import BaseTorchFunctionMode
+
+# Define our mode, Note: ``BaseTorchFunctionMode``
+# implements the actual invocation of func(..)
+class AddToMultiplyMode(BaseTorchFunctionMode):
+    def __torch_function__(self, func, types, args=(), kwargs=None):
+        if func == torch.Tensor.add:
+            func = torch.mul
+
+        return super().__torch_function__(func, types, args, kwargs)
+
+@torch.compile()
+def test_fn(x, y):
+    return x + y * x # Note: infix operators map to torch.Tensor.* methods
+
+x = torch.rand(2, 2)
+y = torch.rand_like(x)
+
+with AddToMultiplyMode():
+    z = test_fn(x, y)
+
+assert torch.allclose(z, x * y * x)
+
+# The mode can also be used within the compiled region as well like this:
+
+@torch.compile()
+def test_fn(x, y):
+    with AddToMultiplyMode():
+        return x + y * x # Note: infix operators map to torch.Tensor.* methods
+
+x = torch.rand(2, 2)
+y = torch.rand_like(x)
+z = test_fn(x, y)
+
+assert torch.allclose(z, x * y * x)
+
+######################################################################
+# Conclusion
+# ~~~~~~~~~~
+# In this recipe we demonstrated how to override the behavior of ``torch.*`` operators
+# using torch function modes from within ``torch.compile``. This enables users to utilize
+# the extensibility benefits of torch function modes without the runtime overhead
+# of calling torch function on every op invocation. 
+# 
+# * See `Extending Torch API with Modes <https://pytorch.org/docs/stable/notes/extending.html#extending-all-torch-api-with-modes>`__  for other examples and background on Torch Function modes.
diff --git a/recipes_source/torch_compile_user_defined_triton_kernel_tutorial.py b/recipes_source/torch_compile_user_defined_triton_kernel_tutorial.py
new file mode 100644
index 00000000000..10ecd74ce91
--- /dev/null
+++ b/recipes_source/torch_compile_user_defined_triton_kernel_tutorial.py
@@ -0,0 +1,372 @@
+# -*- coding: utf-8 -*-
+
+"""
+Using User-Defined Triton Kernels with ``torch.compile``
+=========================================================
+**Author:** `Oguz Ulgen <https://github.com/oulgen>`_
+"""
+
+######################################################################
+# User-defined Triton kernels can be used to optimize specific parts of your
+# model's computation. These kernels are written in Triton's language, which is designed
+# to make it easier to achieve peak hardware performance. By using user-defined Triton
+# kernels with ``torch.compile``, you can integrate these optimized computations into
+# your PyTorch model, potentially achieving significant performance improvements.
+#
+# This recipes demonstrates how you can use user-defined Triton kernels with ``torch.compile``.
+#
+# Prerequisites
+# -------------------
+#
+# Before starting this recipe, make sure that you have the following:
+#
+# * Basic understanding of ``torch.compile`` and Triton. See:
+#
+#   * `torch.compiler API documentation <https://pytorch.org/docs/stable/torch.compiler.html#torch-compiler>`__
+#   * `Introduction to torch.compile <https://pytorch.org/tutorials/intermediate/torch_compile_tutorial.html>`__
+#   * `Triton language documentation <https://triton-lang.org/main/index.html>`__
+#
+# * PyTorch 2.3 or later
+# * A GPU that supports Triton
+#
+
+import torch
+from torch.utils._triton import has_triton
+
+######################################################################
+# Basic Usage
+# --------------------
+#
+# In this example, we will use a simple vector addition kernel from the Triton documentation
+# with ``torch.compile``.
+# For reference, see `Triton documentation <https://triton-lang.org/main/getting-started/tutorials/01-vector-add.html>`__.
+#
+
+if not has_triton():
+    print("Skipping because triton is not supported on this device.")
+else:
+    import triton
+    from triton import language as tl
+
+    @triton.jit
+    def add_kernel(
+        in_ptr0,
+        in_ptr1,
+        out_ptr,
+        n_elements,
+        BLOCK_SIZE: "tl.constexpr",
+    ):
+        pid = tl.program_id(axis=0)
+        block_start = pid * BLOCK_SIZE
+        offsets = block_start + tl.arange(0, BLOCK_SIZE)
+        mask = offsets < n_elements
+        x = tl.load(in_ptr0 + offsets, mask=mask)
+        y = tl.load(in_ptr1 + offsets, mask=mask)
+        output = x + y
+        tl.store(out_ptr + offsets, output, mask=mask)
+
+    @torch.compile(fullgraph=True)
+    def add_fn(x, y):
+        output = torch.zeros_like(x)
+        n_elements = output.numel()
+        grid = lambda meta: (triton.cdiv(n_elements, meta["BLOCK_SIZE"]),)
+        add_kernel[grid](x, y, output, n_elements, BLOCK_SIZE=4)
+        return output
+
+    x = torch.randn(4, device="cuda")
+    y = torch.randn(4, device="cuda")
+    out = add_fn(x, y)
+    print(f"Vector addition of\nX:\t{x}\nY:\t{y}\nis equal to\n{out}")
+
+######################################################################
+# Advanced Usage
+# -------------------------------------------------------------------
+#
+# Triton's autotune feature is a powerful tool that automatically optimizes the configuration
+# parameters of your Triton kernels. It explores a range of possible configurations and
+# selects the one that delivers the best performance for your specific use case.
+#
+# When used with ``torch.compile``, ``triton.autotune`` can help ensure that your PyTorch
+# model is running as efficiently as possible. Here is an example of using ``torch.compile``
+# and ``triton.autotune``.
+#
+# .. note::
+#
+#   ``torch.compile`` only supports configs and key arguments to ``triton.autotune``.
+
+if not has_triton():
+    print("Skipping because triton is not supported on this device.")
+else:
+    import triton
+    from triton import language as tl
+
+    @triton.autotune(
+        configs=[
+            triton.Config({"BLOCK_SIZE": 4}, num_stages=3, num_warps=8),
+            triton.Config({"BLOCK_SIZE": 4}, num_stages=4, num_warps=4),
+            triton.Config({"BLOCK_SIZE": 2}, num_stages=3, num_warps=8),
+            triton.Config({"BLOCK_SIZE": 2}, num_stages=4, num_warps=4),
+        ],
+        key=[],
+    )
+    @triton.jit
+    def add_kernel_autotuned(
+        in_ptr0,
+        in_ptr1,
+        out_ptr,
+        n_elements,
+        BLOCK_SIZE: "tl.constexpr",
+    ):
+        pid = tl.program_id(axis=0)
+        block_start = pid * BLOCK_SIZE
+        offsets = block_start + tl.arange(0, BLOCK_SIZE)
+        mask = offsets < n_elements
+        x = tl.load(in_ptr0 + offsets, mask=mask)
+        y = tl.load(in_ptr1 + offsets, mask=mask)
+        output = x + y
+        tl.store(out_ptr + offsets, output, mask=mask)
+
+    @torch.compile(fullgraph=True)
+    def add_fn(x, y):
+        output = torch.zeros_like(x)
+        n_elements = output.numel()
+        grid = lambda meta: (triton.cdiv(n_elements, meta["BLOCK_SIZE"]),)
+        add_kernel_autotuned[grid](x, y, output, n_elements)
+        return output
+
+    x = torch.randn(4, device="cuda")
+    y = torch.randn(4, device="cuda")
+    out = add_fn(x, y)
+    print(f"Vector addition of\nX:\t{x}\nY:\t{y}\nis equal to\n{out}")
+
+######################################################################
+# Composability
+# -------------------------------------------------------------------
+#
+# User-defined Triton kernels do not automatically support all PyTorch
+# subsystems. This can be seen in the following use cases:
+#
+# - Adding a CPU fallback
+# - Adding a ``FlopCounter`` formula
+# - Composing with Tensor Subclasses
+#
+# To compose with additional PyTorch subsystems, use ``torch.library.triton_op``.
+#
+# ``triton_op is`` a structured way of defining a custom operator that is backed by one
+# or more Triton kernels: like regular custom operators (``torch.library.custom_op``),
+# you are able to specify the interactions with PyTorch subsystems via ``torch.library``.
+# However, unlike ``torch.library.custom_op``, which creates opaque callables with respect to
+# ``torch.compile``, ``torch.compile`` traces into ``triton_op`` to apply optimizations.
+#
+# Here’s a chart of which API to use when integrating Triton kernels with PyTorch.
+#
+# .. list-table::
+#    :header-rows: 1
+#
+#    * -
+#      - Triton kernel (no explicit ``torch.library`` wrapper)
+#      - ``torch.library.triton_op``
+#      - ``torch.library.custom_op``
+#    * - Supports inference
+#      - Yes
+#      - Yes
+#      - Yes
+#    * - Supports training
+#      - In the majority of cases
+#      - Yes
+#      - Yes
+#    * - Supports ``torch.compile``
+#      - Yes
+#      - Yes
+#      - Yes
+#    * - Supports ``torch.compile(fullgraph=True)``
+#      - In the majority of cases
+#      - In the majority of cases
+#      - In all cases
+#    * - Does torch.compile trace into the implementation?
+#      - Yes
+#      - Yes
+#      - No
+#    * - Supports AOTInductor
+#      - Yes
+#      - Yes
+#      - No
+#    * - Supports PyTorch Subsystems like FlopCounterMode, CPU Fallback, Tensor Subclasses
+#      - No
+#      - Yes
+#      - Yes
+
+######################################################################
+# Wrapping Triton kernels with ``triton_op``
+# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#
+# Use ``torch.library.triton_op`` to wrap a function that may invoke one or more Triton kernels.
+# Use ``torch.library.wrap_triton`` to wrap the calls to the Triton kernel.
+
+from torch.library import triton_op, wrap_triton
+
+@triton_op("mylib::mysin", mutates_args={})
+def mysin(x: torch.Tensor) -> torch.Tensor:
+    out = torch.empty_like(x)
+    n_elements = x.numel()
+    wrap_triton(sin_kernel)[(n_elements,)](x, out, n_elements, BLOCK_SIZE=4)
+    return out
+
+@triton.jit
+def sin_kernel(
+    in_ptr0,
+    out_ptr,
+    n_elements,
+    BLOCK_SIZE: "tl.constexpr",
+):
+    pid = tl.program_id(axis=0)
+    block_start = pid * BLOCK_SIZE
+    offsets = block_start + tl.arange(0, BLOCK_SIZE)
+    mask = offsets < n_elements
+    x = tl.load(in_ptr0 + offsets, mask=mask)
+    output = tl.sin(x)
+    tl.store(out_ptr + offsets, output, mask=mask)
+
+######################################################################
+# You can invoke the ``triton_op`` in one of the following two ways.
+
+x = torch.randn(3, device="cuda")
+y = mysin(x)
+z = torch.ops.mylib.mysin.default(x)
+
+assert torch.allclose(y, x.sin())
+assert torch.allclose(z, x.sin())
+
+######################################################################
+# The resulting ``triton_op`` works with ``torch.compile`` and ``AOTInductor``.
+
+y = torch.compile(mysin)(x)
+assert torch.allclose(y, x.sin())
+
+######################################################################
+# Adding training support
+# ^^^^^^^^^^^^^^^^^^^^^^^
+#
+# Use ``register_autograd`` to add an autograd formula for the ``triton_op``.
+# Prefer this to using ``torch.autograd.Function`` (which has various composability footguns
+# with ``torch.compile``).
+
+def backward(ctx, grad):
+    x, = ctx.saved_tensors
+    return grad * x.cos()
+
+def setup_context(ctx, inputs, output):
+    x, = inputs
+    ctx.save_for_backward(x)
+
+mysin.register_autograd(backward, setup_context=setup_context)
+
+######################################################################
+# Note that the backward must be a composition of PyTorch-understood operators.
+# If you want the backward to call Triton kernels, then those must be wrapped in ``triton_op`` as well:
+
+@triton.jit
+def cos_kernel(
+    in_ptr0,
+    out_ptr,
+    n_elements,
+    BLOCK_SIZE: "tl.constexpr",
+):
+    pid = tl.program_id(axis=0)
+    block_start = pid * BLOCK_SIZE
+    offsets = block_start + tl.arange(0, BLOCK_SIZE)
+    mask = offsets < n_elements
+    x = tl.load(in_ptr0 + offsets, mask=mask)
+    output = tl.cos(x)
+    tl.store(out_ptr + offsets, output, mask=mask)
+
+@triton_op("mylib::mycos", mutates_args={})
+def mycos(x: torch.Tensor) -> torch.Tensor:
+    out = torch.empty_like(x)
+    n_elements = x.numel()
+    wrap_triton(cos_kernel)[(n_elements,)](x, out, n_elements, BLOCK_SIZE=4)
+    return out
+
+def backward(ctx, grad):
+    x, = ctx.saved_tensors
+    return grad * mycos(x)
+
+def setup_context(ctx, inputs, output):
+    x, = inputs
+    ctx.save_for_backward(x)
+
+mysin.register_autograd(backward, setup_context=setup_context)
+
+######################################################################
+# Adding a CPU Fallback
+# ^^^^^^^^^^^^^^^^^^^^^
+# Triton kernels don’t run on CPU. Use  ``register_kernel`` to add a CPU (or any other device) fallback for the ``triton_op``:
+
+@mysin.register_kernel("cpu")
+def _(x):
+    return torch.sin(x)
+
+x = torch.randn(3)
+y = mysin(x)
+assert torch.allclose(y, x.sin())
+
+######################################################################
+# The fallback must be composed of PyTorch operators.
+
+######################################################################
+# Adding a FlopCounter Formula
+# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#
+# To specify how many flops the triton kernel reports under PyTorch's flop counter,
+# use ``register_flop_formula``.
+
+from torch.utils.flop_counter import FlopCounterMode, register_flop_formula
+
+@register_flop_formula(torch.ops.mylib.mysin)
+def _(x_shape):
+    numel = 1
+    for s in x_shape:
+        numel *= s
+    return numel
+
+x = torch.randn(3, device="cuda")
+
+#########################################################
+# ``FlopCounterMode`` requires `tabulate <https://pypi.org/project/tabulate/>`__.
+# Before running the code below, make sure you have ``tabulate`` installed or install by
+# running ``pip install tabulate``. 
+#
+# >>> with FlopCounterMode() as flop_counter:
+# >>>     y = mysin(x)
+
+######################################################################
+# Limitations
+# --------------------------------------------------------------------
+#
+# As of PyTorch 2.3, the support for user-defined Triton kernels in ``torch.compile``
+# includes dynamic shapes, ``torch.autograd.Function``, JIT inductor, and AOT inductor.
+# You can use these features together to build complex, high-performance models.
+#
+# PyTorch 2.6 added ``torch.library.triton_op``, which adds support for
+# user-defined Triton kernels in tensor subclasses and other advanced features.
+#
+# However, there are certain limitations to be aware of:
+#
+# * **Triton Features:** While ``triton.heuristics`` can be used either standalone or
+#   before ``triton.autotune``, it cannot be used after ``triton.autotune``. This
+#   implies that if ``triton.heuristics`` and ``triton.autotune`` are to be used
+#   together, ``triton.heuristics`` must be used first.
+#
+# Conclusion
+# -----------
+# In this recipe, we explored how to utilize user-defined Triton kernels
+# with ``torch.compile``. We delved into the basic usage of a simple
+# vector addition kernel and advanced usage involving Triton's autotune
+# feature. We also discussed the composability of user-defined Triton
+# kernels with other PyTorch features and highlighted some current limitations.
+#
+# See Also
+# ---------
+#
+# * `Compiling the Optimizers <https://pytorch.org/tutorials/recipes/compiling_optimizer.html>`__
+# * `Implementing High-Performance Transformers with Scaled Dot Product Attention <https://pytorch.org/tutorials/intermediate/scaled_dot_product_attention_tutorial.html>`__
diff --git a/recipes_source/torch_compiler_set_stance_tutorial.py b/recipes_source/torch_compiler_set_stance_tutorial.py
new file mode 100644
index 00000000000..56b338db801
--- /dev/null
+++ b/recipes_source/torch_compiler_set_stance_tutorial.py
@@ -0,0 +1,244 @@
+# -*- coding: utf-8 -*-
+
+"""
+Dynamic Compilation Control with ``torch.compiler.set_stance``
+=========================================================================
+**Author:** `William Wen <https://github.com/williamwen42>`_
+"""
+
+######################################################################
+# ``torch.compiler.set_stance`` is a ``torch.compiler`` API that
+# enables you to change the behavior of ``torch.compile`` across different
+# calls to your model without having to reapply ``torch.compile`` to your model.
+#
+# This recipe provides some examples on how to use ``torch.compiler.set_stance``.
+#
+#
+# .. contents::
+#     :local:
+#
+# Prerequisites
+# ---------------
+#
+# - ``torch >= 2.6``
+
+######################################################################
+# Description
+# -----------
+# ``torch.compile.set_stance`` can be used as a decorator, context manager, or raw function
+# to change the behavior of ``torch.compile`` across different calls to your model.
+#
+# In the example below, the ``"force_eager"`` stance ignores all ``torch.compile`` directives.
+
+import torch
+
+
+@torch.compile
+def foo(x):
+    if torch.compiler.is_compiling():
+        # torch.compile is active
+        return x + 1
+    else:
+        # torch.compile is not active
+        return x - 1
+
+
+inp = torch.zeros(3)
+
+print(foo(inp))  # compiled, prints 1
+
+######################################################################
+# Sample decorator usage
+
+
+@torch.compiler.set_stance("force_eager")
+def bar(x):
+    # force disable the compiler
+    return foo(x)
+
+
+print(bar(inp))  # not compiled, prints -1
+
+######################################################################
+# Sample context manager usage
+
+with torch.compiler.set_stance("force_eager"):
+    print(foo(inp))  # not compiled, prints -1
+
+######################################################################
+# Sample raw function usage
+
+torch.compiler.set_stance("force_eager")
+print(foo(inp))  # not compiled, prints -1
+torch.compiler.set_stance("default")
+
+print(foo(inp))  # compiled, prints 1
+
+######################################################################
+# ``torch.compile`` stance can only be changed **outside** of any ``torch.compile`` region. Attempts
+# to do otherwise will result in an error.
+
+
+@torch.compile
+def baz(x):
+    # error!
+    with torch.compiler.set_stance("force_eager"):
+        return x + 1
+
+
+try:
+    baz(inp)
+except Exception as e:
+    print(e)
+
+
+@torch.compiler.set_stance("force_eager")
+def inner(x):
+    return x + 1
+
+
+@torch.compile
+def outer(x):
+    # error!
+    return inner(x)
+
+
+try:
+    outer(inp)
+except Exception as e:
+    print(e)
+
+######################################################################
+# Other stances include:
+#  - ``"default"``: The default stance, used for normal compilation.
+#  - ``"eager_on_recompile"``: Run code eagerly when a recompile is necessary. If there is cached compiled code valid for the input, it will still be used.
+#  - ``"fail_on_recompile"``: Raise an error when recompiling a function.
+#
+# See the ``torch.compiler.set_stance`` `doc page <https://pytorch.org/docs/main/generated/torch.compiler.set_stance.html#torch.compiler.set_stance>`__
+# for more stances and options. More stances/options may also be added in the future.
+
+######################################################################
+# Examples
+# --------
+
+######################################################################
+# Preventing recompilation
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# Some models do not expect any recompilations - for example, you may always have inputs with the same shape.
+# Since recompilations may be expensive, we may wish to error out when we attempt to recompile so we can detect and fix recompilation cases.
+# The ``"fail_on_recompilation"`` stance can be used for this.
+
+
+@torch.compile
+def my_big_model(x):
+    return torch.relu(x)
+
+
+# first compilation
+my_big_model(torch.randn(3))
+
+with torch.compiler.set_stance("fail_on_recompile"):
+    my_big_model(torch.randn(3))  # no recompilation - OK
+    try:
+        my_big_model(torch.randn(4))  # recompilation - error
+    except Exception as e:
+        print(e)
+
+######################################################################
+# If erroring out is too disruptive, we can use ``"eager_on_recompile"`` instead,
+# which will cause ``torch.compile`` to fall back to eager instead of erroring out.
+# This may be useful if we don't expect recompilations to happen frequently, but
+# when one is required, we'd rather pay the cost of running eagerly over the cost of recompilation.
+
+
+@torch.compile
+def my_huge_model(x):
+    if torch.compiler.is_compiling():
+        return x + 1
+    else:
+        return x - 1
+
+
+# first compilation
+print(my_huge_model(torch.zeros(3)))  # 1
+
+with torch.compiler.set_stance("eager_on_recompile"):
+    print(my_huge_model(torch.zeros(3)))  # 1
+    print(my_huge_model(torch.zeros(4)))  # -1
+    print(my_huge_model(torch.zeros(3)))  # 1
+
+
+######################################################################
+# Measuring performance gains
+# ===========================
+#
+# ``torch.compiler.set_stance`` can be used to compare eager vs. compiled performance
+# without having to define a separate eager model.
+
+
+# Returns the result of running `fn()` and the time it took for `fn()` to run,
+# in seconds. We use CUDA events and synchronization for the most accurate
+# measurements.
+def timed(fn):
+    start = torch.cuda.Event(enable_timing=True)
+    end = torch.cuda.Event(enable_timing=True)
+    start.record()
+    result = fn()
+    end.record()
+    torch.cuda.synchronize()
+    return result, start.elapsed_time(end) / 1000
+
+
+@torch.compile
+def my_gigantic_model(x, y):
+    x = x @ y
+    x = x @ y
+    x = x @ y
+    return x
+
+
+inps = torch.randn(5, 5), torch.randn(5, 5)
+
+with torch.compiler.set_stance("force_eager"):
+    print("eager:", timed(lambda: my_gigantic_model(*inps))[1])
+
+# warmups
+for _ in range(3):
+    my_gigantic_model(*inps)
+
+print("compiled:", timed(lambda: my_gigantic_model(*inps))[1])
+
+
+######################################################################
+# Crashing sooner
+# ===============
+#
+# Running an eager iteration first before a compiled iteration using the ``"force_eager"`` stance
+# can help us to catch errors unrelated to ``torch.compile`` before attempting a very long compile.
+
+
+@torch.compile
+def my_humongous_model(x):
+    return torch.sin(x, x)
+
+
+try:
+    with torch.compiler.set_stance("force_eager"):
+        print(my_humongous_model(torch.randn(3)))
+    # this call to the compiled model won't run
+    print(my_humongous_model(torch.randn(3)))
+except Exception as e:
+    print(e)
+
+########################################
+# Conclusion
+# --------------
+# In this recipe, we have learned how to use the ``torch.compiler.set_stance`` API
+# to modify the behavior of ``torch.compile`` across different calls to a model
+# without needing to reapply it. The recipe demonstrates using
+# ``torch.compiler.set_stance`` as a decorator, context manager, or raw function
+# to control compilation stances like ``force_eager``, ``default``,
+# ``eager_on_recompile``, and "fail_on_recompile." 
+# 
+# For more information, see: `torch.compiler.set_stance API documentation <https://pytorch.org/docs/main/generated/torch.compiler.set_stance.html#torch.compiler.set_stance>`__.
diff --git a/recipes_source/torch_export_aoti_python.py b/recipes_source/torch_export_aoti_python.py
new file mode 100644
index 00000000000..c0cbb7e2800
--- /dev/null
+++ b/recipes_source/torch_export_aoti_python.py
@@ -0,0 +1,276 @@
+# -*- coding: utf-8 -*-
+
+"""
+.. meta::
+   :description: An end-to-end example of how to use AOTInductor for Python runtime.
+   :keywords: torch.export, AOTInductor, torch._inductor.aoti_compile_and_package, aot_compile, torch._export.aoti_load_package
+
+``torch.export`` AOTInductor Tutorial for Python runtime (Beta)
+===============================================================
+**Author:** Ankith Gunapal, Bin Bao, Angela Yi
+"""
+
+######################################################################
+#
+# .. warning::
+#
+#     ``torch._inductor.aoti_compile_and_package`` and
+#     ``torch._inductor.aoti_load_package`` are in Beta status and are subject
+#     to backwards compatibility breaking changes. This tutorial provides an
+#     example of how to use these APIs for model deployment using Python
+#     runtime.
+#
+# It has been shown `previously
+# <https://pytorch.org/docs/stable/torch.compiler_aot_inductor.html#>`__ how
+# AOTInductor can be used to do Ahead-of-Time compilation of PyTorch exported
+# models by creating an artifact that can be run in a non-Python environment.
+# In this tutorial, you will learn an end-to-end example of how to use
+# AOTInductor for Python runtime.
+#
+# **Contents**
+#
+# .. contents::
+#     :local:
+
+######################################################################
+# Prerequisites
+# -------------
+# * PyTorch 2.6 or later
+# * Basic understanding of ``torch.export`` and AOTInductor
+# * Complete the `AOTInductor: Ahead-Of-Time Compilation for Torch.Export-ed Models <https://pytorch.org/docs/stable/torch.compiler_aot_inductor.html#>`_ tutorial
+
+######################################################################
+# What you will learn
+# ----------------------
+# * How to use AOTInductor for Python runtime.
+# * How to use :func:`torch._inductor.aoti_compile_and_package` along with :func:`torch.export.export` to generate a compiled artifact
+# * How to load and run the artifact in a Python runtime using :func:`torch._export.aot_load`.
+# * When to you use AOTInductor with a Python runtime
+
+######################################################################
+# Model Compilation
+# -----------------
+#
+# We will use the TorchVision pretrained ``ResNet18`` model as an example.
+#
+# The first step is to export the model to a graph representation using
+# :func:`torch.export.export`. To learn more about using this function, you can
+# check out the `docs <https://pytorch.org/docs/main/export.html>`_ or the
+# `tutorial <https://pytorch.org/tutorials/intermediate/torch_export_tutorial.html>`_.
+#
+# Once we have exported the PyTorch model and obtained an ``ExportedProgram``,
+# we can apply :func:`torch._inductor.aoti_compile_and_package` to AOTInductor
+# to compile the program to a specified device, and save the generated contents
+# into a ".pt2" artifact.
+#
+# .. note::
+#
+#       This API supports the same available options that :func:`torch.compile`
+#       has, such as ``mode`` and ``max_autotune`` (for those who want to enable
+#       CUDA graphs and leverage Triton based matrix multiplications and
+#       convolutions)
+
+import os
+import torch
+import torch._inductor
+from torchvision.models import ResNet18_Weights, resnet18
+
+model = resnet18(weights=ResNet18_Weights.DEFAULT)
+model.eval()
+
+with torch.inference_mode():
+    inductor_configs = {}
+
+    if torch.cuda.is_available():
+        device = "cuda"
+        inductor_configs["max_autotune"] = True
+    else:
+        device = "cpu"
+
+    model = model.to(device=device)
+    example_inputs = (torch.randn(2, 3, 224, 224, device=device),)
+
+    exported_program = torch.export.export(
+        model,
+        example_inputs,
+    )
+    path = torch._inductor.aoti_compile_and_package(
+        exported_program,
+        package_path=os.path.join(os.getcwd(), "resnet18.pt2"),
+        inductor_configs=inductor_configs
+    )
+
+######################################################################
+# The result of :func:`aoti_compile_and_package` is an artifact "resnet18.pt2"
+# which can be loaded and executed in Python and C++.
+# 
+# The artifact itself contains a bunch of AOTInductor generated code, such as
+# a generated C++ runner file, a shared library compiled from the C++ file, and
+# CUDA binary files, aka cubin files, if optimizing for CUDA.
+# 
+# Structure-wise, the artifact is a structured ``.zip`` file, with the following 
+# specification:
+#
+# .. code::
+#    .
+#    ├── archive_format
+#    ├── version
+#    ├── data
+#    │   ├── aotinductor
+#    │   │   └── model
+#    │   │       ├── xxx.cpp            # AOTInductor generated cpp file
+#    │   │       ├── xxx.so             # AOTInductor generated shared library
+#    │   │       ├── xxx.cubin          # Cubin files (if running on CUDA)
+#    │   │       └── xxx_metadata.json  # Additional metadata to save
+#    │   ├── weights
+#    │   │  └── TBD
+#    │   └── constants
+#    │      └── TBD
+#    └── extra
+#        └── metadata.json
+#
+# We can use the following command to inspect the artifact contents:
+#
+# .. code:: bash
+#
+#    $ unzip -l resnet18.pt2
+#
+# .. code::
+#
+#    Archive:  resnet18.pt2
+#      Length      Date    Time    Name
+#    ---------  ---------- -----   ----
+#            1  01-08-2025 16:40   version
+#            3  01-08-2025 16:40   archive_format
+#        10088  01-08-2025 16:40   data/aotinductor/model/cagzt6akdaczvxwtbvqe34otfe5jlorktbqlojbzqjqvbfsjlge4.cubin
+#        17160  01-08-2025 16:40   data/aotinductor/model/c6oytfjmt5w4c7onvtm6fray7clirxt7q5xjbwx3hdydclmwoujz.cubin
+#        16616  01-08-2025 16:40   data/aotinductor/model/c7ydp7nocyz323hij4tmlf2kcedmwlyg6r57gaqzcsy3huneamu6.cubin
+#        17776  01-08-2025 16:40   data/aotinductor/model/cyqdf46ordevqhiddvpdpp3uzwatfbzdpl3auj2nx23uxvplnne2.cubin
+#        10856  01-08-2025 16:40   data/aotinductor/model/cpzfebfgrusqslui7fxsuoo4tvwulmrxirc5tmrpa4mvrbdno7kn.cubin
+#        14608  01-08-2025 16:40   data/aotinductor/model/c5ukeoz5wmaszd7vczdz2qhtt6n7tdbl3b6wuy4rb2se24fjwfoy.cubin
+#        11376  01-08-2025 16:40   data/aotinductor/model/csu3nstcp56tsjfycygaqsewpu64l5s6zavvz7537cm4s4cv2k3r.cubin
+#        10984  01-08-2025 16:40   data/aotinductor/model/cp76lez4glmgq7gedf2u25zvvv6rksv5lav4q22dibd2zicbgwj3.cubin
+#        14736  01-08-2025 16:40   data/aotinductor/model/c2bb5p6tnwz4elgujqelsrp3unvkgsyiv7xqxmpvuxcm4jfl7pc2.cubin
+#        11376  01-08-2025 16:40   data/aotinductor/model/c6eopmb2b4ngodwsayae4r5q6ni3jlfogfbdk3ypg56tgpzhubfy.cubin
+#        11624  01-08-2025 16:40   data/aotinductor/model/chmwe6lvoekzfowdbiizitm3haiiuad5kdm6sd2m6mv6dkn2zk32.cubin
+#        15632  01-08-2025 16:40   data/aotinductor/model/c3jop5g344hj3ztsu4qm6ibxyaaerlhkzh2e6emak23rxfje6jam.cubin
+#        25472  01-08-2025 16:40   data/aotinductor/model/chaiixybeiuuitm2nmqnxzijzwgnn2n7uuss4qmsupgblfh3h5hk.cubin
+#       139389  01-08-2025 16:40   data/aotinductor/model/cvk6qzuybruhwxtfblzxiov3rlrziv5fkqc4mdhbmantfu3lmd6t.cpp
+#           27  01-08-2025 16:40   data/aotinductor/model/cvk6qzuybruhwxtfblzxiov3rlrziv5fkqc4mdhbmantfu3lmd6t_metadata.json
+#     47195424  01-08-2025 16:40   data/aotinductor/model/cvk6qzuybruhwxtfblzxiov3rlrziv5fkqc4mdhbmantfu3lmd6t.so
+#    ---------                     -------
+#     47523148                     18 files
+
+
+######################################################################
+# Model Inference in Python
+# -------------------------
+#
+# To load and run the artifact in Python, we can use :func:`torch._inductor.aoti_load_package`.
+#
+
+import os
+import torch
+import torch._inductor
+
+model_path = os.path.join(os.getcwd(), "resnet18.pt2")
+
+compiled_model = torch._inductor.aoti_load_package(model_path)
+example_inputs = (torch.randn(2, 3, 224, 224, device=device),)
+
+with torch.inference_mode():
+    output = compiled_model(example_inputs)
+
+
+######################################################################
+# When to use AOTInductor with a Python Runtime
+# ---------------------------------------------
+#
+# There are mainly two reasons why one would use AOTInductor with a Python Runtime:
+#
+# -  ``torch._inductor.aoti_compile_and_package`` generates a singular
+#    serialized artifact. This is useful for model versioning for deployments
+#    and tracking model performance over time.
+# -  With :func:`torch.compile` being a JIT compiler, there is a warmup
+#    cost associated with the first compilation. Your deployment needs to
+#    account for the compilation time taken for the first inference. With
+#    AOTInductor, the compilation is done ahead of time using
+#    ``torch.export.export`` and ``torch._inductor.aoti_compile_and_package``.
+#    At deployment time, after loading the model, running inference does not
+#    have any additional cost.
+#
+#
+# The section below shows the speedup achieved with AOTInductor for first inference
+#
+# We define a utility function ``timed`` to measure the time taken for inference
+#
+
+import time
+def timed(fn):
+    # Returns the result of running `fn()` and the time it took for `fn()` to run,
+    # in seconds. We use CUDA events and synchronization for accurate
+    # measurement on CUDA enabled devices.
+    if torch.cuda.is_available():
+        start = torch.cuda.Event(enable_timing=True)
+        end = torch.cuda.Event(enable_timing=True)
+        start.record()
+    else:
+        start = time.time()
+
+    result = fn()
+    if torch.cuda.is_available():
+        end.record()
+        torch.cuda.synchronize()
+    else:
+        end = time.time()
+
+    # Measure time taken to execute the function in miliseconds
+    if torch.cuda.is_available():
+        duration = start.elapsed_time(end)
+    else:
+        duration = (end - start) * 1000
+
+    return result, duration
+
+
+######################################################################
+# Lets measure the time for first inference using AOTInductor
+
+torch._dynamo.reset()
+
+model = torch._inductor.aoti_load_package(model_path)
+example_inputs = (torch.randn(1, 3, 224, 224, device=device),)
+
+with torch.inference_mode():
+    _, time_taken = timed(lambda: model(example_inputs))
+    print(f"Time taken for first inference for AOTInductor is {time_taken:.2f} ms")
+
+
+######################################################################
+# Lets measure the time for first inference using ``torch.compile``
+
+torch._dynamo.reset()
+
+model = resnet18(weights=ResNet18_Weights.DEFAULT).to(device)
+model.eval()
+
+model = torch.compile(model)
+example_inputs = torch.randn(1, 3, 224, 224, device=device)
+
+with torch.inference_mode():
+    _, time_taken = timed(lambda: model(example_inputs))
+    print(f"Time taken for first inference for torch.compile is {time_taken:.2f} ms")
+
+######################################################################
+# We see that there is a drastic speedup in first inference time using AOTInductor compared
+# to ``torch.compile``
+
+######################################################################
+# Conclusion
+# ----------
+#
+# In this recipe, we have learned how to effectively use the AOTInductor for Python runtime by 
+# compiling and loading a pretrained ``ResNet18`` model. This process
+# demonstrates the practical application of generating a compiled artifact and
+# running it within a Python environment. We also looked at the advantage of using 
+# AOTInductor in model deployments, with regards to speed up in first inference time.
diff --git a/recipes_source/torch_export_challenges_solutions.rst b/recipes_source/torch_export_challenges_solutions.rst
new file mode 100644
index 00000000000..1f8b1ae45a4
--- /dev/null
+++ b/recipes_source/torch_export_challenges_solutions.rst
@@ -0,0 +1,331 @@
+Demonstration of torch.export flow, common challenges and the solutions to address them
+=======================================================================================
+**Authors:** `Ankith Gunapal <https://github.com/agunapal>`__, `Jordi Ramon <https://github.com/JordiFB>`__, `Marcos Carranza <https://github.com/macarran>`__
+
+In the `Introduction to torch.export Tutorial <https://pytorch.org/tutorials/intermediate/torch_export_tutorial.html>`__ , we learned how to use `torch.export <https://pytorch.org/docs/stable/export.html>`__.
+This tutorial expands on the previous one and explores the process of exporting popular models with code, as well as addresses common challenges that may arise with ``torch.export``.
+
+In this tutorial, you will learn how to export models for these use cases:
+
+* Video classifier (`MViT <https://pytorch.org/vision/main/models/video_mvit.html>`__)
+* Automatic Speech Recognition (`OpenAI Whisper-Tiny <https://huggingface.co/openai/whisper-tiny>`__)
+* Image Captioning (`BLIP <https://github.com/salesforce/BLIP>`__)
+* Promptable Image Segmentation (`SAM2 <https://ai.meta.com/sam2/>`__)
+
+Each of the four models were chosen to demonstrate unique features of `torch.export`, as well as some practical considerations
+and issues faced in the implementation.
+
+Prerequisites
+-------------
+
+* PyTorch 2.4 or later
+* Basic understanding of ``torch.export`` and PyTorch Eager inference.
+
+
+Key requirement for ``torch.export``: No graph break
+----------------------------------------------------
+
+`torch.compile <https://pytorch.org/tutorials/intermediate/torch_compile_tutorial.html>`__ speeds up PyTorch code by using JIT to compile PyTorch code into optimized kernels. It optimizes the given model
+using ``TorchDynamo`` and creates an optimized graph , which is then lowered into the hardware using the backend specified in the API.
+When TorchDynamo encounters unsupported Python features, it breaks the computation graph, lets the default Python interpreter
+handle the unsupported code, and then resumes capturing the graph. This break in the computation graph is called a `graph break <https://pytorch.org/tutorials/intermediate/torch_compile_tutorial.html#torchdynamo-and-fx-graphs>`__.
+
+One of the key differences between ``torch.export`` and ``torch.compile`` is that ``torch.export`` doesn’t support graph breaks
+which means that the entire model or part of the model that you are exporting needs to be a single graph. This is because handling graph breaks
+involves interpreting the unsupported operation with default Python evaluation, which is incompatible with what ``torch.export`` is
+designed for. You can read details about the differences between the various PyTorch frameworks in this `link <https://pytorch.org/docs/main/export.html#existing-frameworks>`__
+
+You can identify graph breaks in your program by using the following command:
+
+.. code:: sh
+
+   TORCH_LOGS="graph_breaks" python <file_name>.py
+
+You will need to modify your program to get rid of graph breaks. Once resolved, you are ready to export the model.
+PyTorch runs `nightly benchmarks <https://hud.pytorch.org/benchmark/compilers>`__ for `torch.compile` on popular HuggingFace and TIMM models.
+Most of these models have no graph breaks.
+
+The models in this recipe have no graph breaks, but fail with `torch.export`.
+
+Video Classification
+--------------------
+
+MViT is a class of models based on `MultiScale Vision Transformers <https://arxiv.org/abs/2104.11227>`__. This model has been trained for video classification using the `Kinetics-400 Dataset <https://arxiv.org/abs/1705.06950>`__.
+This model with a relevant dataset can be used for action recognition in the context of gaming.
+
+
+The code below exports MViT by tracing with ``batch_size=2`` and then checks if the ExportedProgram can run with ``batch_size=4``.
+
+.. code:: python
+
+   import numpy as np
+   import torch
+   from torchvision.models.video import MViT_V1_B_Weights, mvit_v1_b
+   import traceback as tb
+
+   model = mvit_v1_b(weights=MViT_V1_B_Weights.DEFAULT)
+
+   # Create a batch of 2 videos, each with 16 frames of shape 224x224x3.
+   input_frames = torch.randn(2,16, 224, 224, 3)
+   # Transpose to get [1, 3, num_clips, height, width].
+   input_frames = np.transpose(input_frames, (0, 4, 1, 2, 3))
+
+   # Export the model.
+   exported_program = torch.export.export(
+       model,
+       (input_frames,),
+   )
+
+   # Create a batch of 4 videos, each with 16 frames of shape 224x224x3.
+   input_frames = torch.randn(4,16, 224, 224, 3)
+   input_frames = np.transpose(input_frames, (0, 4, 1, 2, 3))
+   try:
+       exported_program.module()(input_frames)
+   except Exception:
+       tb.print_exc()
+
+
+Error: Static batch size
+~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. code-block:: sh
+
+       raise RuntimeError(
+   RuntimeError: Expected input at *args[0].shape[0] to be equal to 2, but got 4
+
+
+By default, the exporting flow will trace the program assuming that all input shapes are static, so if you run the program with
+input shapes that are different than the ones you used while tracing, you will run into an error.
+
+Solution
+~~~~~~~~
+
+To address the error, we specify the first dimension of the input (``batch_size``) to be dynamic , specifying the expected range of ``batch_size``.
+In the corrected example shown below, we specify that the expected ``batch_size`` can range from 1 to 16.
+One detail to notice that ``min=2``  is not a bug and is explained in `The 0/1 Specialization Problem <https://docs.google.com/document/d/16VPOa3d-Liikf48teAOmxLc92rgvJdfosIy-yoT38Io/edit?fbclid=IwAR3HNwmmexcitV0pbZm_x1a4ykdXZ9th_eJWK-3hBtVgKnrkmemz6Pm5jRQ#heading=h.ez923tomjvyk>`__. A detailed description of dynamic shapes
+for ``torch.export`` can be found in the export tutorial. The code shown below demonstrates how to export mViT with dynamic batch sizes:
+
+.. code:: python
+
+   import numpy as np
+   import torch
+   from torchvision.models.video import MViT_V1_B_Weights, mvit_v1_b
+   import traceback as tb
+
+
+   model = mvit_v1_b(weights=MViT_V1_B_Weights.DEFAULT)
+
+   # Create a batch of 2 videos, each with 16 frames of shape 224x224x3.
+   input_frames = torch.randn(2,16, 224, 224, 3)
+
+   # Transpose to get [1, 3, num_clips, height, width].
+   input_frames = np.transpose(input_frames, (0, 4, 1, 2, 3))
+
+   # Export the model.
+   batch_dim = torch.export.Dim("batch", min=2, max=16)
+   exported_program = torch.export.export(
+       model,
+       (input_frames,),
+       # Specify the first dimension of the input x as dynamic
+       dynamic_shapes={"x": {0: batch_dim}},
+   )
+
+   # Create a batch of 4 videos, each with 16 frames of shape 224x224x3.
+   input_frames = torch.randn(4,16, 224, 224, 3)
+   input_frames = np.transpose(input_frames, (0, 4, 1, 2, 3))
+   try:
+       exported_program.module()(input_frames)
+   except Exception:
+       tb.print_exc()
+
+
+Automatic Speech Recognition
+---------------
+
+**Automatic Speech Recognition** (ASR) is the use of machine learning to transcribe spoken language into text.
+`Whisper <https://arxiv.org/abs/2212.04356>`__ is a Transformer based encoder-decoder model from OpenAI, which was trained on 680k hours of labelled data for ASR and speech translation.
+The code below tries to export ``whisper-tiny`` model for ASR.
+
+
+.. code:: python
+
+   import torch
+   from transformers import WhisperProcessor, WhisperForConditionalGeneration
+   from datasets import load_dataset
+
+   # load model
+   model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny")
+
+   # dummy inputs for exporting the model
+   input_features = torch.randn(1,80, 3000)
+   attention_mask = torch.ones(1, 3000)
+   decoder_input_ids = torch.tensor([[1, 1, 1 , 1]]) * model.config.decoder_start_token_id
+
+   model.eval()
+
+   exported_program: torch.export.ExportedProgram= torch.export.export(model, args=(input_features, attention_mask, decoder_input_ids,))
+
+
+
+Error: strict tracing with TorchDynamo
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. code:: console
+
+   torch._dynamo.exc.InternalTorchDynamoError: AttributeError: 'DynamicCache' object has no attribute 'key_cache'
+
+
+By default ``torch.export`` traces your code using `TorchDynamo <https://pytorch.org/docs/stable/torch.compiler_dynamo_overview.html>`__, a byte-code analysis engine,  which symbolically analyzes your code and builds a graph.
+This analysis provides a stronger guarantee about safety but not all Python code is supported. When we export the ``whisper-tiny`` model  using the
+default strict mode, it typically returns an error in Dynamo due to an unsupported feature. To understand why this errors in Dynamo, you can refer to this `GitHub issue <https://github.com/pytorch/pytorch/issues/144906>`__.
+
+Solution
+~~~~~~~~
+
+To address the above error , ``torch.export`` supports  the ``non_strict`` mode where the program is traced using the Python interpreter, which works similar to
+PyTorch eager execution. The only difference is that all ``Tensor`` objects will be replaced by ``ProxyTensors``, which will record all their operations into
+a graph. By using ``strict=False``, we are able to export the program.
+
+.. code:: python
+
+   import torch
+   from transformers import WhisperProcessor, WhisperForConditionalGeneration
+   from datasets import load_dataset
+
+   # load model
+   model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny")
+
+   # dummy inputs for exporting the model
+   input_features = torch.randn(1,80, 3000)
+   attention_mask = torch.ones(1, 3000)
+   decoder_input_ids = torch.tensor([[1, 1, 1 , 1]]) * model.config.decoder_start_token_id
+
+   model.eval()
+
+   exported_program: torch.export.ExportedProgram= torch.export.export(model, args=(input_features, attention_mask, decoder_input_ids,), strict=False)
+
+Image Captioning
+----------------
+
+**Image Captioning** is the task of defining the contents of an image in words. In the context of gaming, Image Captioning can be used to enhance the
+gameplay experience by dynamically generating text description of the various game objects in the scene, thereby providing the gamer with additional
+details. `BLIP <https://arxiv.org/pdf/2201.12086>`__ is a popular model for Image Captioning `released by SalesForce Research <https://github.com/salesforce/BLIP>`__. The code below tries to export BLIP with ``batch_size=1``.
+
+
+.. code:: python
+
+   import torch
+   from models.blip import blip_decoder
+
+   device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+   image_size = 384
+   image = torch.randn(1, 3,384,384).to(device)
+   caption_input = ""
+
+   model_url = 'https://storage.googleapis.com/sfr-vision-language-research/BLIP/models/model_base_capfilt_large.pth'
+   model = blip_decoder(pretrained=model_url, image_size=image_size, vit='base')
+   model.eval()
+   model = model.to(device)
+
+   exported_program: torch.export.ExportedProgram= torch.export.export(model, args=(image,caption_input,), strict=False)
+
+
+
+Error: Cannot mutate tensors with frozen storage
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+While exporting a model, it might fail because the model implementation might contain certain Python operations which are not yet supported by ``torch.export``.
+Some of these failures may have a workaround. BLIP is an example where the original model errors, which can be resolved by making a small change in the code.
+``torch.export`` lists the common cases of supported and unsupported operations in `ExportDB <https://pytorch.org/docs/main/generated/exportdb/index.html>`__ and shows how you can modify your code to make it export compatible.
+
+.. code:: console
+
+   File "/BLIP/models/blip.py", line 112, in forward
+       text.input_ids[:,0] = self.tokenizer.bos_token_id
+     File "/anaconda3/envs/export/lib/python3.10/site-packages/torch/_subclasses/functional_tensor.py", line 545, in __torch_dispatch__
+       outs_unwrapped = func._op_dk(
+   RuntimeError: cannot mutate tensors with frozen storage
+
+
+
+Solution
+~~~~~~~~
+
+Clone the `tensor <https://github.com/salesforce/BLIP/blob/main/models/blip.py#L112>`__ where export fails.
+
+.. code:: python
+
+   text.input_ids = text.input_ids.clone() # clone the tensor
+   text.input_ids[:,0] = self.tokenizer.bos_token_id
+
+.. note::
+   This constraint has been relaxed in PyTorch 2.7 nightlies. This should work out-of-the-box in PyTorch 2.7
+
+Promptable Image Segmentation
+-----------------------------
+
+**Image segmentation** is a computer vision technique that divides a digital image into distinct groups of pixels, or segments, based on their characteristics.
+`Segment Anything Model (SAM) <https://ai.meta.com/blog/segment-anything-foundation-model-image-segmentation/>`__) introduced promptable image segmentation, which predicts object masks given prompts that indicate the desired object. `SAM 2 <https://ai.meta.com/sam2/>`__ is
+the first unified model for segmenting objects across images and videos. The `SAM2ImagePredictor <https://github.com/facebookresearch/sam2/blob/main/sam2/sam2_image_predictor.py#L20>`__ class provides an easy interface to the model for prompting
+the model. The model can take as input both point and box prompts, as well as masks from the previous iteration of prediction. Since SAM2 provides strong
+zero-shot performance for object tracking, it can be used for tracking game objects in a scene.
+
+
+The tensor operations in the predict method of `SAM2ImagePredictor <https://github.com/facebookresearch/sam2/blob/main/sam2/sam2_image_predictor.py#L20>`__  are happening in the `_predict <https://github.com/facebookresearch/sam2/blob/main/sam2/sam2_image_predictor.py#L291>`__ method. So, we try to export like this.
+
+.. code:: python
+
+   ep = torch.export.export(
+       self._predict,
+       args=(unnorm_coords, labels, unnorm_box, mask_input, multimask_output),
+       kwargs={"return_logits": return_logits},
+       strict=False,
+   )
+
+
+Error: Model is not of type ``torch.nn.Module``
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+``torch.export`` expects the module to be of type ``torch.nn.Module``. However, the module we are trying to export is a class method. Hence it errors.
+
+.. code:: console
+
+   Traceback (most recent call last):
+     File "/sam2/image_predict.py", line 20, in <module>
+       masks, scores, _ = predictor.predict(
+     File "/sam2/sam2/sam2_image_predictor.py", line 312, in predict
+       ep = torch.export.export(
+     File "python3.10/site-packages/torch/export/__init__.py", line 359, in export
+       raise ValueError(
+   ValueError: Expected `mod` to be an instance of `torch.nn.Module`, got <class 'method'>.
+
+
+Solution
+~~~~~~~~
+
+We write a helper class, which inherits from ``torch.nn.Module`` and call the ``_predict method`` in the ``forward`` method of the class. The complete code can be found `here <https://github.com/anijain2305/sam2/blob/ued/sam2/sam2_image_predictor.py#L293-L311>`__.
+
+.. code:: python
+
+   class ExportHelper(torch.nn.Module):
+       def __init__(self):
+           super().__init__()
+
+       def forward(_, *args, **kwargs):
+           return self._predict(*args, **kwargs)
+
+    model_to_export = ExportHelper()
+    ep = torch.export.export(
+         model_to_export,
+         args=(unnorm_coords, labels, unnorm_box, mask_input,  multimask_output),
+         kwargs={"return_logits": return_logits},
+         strict=False,
+         )
+
+Conclusion
+----------
+
+In this tutorial, we have learned how to use ``torch.export`` to export models for popular use cases by addressing challenges through correct configuration and simple code modifications.
+Once you are able to export a model, you can lower the ``ExportedProgram`` into your hardware using `AOTInductor <https://pytorch.org/docs/stable/torch.compiler_aot_inductor.html>`__ in case of servers and `ExecuTorch <https://pytorch.org/executorch/stable/index.html>`__ in case of edge device.
+To learn more about ``AOTInductor`` (AOTI), please refer to the `AOTI tutorial <https://pytorch.org/tutorials/recipes/torch_export_aoti_python.html>`__.
+To learn more about ``ExecuTorch`` , please refer to the `ExecuTorch tutorial <https://pytorch.org/executorch/stable/tutorials/export-to-executorch-tutorial.html>`__.
diff --git a/recipes_source/torch_logs.py b/recipes_source/torch_logs.py
new file mode 100644
index 00000000000..b5c3f0bd8ac
--- /dev/null
+++ b/recipes_source/torch_logs.py
@@ -0,0 +1,96 @@
+"""
+(beta) Using TORCH_LOGS python API with torch.compile
+==========================================================================================
+**Author:** `Michael Lazos <https://github.com/mlazos>`_
+"""
+
+import logging
+
+######################################################################
+#
+# This tutorial introduces the ``TORCH_LOGS`` environment variable, as well as the Python API, and
+# demonstrates how to apply it to observe the phases  of ``torch.compile``.
+#
+# .. note::
+#
+#   This tutorial requires PyTorch 2.2.0 or later.
+#
+#
+
+
+######################################################################
+# Setup
+# ~~~~~~~~~~~~~~~~~~~~~
+# In this example, we'll set up a simple Python function which performs an elementwise
+# add and observe the compilation process with ``TORCH_LOGS`` Python API.
+#
+# .. note::
+#
+#   There is also an environment variable ``TORCH_LOGS``, which can be used to
+#   change logging settings at the command line. The equivalent environment
+#   variable setting is shown for each example.
+
+import torch
+
+# exit cleanly if we are on a device that doesn't support torch.compile
+if torch.cuda.get_device_capability() < (7, 0):
+    print("Skipping because torch.compile is not supported on this device.")
+else:
+    @torch.compile()
+    def fn(x, y):
+        z = x + y
+        return z + 2
+
+
+    inputs = (torch.ones(2, 2, device="cuda"), torch.zeros(2, 2, device="cuda"))
+
+
+# print separator and reset dynamo
+# between each example
+    def separator(name):
+        print(f"==================={name}=========================")
+        torch._dynamo.reset()
+
+
+    separator("Dynamo Tracing")
+# View dynamo tracing
+# TORCH_LOGS="+dynamo"
+    torch._logging.set_logs(dynamo=logging.DEBUG)
+    fn(*inputs)
+
+    separator("Traced Graph")
+# View traced graph
+# TORCH_LOGS="graph"
+    torch._logging.set_logs(graph=True)
+    fn(*inputs)
+
+    separator("Fusion Decisions")
+# View fusion decisions
+# TORCH_LOGS="fusion"
+    torch._logging.set_logs(fusion=True)
+    fn(*inputs)
+
+    separator("Output Code")
+# View output code generated by inductor
+# TORCH_LOGS="output_code"
+    torch._logging.set_logs(output_code=True)
+    fn(*inputs)
+
+    separator("")
+
+######################################################################
+# Conclusion
+# ~~~~~~~~~~
+#
+# In this tutorial we introduced the TORCH_LOGS environment variable and python API
+# by experimenting with a small number of the available logging options.
+# To view descriptions of all available options, run any python script
+# which imports torch and set TORCH_LOGS to "help".
+#
+# Alternatively, you can view the `torch._logging documentation`_ to see
+# descriptions of all available logging options.
+#
+# For more information on torch.compile, see the `torch.compile tutorial`_.
+#
+# .. _torch._logging documentation: https://pytorch.org/docs/main/logging.html
+# .. _torch.compile tutorial: https://pytorch.org/tutorials/intermediate/torch_compile_tutorial.html
diff --git a/recipes_source/torchscript_inference.rst b/recipes_source/torchscript_inference.rst
new file mode 100644
index 00000000000..01bc497d38e
--- /dev/null
+++ b/recipes_source/torchscript_inference.rst
@@ -0,0 +1,6 @@
+..
+  TODO(gmagogsfm): Replace/delete this document by 2.9 release. https://github.com/pytorch/tutorials/issues/3456
+
+.. warning::
+    TorchScript is deprecated, please use 
+    `torch.export <https://docs.pytorch.org/tutorials/intermediate/torch_export_tutorial.html>`__ instead.
\ No newline at end of file
diff --git a/recipes_source/xeon_run_cpu.rst b/recipes_source/xeon_run_cpu.rst
new file mode 100644
index 00000000000..9ff14be08e3
--- /dev/null
+++ b/recipes_source/xeon_run_cpu.rst
@@ -0,0 +1,363 @@
+Optimizing CPU Performance on Intel® Xeon® with run_cpu Script
+======================================================================
+
+There are several configuration options that can impact the performance of PyTorch inference when executed on Intel® Xeon® Scalable Processors.
+To get peak performance, the ``torch.backends.xeon.run_cpu`` script is provided that optimizes the configuration of thread and memory management.
+For thread management, the script configures thread affinity and the preload of Intel® OMP library.
+For memory management, it configures NUMA binding and preloads optimized memory allocation libraries, such as TCMalloc and JeMalloc.
+In addition, the script provides tunable parameters for compute resource allocation in both single instance and multiple instance scenarios,
+helping the users try out an optimal coordination of resource utilization for the specific workloads.
+
+What You Will Learn
+-------------------
+
+* How to utilize tools like ``numactl``, ``taskset``, Intel® OpenMP Runtime Library and optimized memory
+  allocators such as ``TCMalloc`` and ``JeMalloc`` for enhanced performance.
+* How to configure CPU resources and memory management to maximize PyTorch inference performance on Intel® Xeon® processors.
+
+Introduction of the Optimizations
+---------------------------------
+
+Applying NUMA Access Control
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+It is beneficial that an increasing number of CPU cores are being provided to users within a single socket, as this offers greater computational resources.
+However, this also leads to competition for memory access, which can cause programs to stall due to busy memory.
+To address this problem, Non-Uniform Memory Access (NUMA) was introduced.
+Unlike Uniform Memory Access (UMA), where all memories are equally accessible to all cores,
+NUMA organizes memory into multiple groups. Certain number of memories are directly attached to one socket's integrated memory controller to become local memory of this socket.
+Local memory access is much faster than remote memory access.
+
+Users can get CPU information with ``lscpu`` command on Linux to learn how many cores and sockets are there on the machine.
+Additionally, this command provides NUMA information, such as the distribution of CPU cores.
+Below is an example of executing  ``lscpu`` on a machine equipped with an Intel® Xeon® CPU Max 9480:
+
+.. code-block:: console
+
+   $ lscpu
+   ...
+   CPU(s):                  224
+     On-line CPU(s) list:   0-223
+   Vendor ID:               GenuineIntel
+     Model name:            Intel (R) Xeon (R) CPU Max 9480
+       CPU family:          6
+       Model:               143
+       Thread(s) per core:  2
+       Core(s) per socket:  56
+       Socket(s):           2
+   ...
+   NUMA:
+     NUMA node(s):          2
+     NUMA node0 CPU(s):     0-55,112-167
+     NUMA node1 CPU(s):     56-111,168-223
+   ...
+
+* Two sockets were detected, each containing 56 physical cores. With Hyper-Threading enabled, each core can handle 2 threads, resulting in 56 logical cores per socket. Therefore, the machine has a total of 224 CPU cores in service.
+* Typically, physical cores are indexed before logical cores. In this scenario, cores 0-55 are the physical cores on the first NUMA node, and cores 56-111 are the physical cores on the second NUMA node.
+* Logical cores are indexed subsequently: cores 112-167 correspond to the logical cores on the first NUMA node, and cores 168-223 to those on the second NUMA node.
+
+Typically, running PyTorch programs with compute intense workloads should avoid using logical cores to get good performance.
+
+Linux provides a tool called ``numactl`` that allows user control of NUMA policy for processes or shared memory.
+It runs processes with a specific NUMA scheduling or memory placement policy.
+As described above, cores share high-speed cache in one socket, thus it is a good idea to avoid cross socket computations.
+From a memory access perspective, bounding memory access locally is much faster than accessing remote memories.
+``numactl`` command should have been installed in recent Linux distributions. In case it is missing, you can install it manually with the installation command, like on Ubuntu:
+
+.. code-block:: console
+
+   $ apt-get install numactl
+
+on CentOS you can run the following command:
+
+.. code-block:: console
+
+   $ yum install numactl
+
+The ``taskset`` command in Linux is another powerful utility that allows you to set or retrieve the CPU affinity of a running process.
+``taskset`` are pre-installed in most Linux distributions and in case it's not, on Ubuntu you can install it with the command:
+
+.. code-block:: console
+
+   $ apt-get install util-linux
+
+on CentOS you can run the following command:
+
+.. code-block:: console
+
+   $ yum install util-linux
+
+Using Intel® OpenMP Runtime Library
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+OpenMP is an implementation of multithreading, a method of parallelizing where a primary thread (a series of instructions executed consecutively) forks a specified number of sub-threads and the system divides a task among them. The threads then run concurrently, with the runtime environment allocating threads to different processors.
+Users can control OpenMP behaviors with some environment variable settings to fit for their workloads, the settings are read and executed by OMP libraries. By default, PyTorch uses GNU OpenMP Library (GNU libgomp) for parallel computation. On Intel® platforms, Intel® OpenMP Runtime Library (libiomp) provides OpenMP API specification support. It usually brings more performance benefits compared to libgomp.
+
+The Intel® OpenMP Runtime Library can be installed using one of these commands:
+
+.. code-block:: console
+
+   $ pip install intel-openmp
+
+or
+
+.. code-block:: console
+
+   $ conda install mkl
+
+Choosing an Optimized Memory Allocator
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Memory allocator plays an important role from performance perspective as well. A more efficient memory usage reduces overhead on unnecessary memory allocations or destructions, and thus results in a faster execution. From practical experiences, for deep learning workloads, ``TCMalloc`` or ``JeMalloc`` can get better performance by reusing memory as much as possible than default malloc operations.
+
+You can install ``TCMalloc`` by running the following command on Ubuntu:
+
+.. code-block:: console
+
+   $ apt-get install google-perftools
+
+On CentOS, you can install it by running:
+
+.. code-block:: console
+
+   $ yum install gperftools
+
+In a conda environment, it can also be installed by running:
+
+.. code-block:: console
+
+   $ conda install conda-forge::gperftools
+
+On Ubuntu ``JeMalloc`` can be installed by this command:
+
+.. code-block:: console
+
+   $ apt-get install libjemalloc2
+
+On CentOS it can be installed by running:
+
+.. code-block:: console
+
+   $ yum install jemalloc
+
+In a conda environment, it can also be installed by running:
+
+.. code-block:: console
+
+   $ conda install conda-forge::jemalloc
+
+Quick Start Example Commands
+----------------------------
+
+1. To run single-instance inference with 1 thread on 1 CPU core (only Core #0 would be used):
+
+.. code-block:: console
+
+   $ python -m torch.backends.xeon.run_cpu --ninstances 1 --ncores-per-instance 1 <program.py> [program_args]
+
+2. To run single-instance inference on a single CPU node (NUMA socket):
+
+.. code-block:: console
+
+   $ python -m torch.backends.xeon.run_cpu --node-id 0 <program.py> [program_args]
+
+3. To run multi-instance inference, 8 instances with 14 cores per instance on a 112-core CPU:
+
+.. code-block:: console
+
+   $ python -m torch.backends.xeon.run_cpu --ninstances 8 --ncores-per-instance 14 <program.py> [program_args]
+
+4. To run inference in throughput mode, in which all the cores in each CPU node set up an instance:
+
+.. code-block:: console
+
+   $ python -m torch.backends.xeon.run_cpu --throughput-mode <program.py> [program_args]
+
+.. note::
+
+   Term "instance" here doesn't refer to a cloud instance. This script is executed as a single process which invokes multiple "instances" which are formed from multiple threads. "Instance" is kind of group of threads in this context.
+
+Using ``torch.backends.xeon.run_cpu``
+-------------------------------------
+
+The argument list and usage guidance can be shown with the following command:
+
+.. code-block:: console
+
+   $ python -m torch.backends.xeon.run_cpu –h
+   usage: run_cpu.py [-h] [--multi-instance] [-m] [--no-python] [--enable-tcmalloc] [--enable-jemalloc] [--use-default-allocator] [--disable-iomp] [--ncores-per-instance] [--ninstances] [--skip-cross-node-cores] [--rank] [--latency-mode] [--throughput-mode] [--node-id] [--use-logical-core] [--disable-numactl] [--disable-taskset] [--core-list] [--log-path] [--log-file-prefix] <program> [program_args]
+
+The command above has the following positional arguments:
+
+.. list-table::
+   :widths: 25 50
+   :header-rows: 1
+
+   * - knob
+     - help
+   * - ``program``
+     - The full path of the program/script to be launched.
+   * - ``program_args``
+     - The input arguments for the program/script to be launched.
+
+Explanation of the options
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The generic option settings (knobs) include the following:
+
+.. list-table::
+   :widths: 25 10 15 50
+   :header-rows: 1
+
+   * - knob
+     - type
+     - default value
+     - help
+   * - ``-h``, ``--help``
+     - 
+     - 
+     - To show the help message and exit.
+   * - ``-m``, ``--module``
+     - 
+     - 
+     - To change each process to interpret the launch script as a python module, executing with the same behavior as "python -m".
+   * - ``--no-python``
+     - bool
+     - False
+     - To avoid prepending the program with "python" - just execute it directly. Useful when the script is not a Python script.
+   * - ``--log-path``
+     - str
+     - ``''``
+     - To specify the log file directory. Default path is ``''``, which means disable logging to files.
+   * - ``--log-file-prefix``
+     - str
+     - "run"
+     - Prefix of the log file name.
+
+Knobs for applying or disabling optimizations are:
+
+.. list-table::
+   :widths: 25 10 15 50
+   :header-rows: 1
+
+   * - knob
+     - type
+     - default value
+     - help
+   * - ``--enable-tcmalloc``
+     - bool
+     - False
+     - To enable ``TCMalloc`` memory allocator.
+   * - ``--enable-jemalloc``
+     - bool
+     - False
+     - To enable ``JeMalloc`` memory allocator.
+   * - ``--use-default-allocator``
+     - bool
+     - False
+     - To use default memory allocator. Neither ``TCMalloc`` nor ``JeMalloc`` would be used.
+   * - ``--disable-iomp``
+     - bool
+     - False
+     - By default, Intel® OpenMP lib will be used if installed. Setting this flag would disable the usage of Intel® OpenMP.
+
+.. note::
+
+   Memory allocators influence performance. If the user does not specify a desired memory allocator, the ``run_cpu`` script will search if any of them is installed in the order of TCMalloc > JeMalloc > PyTorch default memory allocator, and takes the first matched one.
+
+Knobs for controlling instance number and compute resource allocation are:
+
+.. list-table::
+   :widths: 25 10 15 50
+   :header-rows: 1
+
+   * - knob
+     - type
+     - default value
+     - help
+   * - ``--ninstances``
+     - int
+     - 0
+     - Number of instances.
+   * - ``--ncores-per-instance``
+     - int
+     - 0
+     - Number of cores used by each instance.
+   * - ``--node-id``
+     - int
+     - -1
+     - The node ID to be used for multi-instance, by default all nodes will be used.
+   * - ``--core-list``
+     - str
+     - ``''``
+     - To specify the core list as ``'core_id, core_id, ....'`` or core range as ``'core_id-core_id'``. By dafault all the cores will be used.
+   * - ``--use-logical-core``
+     - bool
+     - False
+     - By default only physical cores are used. Specifying this flag enables logical cores usage.
+   * - ``--skip-cross-node-cores``
+     - bool
+     - False
+     - To prevent the workload to be executed on cores across NUMA nodes.
+   * - ``--rank``
+     - int
+     - -1
+     - To specify instance index to assign ncores_per_instance for rank; otherwise ncores_per_instance will be assigned sequentially to the instances.
+   * - ``--multi-instance``
+     - bool
+     - False
+     - A quick set to invoke multiple instances of the workload on multi-socket CPU servers.
+   * - ``--latency-mode``
+     - bool
+     - False
+     - A quick set to invoke benchmarking with latency mode, in which all physical cores are used and 4 cores per instance.
+   * - ``--throughput-mode``
+     - bool
+     - False
+     - A quick set to invoke benchmarking with throughput mode, in which all physical cores are used and 1 numa node per instance.
+   * - ``--disable-numactl``
+     - bool
+     - False
+     - By default ``numactl`` command is used to control NUMA access. Setting this flag will disable it.
+   * - ``--disable-taskset``
+     - bool
+     - False
+     - To disable the usage of ``taskset`` command.
+	 
+.. note::
+
+   Environment variables that will be set by this script include the following:
+
+   .. list-table::
+      :widths: 25 50
+      :header-rows: 1
+
+      * - Environment Variable
+        - Value
+      * - LD_PRELOAD
+        - Depending on knobs you set, <lib>/libiomp5.so, <lib>/libjemalloc.so, <lib>/libtcmalloc.so might be appended to LD_PRELOAD.
+      * - KMP_AFFINITY
+        - If libiomp5.so is preloaded, KMP_AFFINITY could be set to ``"granularity=fine,compact,1,0"``.
+      * - KMP_BLOCKTIME
+        - If libiomp5.so is preloaded, KMP_BLOCKTIME is set to "1".
+      * - OMP_NUM_THREADS
+        - Value of ``ncores_per_instance``
+      * - MALLOC_CONF
+        - If libjemalloc.so is preloaded, MALLOC_CONF will be set to ``"oversize_threshold:1,background_thread:true,metadata_thp:auto"``.
+		
+   Please note that the script respects environment variables set preliminarily. For example, if you have set the environment variables mentioned above before running the script, the values of the variables will not be overwritten by the script.
+
+Conclusion
+----------
+
+In this tutorial, we explored a variety of advanced configurations and tools designed to optimize PyTorch inference performance on Intel® Xeon® Scalable Processors. 
+By leveraging the ``torch.backends.xeon.run_cpu`` script, we demonstrated how to fine-tune thread and memory management to achieve peak performance.
+We covered essential concepts such as NUMA access control, optimized memory allocators like ``TCMalloc`` and ``JeMalloc``, and the use of Intel® OpenMP for efficient multithreading.
+
+Additionally, we provided practical command-line examples to guide you through setting up single and multiple instance scenarios, ensuring optimal resource utilization tailored to specific workloads.
+By understanding and applying these techniques, users can significantly enhance the efficiency and speed of their PyTorch applications on Intel® Xeon® platforms.
+
+See also:
+
+* `PyTorch Performance Tuning Guide <https://pytorch.org/tutorials/recipes/recipes/tuning_guide.html#cpu-specific-optimizations>`__
+* `PyTorch Multiprocessing Best Practices <https://pytorch.org/docs/stable/notes/multiprocessing.html#cpu-in-multiprocessing>`__
diff --git a/recipes_source/zero_redundancy_optimizer.rst b/recipes_source/zero_redundancy_optimizer.rst
new file mode 100644
index 00000000000..bfc076d58e7
--- /dev/null
+++ b/recipes_source/zero_redundancy_optimizer.rst
@@ -0,0 +1,154 @@
+Shard Optimizer States with ZeroRedundancyOptimizer
+===================================================
+
+In this recipe, you will learn:
+
+- The high-level idea of `ZeroRedundancyOptimizer <https://pytorch.org/docs/master/distributed.optim.html>`__.
+- How to use `ZeroRedundancyOptimizer <https://pytorch.org/docs/master/distributed.optim.html>`__
+  in distributed training and its impact.
+
+
+Requirements
+------------
+
+- PyTorch 1.8+
+- `Getting Started With Distributed Data Parallel <https://pytorch.org/tutorials/intermediate/ddp_tutorial.html>`_
+
+
+What is ``ZeroRedundancyOptimizer``?
+------------------------------------
+
+The idea of `ZeroRedundancyOptimizer <https://pytorch.org/docs/master/distributed.optim.html>`__
+comes from `DeepSpeed/ZeRO project <https://github.com/microsoft/DeepSpeed>`_ and
+`Marian <https://github.com/marian-nmt/marian-dev>`_ that shard
+optimizer states across distributed data-parallel processes to
+reduce per-process memory footprint. In the
+`Getting Started With Distributed Data Parallel <https://pytorch.org/tutorials/intermediate/ddp_tutorial.html>`_
+tutorial, we have shown how to use
+`DistributedDataParallel <https://pytorch.org/docs/stable/generated/torch.nn.parallel.DistributedDataParallel.html>`_
+(DDP) to train models. In that tutorial, each process keeps a dedicated replica
+of the optimizer. Since DDP has already synchronized gradients in the
+backward pass, all optimizer replicas will operate on the same parameter and
+gradient values in every iteration, and this is how DDP keeps model replicas in
+the same state. Oftentimes, optimizers also maintain local states. For example,
+the ``Adam`` optimizer uses per-parameter ``exp_avg`` and ``exp_avg_sq`` states. As a
+result, the ``Adam`` optimizer's memory consumption is at least twice the model
+size. Given this observation, we can reduce the optimizer memory footprint by
+sharding optimizer states across DDP processes. More specifically, instead of
+creating per-param states for all parameters, each optimizer instance in
+different DDP processes only keeps optimizer states for a shard of all model
+parameters. The optimizer ``step()`` function only updates the parameters in its
+shard and then broadcasts its updated parameters to all other peer DDP
+processes, so that all model replicas still land in the same state.
+
+How to use ``ZeroRedundancyOptimizer``?
+---------------------------------------
+
+The code below demonstrates how to use
+`ZeroRedundancyOptimizer <https://pytorch.org/docs/master/distributed.optim.html>`__.
+The majority of the code is similar to the simple DDP example presented in
+`Distributed Data Parallel notes <https://pytorch.org/docs/stable/notes/ddp.html>`_.
+The main difference is the ``if-else`` clause in the ``example`` function which
+wraps optimizer constructions, toggling between
+`ZeroRedundancyOptimizer <https://pytorch.org/docs/master/distributed.optim.html>`__
+and ``Adam`` optimizer.
+
+
+::
+
+    import os
+    import torch
+    import torch.distributed as dist
+    import torch.multiprocessing as mp
+    import torch.nn as nn
+    import torch.optim as optim
+    from torch.distributed.optim import ZeroRedundancyOptimizer
+    from torch.nn.parallel import DistributedDataParallel as DDP
+
+    def print_peak_memory(prefix, device):
+        if device == 0:
+            print(f"{prefix}: {torch.cuda.max_memory_allocated(device) // 1e6}MB ")
+
+    def example(rank, world_size, use_zero):
+        torch.manual_seed(0)
+        torch.cuda.manual_seed(0)
+        os.environ['MASTER_ADDR'] = 'localhost'
+        os.environ['MASTER_PORT'] = '29500'
+        # create default process group
+        dist.init_process_group("gloo", rank=rank, world_size=world_size)
+
+        # create local model
+        model = nn.Sequential(*[nn.Linear(2000, 2000).to(rank) for _ in range(20)])
+        print_peak_memory("Max memory allocated after creating local model", rank)
+
+        # construct DDP model
+        ddp_model = DDP(model, device_ids=[rank])
+        print_peak_memory("Max memory allocated after creating DDP", rank)
+
+        # define loss function and optimizer
+        loss_fn = nn.MSELoss()
+        if use_zero:
+            optimizer = ZeroRedundancyOptimizer(
+                ddp_model.parameters(),
+                optimizer_class=torch.optim.Adam,
+                lr=0.01
+            )
+        else:
+            optimizer = torch.optim.Adam(ddp_model.parameters(), lr=0.01)
+
+        # forward pass
+        outputs = ddp_model(torch.randn(20, 2000).to(rank))
+        labels = torch.randn(20, 2000).to(rank)
+        # backward pass
+        loss_fn(outputs, labels).backward()
+
+        # update parameters
+        print_peak_memory("Max memory allocated before optimizer step()", rank)
+        optimizer.step()
+        print_peak_memory("Max memory allocated after optimizer step()", rank)
+
+        print(f"params sum is: {sum(model.parameters()).sum()}")
+
+
+
+    def main():
+        world_size = 2
+        print("=== Using ZeroRedundancyOptimizer ===")
+        mp.spawn(example,
+            args=(world_size, True),
+            nprocs=world_size,
+            join=True)
+
+        print("=== Not Using ZeroRedundancyOptimizer ===")
+        mp.spawn(example,
+            args=(world_size, False),
+            nprocs=world_size,
+            join=True)
+
+    if __name__=="__main__":
+        main()
+
+The output is shown below. When enabling ``ZeroRedundancyOptimizer`` with ``Adam``,
+the optimizer ``step()`` peak memory consumption is half of vanilla ``Adam``'s
+memory consumption. This agrees with our expectation, as we are sharding
+``Adam`` optimizer states across two processes. The output also shows that, with
+``ZeroRedundancyOptimizer``, the model parameters still end up with the same
+values after one iterations (the parameters sum is the same with and without
+``ZeroRedundancyOptimizer``).
+
+::
+
+    === Using ZeroRedundancyOptimizer ===
+    Max memory allocated after creating local model: 335.0MB
+    Max memory allocated after creating DDP: 656.0MB
+    Max memory allocated before optimizer step(): 992.0MB
+    Max memory allocated after optimizer step(): 1361.0MB
+    params sum is: -3453.6123046875
+    params sum is: -3453.6123046875
+    === Not Using ZeroRedundancyOptimizer ===
+    Max memory allocated after creating local model: 335.0MB
+    Max memory allocated after creating DDP: 656.0MB
+    Max memory allocated before optimizer step(): 992.0MB
+    Max memory allocated after optimizer step(): 1697.0MB
+    params sum is: -3453.6123046875
+    params sum is: -3453.6123046875
diff --git a/redirects.py b/redirects.py
new file mode 100644
index 00000000000..1ffa68e6b85
--- /dev/null
+++ b/redirects.py
@@ -0,0 +1,54 @@
+redirects = {
+    "advanced/cpp_extension.html": "https://docs.pytorch.org/tutorials/advanced/custom_ops_landing_page.html",
+    "advanced/cpp_cuda_graphs.html": "../index.html",
+    "advanced/dynamic_quantization_tutorial.html": "../index.html",
+    "advanced/static_quantization_tutorial.html": "../index.html",
+    "advanced/super_resolution_with_onnxruntime.html": "../index.html",
+    "advanced/torch_script_custom_classes": "../index.html",
+    "advanced_source/static_quantization_tutorial.rst": "../index.html",
+    "beginner/Intro_to_TorchScript_tutorial.html": "../index.html",
+    "beginner/deploy_seq2seq_hybrid_frontend_tutorial.html": "../index.html",
+    "beginner/hybrid_frontend_tutorial": "../index.html",
+    "beginner/hybrid_frontend/learning_hybrid_frontend_through_example_tutorial.html": "../../index.html",
+    "beginner/flava_finetuning_tutorial.html": "../index.html",
+    "beginner/ptcheat.html": "../index.html",
+    "intermediate/FSDP_adavnced_tutorial.html": "https://docs.pytorch.org/tutorials/intermediate/FSDP_advanced_tutorial.html",
+    "intermediate/dynamic_quantization_bert_tutorial.html": "../index.html",
+    "intermediate/flask_rest_api_tutorial": "../index.html",
+    "intermediate/quantized_transfer_learning_tutorial.html": "../index.html",
+    "intermediate/torchserve_with_ipex.html": "../index.html",
+    "intermediate/torchserve_with_ipex_2.html": "../index.html",
+    "intermediate/tiatoolbox_tutorial.html": "../index.html",
+    "prototype/backend_config_tutorial.html": "../index.html",
+    "prototype/flight_recorder_tutorial.html": "https://docs.pytorch.org/tutorials/unstable/flight_recorder_tutorial.html",
+    "prototype/fx_graph_mode_ptq_dynamic.html": "../index.html",
+    "prototype/fx_graph_mode_ptq_static.html": "../index.html",
+    "prototype/fx_graph_mode_quant_guide.html": "../index.html",
+    "prototype/graph_mode_dynamic_bert_tutorial.html": "../index.html",
+    "prototype/inductor_windows.html": "https://pytorch.org/tutorials/unstable/inductor_windows.html",
+    "prototype/numeric_suite_tutorial.html": "../index.html",
+    "prototype/openvino_quantizer.html": "https://docs.pytorch.org/ao/main/tutorials_source/pt2e_quant_openvino_inductor.html",
+    "prototype/pt2e_quant_ptq.html": "https://docs.pytorch.org/ao/main/tutorials_source/pt2e_quant_ptq.html",
+    "prototype/pt2e_quant_ptq_x86_inductor.html": "https://docs.pytorch.org/ao/main/tutorials_source/pt2e_quant_x86_inductor.html",
+    "prototype/pt2e_quant_qat.html": "https://docs.pytorch.org/ao/main/tutorials_source/pt2e_quant_qat.html",
+    "prototype/pt2e_quant_x86_inductor.html": "https://docs.pytorch.org/ao/main/tutorials_source/pt2e_quant_x86_inductor.html",
+    "prototype/pt2e_quant_xpu_inductor.html": "https://docs.pytorch.org/ao/main/tutorials_source/pt2e_quant_xpu_inductor.html",
+    "prototype/pt2e_quantizer.html": "https://docs.pytorch.org/ao/main/tutorials_source/pt2e_quantizer.html",
+    "prototype/quantization_in_pytorch_2_0_export_tutorial.html": "../index.html",
+    "prototype/torchscript_freezing.html": "../index.html",
+    "recipes_source/cuda_rpc.rst": "../index.html",
+    "receipes/fuse.html": "../index.html",
+    "receipes/quantization.html": "../index.html",
+    "receipes/receipes/dynamic_quantization.html": "../index.html",
+    "recipes/bundled_inputs.html": "../index.html",
+    "recipes/inference_tuning_on_aws_graviton.html": "../index.html",
+    "recipes/recipes_index.html": "../recipes_index.html",
+    "recipes/intel_extension_for_pytorch.html": "../index.html",
+    "recipes/torch_compile_backend_ipex.html": "../index.html",
+    "recipes/torchserve_vertexai_tutorial.html": "../index.html",
+    "recipes/amx.html": "../index.html",
+    "unstable_source/vulkan_workflow.rst": "../index.html",
+    "unstable/semi_structured_sparse.html": "https://docs.pytorch.org/tutorials/advanced/semi_structured_sparse.html",
+    "unstable/skip_param_init.html": "https://docs.pytorch.org/tutorials/recipes/recipes/module_load_state_dict_tips.html",
+    "unstable_source/backend_config_tutorial.rst": "../index.html",
+}
diff --git a/requirements.txt b/requirements.txt
deleted file mode 100644
index 7d74d4d845e..00000000000
--- a/requirements.txt
+++ /dev/null
@@ -1,25 +0,0 @@
-# Refer to ./jenkins/build.sh for tutorial build instructions 
-
-sphinx
-sphinx-gallery
-tqdm
-numpy
-matplotlib
-torch
-torchvision
-PyHamcrest
-bs4
-awscli==1.16.35
-
-# PyTorch Theme
--e git+git://github.com/pytorch/pytorch_sphinx_theme.git#egg=pytorch_sphinx_theme
-
-ipython
-
-# to run examples
-pandas
-scikit-image
-# pillow >= 4.2 will throw error when trying to write mode RGBA as JPEG,
-# this is a workaround to the issue.
-pillow==4.1.1
-wget
diff --git a/requirements.txt b/requirements.txt
new file mode 120000
index 00000000000..72b541c1ebf
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1 @@
+.ci/docker/requirements.txt
\ No newline at end of file
diff --git a/runtime.txt b/runtime.txt
index d70c8f8d89f..cc1923a40b1 100644
--- a/runtime.txt
+++ b/runtime.txt
@@ -1 +1 @@
-3.6
+3.8
diff --git a/src/pytorch-sphinx-theme b/src/pytorch-sphinx-theme
deleted file mode 160000
index 19dbba563ff..00000000000
--- a/src/pytorch-sphinx-theme
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit 19dbba563ffd86c4167b6e9ac571556521c25f13
diff --git a/tools/linter/adapters/run_from_link.py b/tools/linter/adapters/run_from_link.py
new file mode 100644
index 00000000000..57c2f89f9a5
--- /dev/null
+++ b/tools/linter/adapters/run_from_link.py
@@ -0,0 +1,81 @@
+import argparse
+import subprocess
+import urllib.request
+from pathlib import Path
+
+
+REPO_ROOT = Path(__file__).absolute().parents[3]
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Use a formatter in a different repository.",
+    )
+    parser.add_argument(
+        "--run-init",
+        action="store_true",
+        help="Run the initialization script specified by --init-name.",
+    )
+    parser.add_argument(
+        "--run-lint",
+        action="store_true",
+        help="Run the linting script specified by --lint-name.",
+    )
+    parser.add_argument(
+        "--init-name",
+        help="Name of the initialization script.  This also serves as the filename.",
+    )
+    parser.add_argument(
+        "--init-link",
+        help="URL to download the initialization script from.",
+    )
+    parser.add_argument(
+        "--lint-name",
+        help="Name of the linting script.  This also serves as the filename.",
+    )
+    parser.add_argument(
+        "--lint-link",
+        help="URL to download the linting script from.",
+    )
+
+    parser.add_argument("args_for_file", nargs=argparse.REMAINDER)
+    args = parser.parse_args()
+    # Skip the first -- if present
+    if args.args_for_file and args.args_for_file[0] == "--":
+        args.args_for_file = args.args_for_file[1:]
+    return args
+
+
+def download_file(url: str, location: Path) -> bytes:
+    response = urllib.request.urlopen(url)
+    content = response.read()
+    location.write_bytes(content)
+    return content
+
+
+def main() -> None:
+    args = parse_args()
+
+    location = REPO_ROOT / ".lintbin" / "from_link" / "adapters"
+    location.mkdir(parents=True, exist_ok=True)
+
+    if args.lint_link:
+        download_file(args.lint_link, location / args.lint_name)
+
+    if args.init_link:
+        download_file(args.init_link, location / args.init_name)
+
+    if args.run_init:
+        # Save the content to a file named after the name argument
+        subprocess_args = ["python3", location / args.init_name] + args.args_for_file
+        subprocess.run(subprocess_args, check=True)
+    if args.run_lint:
+        subprocess_args = ["python3", location / args.lint_name] + args.args_for_file
+        subprocess.run(
+            subprocess_args,
+            check=True,
+        )
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tutorial_submission_policy.md b/tutorial_submission_policy.md
new file mode 100644
index 00000000000..4717ec438d4
--- /dev/null
+++ b/tutorial_submission_policy.md
@@ -0,0 +1,106 @@
+# PyTorch Tutorial Submission Policy
+
+This policy outlines the criteria and process for submitting new
+tutorials to the PyTorch community.
+Our goal is to ensure that all tutorials are of high quality,
+relevant, and up-to-date, supporting both the growth of the PyTorch
+users and the evolution of the PyTorch framework itself. By following
+these guidelines, contributors can help us maintain a robust and
+informative educational environment.
+
+## Acceptance Criteria For New Tutorials
+
+We accept new tutorials that adhere to one of the following use cases:
+
+* **Demonstrate New PyTorch Features:** Tutorials that support new features
+  for upcoming PyTorch releases are typically authored by the engineers who
+  are developing these features. These tutorials are crucial for showcasing
+  the latest advancements in PyTorch. We typically do not require more than
+  one tutorial per feature.
+
+* **Tutorials showcasing PyTorch usage with other tools and libraries:** We
+  accept community-contributed tutorials that illustrate innovative uses of
+  PyTorch alongside other open-source projects, models, and tools. Please
+  ensure that your tutorial remains neutral and does not promote or endorse
+  proprietary technologies over others.
+
+The first use case does not require going through the submission
+process outlined below. If your tutorial falls under the second category,
+please read and follow the instructions in the
+**Submission Process For Community-Contributed Tutorials** section.
+
+## Submission Process For Community-Contributed Tutorials
+
+To maintain the quality and relevance of tutorials, we request that
+community-contributed tutorials undergo a review process. If you are
+interested in contributing a tutorial, please follow these steps:
+
+1. **Create an issue:**
+   * Open an issue in the pytorch/tutorials repository proposing the
+     new tutorial. Clearly explain the importance of the tutorial and
+     confirm that there is no existing tutorial covering the same or
+     similar topic. A tutorial should not disproportionately endorse
+     one technology over another. Please consult with Core Maintainers
+     to ensure your content adheres to these guidelines.
+     Use the provided [ISSUE_TEMPLATE](https://github.com/pytorch/tutorials/blob/main/.github/ISSUE_TEMPLATE/feature-request.yml) for the new tutorial request - select **Feature request** when submitting an issue.
+
+     * If there is an existing tutorial on the topic that you would
+       like to significantly refactor, you can submit a PR. In the
+       description of the PR, explain why the changes are needed and
+       how they improve the tutorial.
+
+   * These issues will be triaged by PyTorch maintainers on a case-by-case basis.
+   * Link any supporting materials including discussions in other repositories.
+
+1. **Await Approval:**
+   * Wait for a response from the PyTorch Tutorials maintainers. A PyTorch
+     tutorial maintainer will review your proposal and
+     determine whether a tutorial on the proposed topic is desirable.
+     A comment and an **approved** label will be added to your issue
+     by a maintainer. The review process for new tutorial PRs submitted
+     without the corresponding issue may take longer.
+
+1. **Adhere to writing and styling guidelines:**
+   * Once approved, follow the guidelines outlined in [CONTRIBUTING.md](https://github.com/pytorch/tutorials/blob/main/CONTRIBUTING.md)
+     and use the provided [template](https://github.com/pytorch/tutorials/blob/main/beginner_source/template_tutorial.py) for creating your tutorial.
+   * Link the issue in which you received approval for your tutorial
+     in the PR.
+   * We accept tutorials in both ``.rst`` (ReStructuredText) and ``.py``
+     (Python) formats. However, unless your tutorial involves using
+     multiple GPU, parallel/distributed training, or requires extended
+     execution time (25 minutes or more), we prefer submissions
+     in Python file format.
+
+## Maintaining Tutorials
+
+When you submit a new tutorial, we encourage you to keep it in sync
+with the latest PyTorch updates and features. Additionally, we may
+contact you to review any PRs, issues, and other related matters to
+ensure the tutorial remains a valuable resource.
+
+Please note the following:
+
+* If a tutorial breaks against the main branch, it will
+  be excluded from the build and an issue will be filed against it,
+  with the author/maintainer notified. If the issue is not resolved
+  within 90 days, the tutorial might be deleted from the repository.
+
+* We recommend that each tutorial is reviewed at least once a year to
+  ensure its relevance.
+
+## Deleting Stale Tutorials
+
+A tutorial might be considered stale when it no longer aligns with
+the latest PyTorch updates, features, or best practices:
+
+* The tutorial is no longer functional due to changes in PyTorch or
+  its dependencies
+* The tutorial has been superseded by a newer, more comprehensive, or
+  more accurate tutorial
+* The tutorial does not run successfully in the (CI), indicating
+  potential compatibility or dependency issues.
+
+If a tutorial is deemed stale, we will attempt to contact the code owner,
+or someone from the tutorial mainatainers might attempt to update it.
+However, if despite those attempts we fail to fix it, the tutorial
+might be removed from the repository.
diff --git a/unstable_index.rst b/unstable_index.rst
new file mode 100644
index 00000000000..6e3cfd4364c
--- /dev/null
+++ b/unstable_index.rst
@@ -0,0 +1,164 @@
+Unstable
+========
+
+API unstable features are not available as part of binary distributions
+like PyPI or Conda (except maybe behind run-time flags). To test these
+features we would, depending on the feature, recommend building PyTorch
+from source (main) or using the nightly wheels that are made
+available on `pytorch.org <https://pytorch.org>`_.
+
+*Level of commitment*: We are committing to gathering high bandwidth
+feedback only on these features. Based on this feedback and potential
+further engagement between community members, we as a community will
+decide if we want to upgrade the level of commitment or to fail fast.
+
+
+.. raw:: html
+
+   <div id="tutorial-cards-container">
+
+    <nav class="navbar navbar-expand-lg navbar-light tutorials-nav col-12">
+        <div class="tutorial-tags-container">
+            <div id="dropdown-filter-tags">
+                <div class="tutorial-filter-menu">
+                    <div class="tutorial-filter filter-btn all-tag-selected" data-tag="all">All</div>
+                </div>
+            </div>
+        </div>
+    </nav>
+
+    <hr class="tutorials-hr">
+
+    <div class="row">
+
+    <div id="tutorial-cards">
+    <div class="list">
+
+.. Add prototype tutorial cards below this line
+
+.. vmap
+
+.. customcarditem::
+   :header: Using torch.vmap
+   :card_description: Learn about torch.vmap, an autovectorizer for PyTorch operations.
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: unstable/vmap_recipe.html
+   :tags: vmap
+
+.. NestedTensor
+
+.. customcarditem::
+   :header: Nested Tensor
+   :card_description: Learn about nested tensors, the new way to batch heterogeneous-length data
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: unstable/nestedtensor.html
+   :tags: NestedTensor
+
+.. MaskedTensor
+
+.. customcarditem::
+   :header: MaskedTensor Overview
+   :card_description: Learn about masked tensors, the source of truth for specified and unspecified values
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: unstable/maskedtensor_overview.html
+   :tags: MaskedTensor
+
+.. customcarditem::
+   :header: Masked Tensor Sparsity
+   :card_description: Learn about how to leverage sparse layouts (e.g. COO and CSR) in MaskedTensor
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: unstable/maskedtensor_sparsity.html
+   :tags: MaskedTensor
+
+.. customcarditem::
+   :header: Masked Tensor Advanced Semantics
+   :card_description: Learn more about Masked Tensor's advanced semantics (reductions and comparing vs. NumPy's MaskedArray)
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: unstable/maskedtensor_advanced_semantics.html
+   :tags: MaskedTensor
+
+.. customcarditem::
+   :header: MaskedTensor: Simplifying Adagrad Sparse Semantics
+   :card_description: See a showcase on how masked tensors can enable sparse semantics and provide for a cleaner dev experience
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: unstable/maskedtensor_adagrad.html
+   :tags: MaskedTensor
+
+.. Model-Optimization
+
+.. customcarditem::
+   :header: Inductor Cpp Wrapper Tutorial
+   :card_description: Speed up your models with Inductor Cpp Wrapper
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: unstable/inductor_cpp_wrapper_tutorial.html
+   :tags: Model-Optimization
+
+.. customcarditem::
+   :header: Inductor Windows CPU Tutorial
+   :card_description: Speed up your models with Inductor On Windows CPU
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: unstable/inductor_windows.html
+   :tags: Model-Optimization
+
+.. customcarditem::
+   :header: Use max-autotune compilation on CPU to gain additional performance boost
+   :card_description: Tutorial for max-autotune mode on CPU to gain additional performance boost
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: unstable/max_autotune_on_CPU_tutorial.html
+   :tags: Model-Optimization
+
+.. Distributed
+.. customcarditem::
+   :header: Flight Recorder Tutorial
+   :card_description: Debug stuck jobs easily with Flight Recorder
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: unstable/flight_recorder_tutorial.html
+   :tags: Distributed, Debugging, FlightRecorder
+
+.. customcarditem::
+   :header: Context Parallel Tutorial
+   :card_description: Parallelize the attention computation along sequence dimension
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: unstable/context_parallel.html
+   :tags: Distributed, Context Parallel
+
+.. Integration
+.. customcarditem::
+   :header: Out-of-tree extension autoloading in Python
+   :card_description: Learn how to improve the seamless integration of out-of-tree extension with PyTorch based on the autoloading mechanism.
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: unstable/python_extension_autoload.html
+   :tags: Extending-PyTorch, Frontend-APIs
+
+.. GPUDirect Storage
+.. customcarditem::
+   :header: (prototype) Using GPUDirect Storage
+   :card_description: Learn how to use GPUDirect Storage in PyTorch.
+   :image: _static/img/thumbnails/cropped/generic-pytorch-logo.png
+   :link: unstable/gpu_direct_storage.html
+   :tags: GPUDirect-Storage
+
+.. End of tutorial card section
+
+.. -----------------------------------------
+.. Page TOC
+.. -----------------------------------------
+
+.. toctree::
+   :maxdepth: 2
+   :hidden:
+
+   unstable/context_parallel
+   unstable/flight_recorder_tutorial
+   unstable/inductor_cpp_wrapper_tutorial
+   unstable/inductor_windows
+   unstable/vmap_recipe
+   unstable/nestedtensor
+   unstable/maskedtensor_overview
+   unstable/maskedtensor_sparsity
+   unstable/maskedtensor_advanced_semantics
+   unstable/maskedtensor_adagrad
+   unstable/python_extension_autoload
+   unstable/gpu_direct_storage.html
+   unstable/max_autotune_on_CPU_tutorial
+   unstable/skip_param_init.html
diff --git a/unstable_source/README.md b/unstable_source/README.md
new file mode 100644
index 00000000000..09f103514a3
--- /dev/null
+++ b/unstable_source/README.md
@@ -0,0 +1,9 @@
+# Prototype Tutorials and Recipes
+
+This directory contains tutorials and recipes demonstrating prototype features in PyTorch. 
+
+**Prototype features** are part of the release and are available as part of the binary distributions such as PyPI or Conda. To test these features you can, depending on the feature, build from the master branch or use the nightly wheels that are made available at pytorch.org. You can also by use the release wheels available from PyPI or Conda. Prototype features are provided as a technical preview and can be altered later on. The PyTorch team does not recommend using them in production pipelines.
+
+These are intentionally left out of the pytorch.org/tutorials build and will not show up on the website.
+
+*Level of commitment:* We are committing to gathering high bandwidth feedback only on these features. Based on this feedback and potential further engagement between community members, we as a community will decide if we want to upgrade the level of commitment or to fail fast. 
diff --git a/unstable_source/README.txt b/unstable_source/README.txt
new file mode 100644
index 00000000000..55a94b43626
--- /dev/null
+++ b/unstable_source/README.txt
@@ -0,0 +1,13 @@
+Prototype Tutorials
+------------------
+1. distributed_rpc_profiling.rst
+           Profiling PyTorch RPC-Based Workloads
+           https://github.com/pytorch/tutorials/blob/main/unstable_source/distributed_rpc_profiling.rst
+
+2. flight_recorder_tutorial.rst
+	   Flight Recorder User Guide
+	   https://pytorch.org/tutorials/prototype/flight_recorder_tutorial.html
+
+3. python_extension_autoload.rst
+	   Autoloading Out-of-Tree Extension
+	   https://github.com/pytorch/tutorials/blob/main/unstable_source/python_extension_autoload.rst
diff --git a/unstable_source/context_parallel.rst b/unstable_source/context_parallel.rst
new file mode 100644
index 00000000000..b12a4030016
--- /dev/null
+++ b/unstable_source/context_parallel.rst
@@ -0,0 +1,228 @@
+Introduction to Context Parallel
+======================================
+**Authors**: `Xilun Wu <https://github.com/XilunWu>`_, `Chien-Chin Huang <https://github.com/fegin>`__
+
+.. note::
+    |edit| View and edit this tutorial in `GitHub <https://github.com/pytorch/tutorials/blob/main/unstable_source/context_parallel.rst>`__.
+
+.. grid:: 2
+
+   .. grid-item-card:: :octicon:`mortar-board;1em;` What you will learn
+      :class-card: card-prerequisites
+
+      * `Context Parallel APIs <https://pytorch.org/docs/stable/distributed.tensor.html#torch.distributed.tensor.experimental.context_parallel>`__
+      * `1M sequence training in TorchTitan with Context Parallel <https://discuss.pytorch.org/t/distributed-w-torchtitan-breaking-barriers-training-long-context-llms-with-1m-sequence-length-in-pytorch-using-context-parallel/215082>`__
+
+
+   .. grid-item-card:: :octicon:`list-unordered;1em;` Prerequisites
+      :class-card: card-prerequisites
+
+      * PyTorch 2.7 or later
+
+
+Introduction
+------------
+
+Context Parallel is an approach used in large language model training to reduce peak activation size by sharding the long input sequence across multiple devices.
+It breaks the constraint on input sequence length resulting from peak memory usage on storing activations in Transformer blocks.
+
+Ring Attention, a novel parallel implementation of the Attention layer, is critical to performant Context Parallel.
+Ring Attention shuffles the KV shards and calculates the partial attention scores, repeats until all KV shards have been used on each device.
+Two Ring Attention variants have been implemented: `the all-gather based pass-KV <https://arxiv.org/abs/2407.21783>`__ and `the all-to-all based pass-KV <https://openreview.net/forum?id=WsRHpHH4s0>`__:
+
+1.  The all-gather based pass-KV algorithm is used in Llama3 training, which initially performs an all-gather on the key and value tensors, followed by computing the attention output for the
+    local query tensor chunk. Our modified all-gather based pass-KV algorithm concurrently all-gathers KV shards and computes attention output for the local query tensor chunk
+    using local key and value tensor chunks, followed by a final computation of attention output for the local query tensor and remaining KV shards. This allows some degree of
+    overlap between the attention computation and the all-gather collective. For example, in the case of Llama3 training, we also shard ``freq_cis`` over the sequence dimension.
+2.  The all-to-all approach uses interleaved all-to-all collectives to ring shuffle KV shards to overlap the SDPA (Scaled Dot Product Attention) computation and the all-to-all communication
+    necessary for the next SDPA.
+
+The Context Parallel APIs consist of two parts:
+
+1.  ``context_parallel()`` allows users to create a Python context where the SDPA function (``torch.nn.functional.scaled_dot_product_attention``)
+    will be automatically replaced with Ring Attention. To shard Tensors along a dimension, simply pass the Tensors and their sharding dimensions to
+    argument ``buffers`` and ``buffer_seq_dims`` respectively. We recommend that users add tensors computing along the sequence dimension to ``buffers``
+    and shard them along this dimension. Taking Llama3 training as an example, missing ``freq_cis`` in ``buffers`` will result in a miscalculated rotary embedding.
+2.  ``set_rotate_method()`` allows users to choose between the all-gather based pass-KV approach and the all-to-all based pass-KV approach.
+
+
+Setup
+---------------------
+
+With ``torch.distributed.tensor.experimental.context_parallel()``, users can easily shard the Tensor input and parallelize the execution of the SDPA function.
+To better demonstrate the usage of this API, we start with a simple code snippet doing SDPA and then parallelize it using the API:
+
+.. code:: python
+
+    import torch
+    import torch.nn.functional as F
+
+    from torch.nn.attention import sdpa_kernel, SDPBackend
+
+
+    def sdpa_example():
+        assert torch.cuda.is_available()
+        torch.cuda.set_device("cuda:0")
+        torch.cuda.manual_seed(0)
+
+        batch = 8
+        nheads = 8
+        qkv_len = 8192
+        dim = 32
+        backend = SDPBackend.FLASH_ATTENTION
+        dtype = (
+            torch.bfloat16
+            if backend == SDPBackend.FLASH_ATTENTION
+            or backend == SDPBackend.CUDNN_ATTENTION
+            else torch.float32
+        )
+
+        qkv = [
+            torch.rand(
+                (batch, nheads, qkv_len, dim),
+                dtype=dtype,
+                requires_grad=True,
+                device='cuda',
+            )
+            for _ in range(3)
+        ]
+        # specify the SDPBackend to use
+        with sdpa_kernel(backend):
+            out = F.scaled_dot_product_attention(*qkv, is_causal=True)
+
+
+    if __name__ == "__main__":
+        sdpa_example()
+
+
+Enable Context Parallel
+-----------------------
+
+Now, let's first adapt it to a distributed program where each rank has the same tensor input. Then we apply the context parallel API to
+shard to input and distribute the computation across ranks:
+
+.. code:: python
+
+    # file: cp_sdpa_example.py
+    import os
+
+    import torch
+    import torch.distributed as dist
+    import torch.nn.functional as F
+    from torch.distributed.device_mesh import init_device_mesh
+    from torch.distributed.tensor.experimental import context_parallel
+    from torch.distributed.tensor.experimental._attention import context_parallel_unshard
+    from torch.nn.attention import sdpa_kernel, SDPBackend
+
+
+    def context_parallel_sdpa_example(world_size: int, rank: int):
+        assert torch.cuda.is_available()
+        assert dist.is_nccl_available()
+        torch.cuda.set_device(f"cuda:{rank}")
+        torch.cuda.manual_seed(0)
+
+        dist.init_process_group(
+            backend="nccl",
+            init_method="env://",
+            world_size=world_size,
+            rank=rank,
+        )
+        device_mesh = init_device_mesh(
+            device_type="cuda", mesh_shape=(world_size,), mesh_dim_names=("cp",)
+        )
+
+        batch = 8
+        nheads = 8
+        qkv_len = 64
+        dim = 32
+        backend = SDPBackend.FLASH_ATTENTION
+        dtype = (
+            torch.bfloat16
+            if backend == SDPBackend.FLASH_ATTENTION
+            or backend == SDPBackend.CUDNN_ATTENTION
+            else torch.float32
+        )
+
+        qkv = [
+            torch.rand(
+                (batch, nheads, qkv_len, dim),
+                dtype=dtype,
+                requires_grad=True,
+                device='cuda',
+            )
+            for _ in range(3)
+        ]
+        # specify the SDPBackend to use
+        with sdpa_kernel(backend):
+            out = F.scaled_dot_product_attention(*qkv, is_causal=True)
+
+        # make a clean copy of QKV for output comparison
+        cp_qkv = [t.detach().clone() for t in qkv]
+
+        with sdpa_kernel(backend):
+            # This `context_parallel()` performs two actions:
+            # 1. Shard the tensor objects in `buffers` in-place along the dimension
+            #    specified in `buffer_seq_dims`, the tensors in `buffers` and their
+            #    sharding dims in `buffer_seq_dims` are organized in the same order.
+            # 2. Replace the execution of `F.scaled_dot_product_attention` with a
+            #    context-paralleled-enabled Ring Attention.
+            with context_parallel(
+                device_mesh, buffers=tuple(cp_qkv), buffer_seq_dims=(2, 2, 2)
+            ):
+                cp_out = F.scaled_dot_product_attention(*cp_qkv, is_causal=True)
+
+            # The output `cp_out` is still sharded in the same way as QKV
+            # the `context_parallel_unshard` API allows users to easily
+            # unshard to gain the full tensor.
+            (cp_out,) = context_parallel_unshard(device_mesh, [cp_out], [2])
+
+        assert torch.allclose(
+            cp_out,
+            out,
+            atol=(1e-08 if dtype == torch.float32 else 1e-03 * world_size),
+        )
+
+
+    if __name__ == "__main__":
+        rank = int(os.environ["RANK"])
+        world_size = int(os.environ["WORLD_SIZE"])
+
+        try:
+            context_parallel_sdpa_example(world_size, rank)
+        finally:
+            dist.barrier()
+            dist.destroy_process_group()
+
+
+You can use the command ``torchrun --standalone --nnodes=1 --nproc-per-node=4 cp_sdpa_example.py`` to launch the above context parallel
+SDPA on 4 GPUs. We demonstrate the numeric correctness by comparing the output of Ring Attention to that of SDPA on a single GPU.
+
+
+Select Rotation Approach
+------------------------
+
+You can choose the desired shards rotation approach in Ring Attention by using ``torch.distributed.tensor.experimental._attention.set_rotate_method()``:
+
+.. code:: python
+
+    # file: cp_sdpa_example.py
+    from torch.distributed.tensor.experimental._attention import set_rotate_method
+
+    set_rotate_method("alltoall")  # rotate shards using all-to-all
+
+    with sdpa_kernel(backend):
+        with context_parallel(
+            device_mesh, buffers=tuple(cp_qkv), buffer_seq_dims=(2, 2, 2)
+        ):
+            cp_out = F.scaled_dot_product_attention(*cp_qkv, is_causal=True)
+
+
+The default rotation approach is the all-gather based pass-KV.
+
+
+Conclusion
+----------
+
+In this tutorial, we have learned how to parallelize the SDPA computation along the sequence dimension easily with our Context Parallel APIs. For
+design and implementation details, performance analysis, and an end-to-end training example in `TorchTitan <https://github.com/pytorch/torchtitan>`__,
+see our post on `PyTorch native long-context training <https://discuss.pytorch.org/t/distributed-w-torchtitan-breaking-barriers-training-long-context-llms-with-1m-sequence-length-in-pytorch-using-context-parallel/215082>`__.
diff --git a/unstable_source/distributed_rpc_profiling.rst b/unstable_source/distributed_rpc_profiling.rst
new file mode 100644
index 00000000000..ab2ecbb2d9b
--- /dev/null
+++ b/unstable_source/distributed_rpc_profiling.rst
@@ -0,0 +1,10 @@
+Profiling PyTorch RPC-Based Workloads
+======================================
+
+This tutorial has been deprecated.
+
+Redirecting to homepage...
+
+.. raw:: html
+
+   <meta http-equiv="Refresh" content="2; url='https://pytorch.org/tutorials'" />
diff --git a/unstable_source/flight_recorder_tutorial.rst b/unstable_source/flight_recorder_tutorial.rst
new file mode 100644
index 00000000000..35477779083
--- /dev/null
+++ b/unstable_source/flight_recorder_tutorial.rst
@@ -0,0 +1,304 @@
+Flight Recorder for Debugging Stuck Jobs
+====================================================
+**Author**: `Chirag Pandya <https://github.com/c-p-i-o>`_, `Junjie Wang <https://github.com/fduwjj>`_
+
+What you will learn
+-------------------
+* Learn about a new tool for debugging stuck jobs during distributed training.
+* Learn how you can enable the tool and use the collected data for analyzing stuck jobs.
+
+Prerequisites
+-------------
+
+- PyTorch version 2.5 or later.
+- `tabulate <https://pypi.org/project/tabulate/>`__. You can install by running ``pip install tabulate``.
+
+
+Overview
+--------
+An AI distributed training job refers to the process of training a machine learning model using multiple devices, such
+as GPUs or CPUs, connected in a network. This approach allows for faster and more efficient training of large models
+that require significant computational resources.
+An engineer’s goal is to complete an AI training job as quickly as possible and make continuous improvements so that
+subsequent training can be done faster. A trained, usable model is the final desired outcome.
+One of the biggest impediment to completing training is the concept of a *stuck job*.
+
+A distributed AI training job is considered `stuck` when it stops making meaningful progress for an extended period of
+time.
+
+A job can get stuck for various reasons:
+
+- **Data Starvation:** This occurs when the training job is not receiving data at the expected rate, possibly due to issues with the data pipeline or the data source.
+
+- **Resource Constraints:** If the system running the job does not have enough computational resources (such as CPU, GPU, or memory), the job might not be able to proceed.
+
+- **Network Issues:** In a distributed training setup, different parts of the model or data may be processed on different devices. If there are network issues, communication between these devices may be disrupted, causing the job to get stuck.
+
+- **Software Bugs or Errors:** Errors in the training code or the underlying libraries and frameworks can also cause a job to get stuck.
+
+- **Synchronization Issues:** In distributed training, different parts of the computation are often run in parallel and need to be synchronized at certain points. If this synchronization fails, the job can get stuck. For example, a deadlock can occur if one or more ranks fail to join a collective while the remaining ranks have joined. This results in an indefinite wait for the job to progress.
+
+Flight Recorder, as the name suggests, captures diagnostics information as collectives run. The captured diagnostic
+information is used to help identify the root causes of issues when jobs become stuck.
+Flight Recorder consists of two core parts:
+
+- The collection portion: when enabled, information about collectives is recorded in an in-memory circular buffer. Upon job timeout, or on demand, the in-memory buffer can be retrieved or dumped to file.
+
+- An analyzer script is available in the `tools/flight_recorder <https://github.com/pytorch/pytorch/tree/main/tools/flight_recorder>`__ directory (details below).
+   The analyzer script runs known heuristics using the collected data and attempts to automatically identify the underlying issue that caused the job to stall.
+
+Enabling Flight Recorder
+------------------------
+There are three required environment variables to get the initial version of Flight Recorder working.
+
+- ``TORCH_NCCL_TRACE_BUFFER_SIZE = (0, N)``: Setting ``N`` to a positive number enables collection.
+  ``N`` represents the number of entries that will be kept internally in a circular buffer.
+  We recommended to set this value at *2000*. The default value is ``2000``.
+- ``TORCH_NCCL_DUMP_ON_TIMEOUT = (true, false)``: Setting this to ``true`` will write out diagnostic files to disk on job timeout.
+  If enabled, there will be one file per rank output in the job's running directory. The default value is ``false``.
+- ``TORCH_FR_DUMP_TEMP_FILE``: Setting the path where the flight recorder will be dumped with file prefix. One file per
+  rank. The default value is ``/tmp/nccl_trace_rank_``.
+
+**Optional settings:**
+
+- ``TORCH_NCCL_TRACE_CPP_STACK = (true, false)``: Setting this to true enables C++ stack traces to be captured in Flight Recorder.
+  C++ stack traces can be useful in providing the exact code path from a PyTorch Python call down to the primitive
+  C++ implementation. Also see ``TORCH_SYMBOLIZE_MODE`` in additional settings.
+- ``TORCH_NCCL_ENABLE_TIMING = (true, false)``: Setting this to ``true`` will enable additional cuda events at the start of each collective and
+  records the *duration* of each collective. This may incur some CPU overhead. In the collected data, the
+  *duration* field indicates how long each collective took to execute.
+
+Additional Settings
+-------------------
+
+- ``TORCH_SYMBOLIZE_MODE = (dladdr, addr2line, fast)``: This setting determines the program used to retrieve C++ traces from a running program.
+     The default setting is ``addr2line``.
+
+     ``fast`` is a new experimental mode that is shown to be much faster than the traditional ``addr2line``.
+     Use this setting in conjunction with ``TORCH_NCCL_TRACE_CPP_STACK`` to collect C++ traces in the Flight Recorder data.
+- If you prefer not to have the flight recorder data dumped into the local disk but rather onto your own storage, you can define your own writer class.
+  This class should inherit from class ``::c10d::DebugInfoWriter`` `(code) <https://github.com/pytorch/pytorch/blob/release/2.5/torch/csrc/distributed/c10d/NCCLUtils.hpp#L237>`__
+  and then register the new writer using ``::c10d::DebugInfoWriter::registerWriter`` `(code) <https://github.com/pytorch/pytorch/blob/release/2.5/torch/csrc/distributed/c10d/NCCLUtils.hpp#L242>`__
+  before we initiate PyTorch distributed.
+
+Retrieving Flight Recorder Data via an API
+------------------------------------------
+
+You can also retrieve Flight Recorder data with an API call.
+The API with the default arguments is shown below:
+
+.. code:: python
+
+  torch._C._distributed_c10d._dump_nccl_trace(includeCollectives=True, includeStackTraces=True, onlyActive=False)
+
+To view the data, you can ``unpickle`` it as shown below:
+
+.. code:: python
+
+  t = pickle.loads(torch._C._distributed_c10d._dump_nccl_trace())
+  print(t)
+
+Flight Recorder File Formats
+----------------------------
+
+Flight Recorder files are dumped in ``pickle`` format. Files are written to local disks or mounted shared NFS
+folders.
+
+The contents of a Flight Recorder ``unpickled`` file are shown below:
+
+.. code-block:: json
+
+  {
+    "version": "2.5",
+    "pg_config": {
+      "0": {
+      "name": "0",
+      "desc": "default_pg",
+      "ranks": "[0, 1]"
+      }
+    },
+    "pg_status": {
+      "0": {
+      "last_enqueued_collective": 2,
+      "last_started_collective": -1,
+      "last_completed_collective": 2
+      }
+    },
+    "entries": [
+    {
+      "frames": [
+      {
+      "name": "test_short_pickle",
+      "filename": "pytorch/test/distributed/test_c10d_nccl.py",
+      "line": 3647
+      },
+      {
+      "name": "spawn_main",
+      "filename": ".conda/envs/pytorch-3.10/lib/python3.10/multiprocessing/spawn.py",
+      "line": 116
+      },
+      {
+      "name": "<module>",
+      "filename": "<string>",
+      "line": 1
+      }
+      ],
+      "record_id": 0,
+      "pg_id": 0,
+      "process_group": ("0", "default_pg"),
+      "collective_seq_id": 1,
+      "p2p_seq_id": 0,
+      "op_id": 1,
+      "profiling_name": "nccl:all_reduce",
+      "time_created_ns": 1724779239936775119,
+      "input_sizes": [[3, 4]],
+      "input_dtypes": ["Float"],
+      "output_sizes": [[3, 4]],
+      "output_dtypes": ["Float"],
+      "state": "completed",
+      "time_discovered_started_ns": null,
+      "time_discovered_completed_ns": 1724779239975811724,
+      "retired": true,
+      "timeout_ms": 600000,
+      "is_p2p": false
+      },
+      ...
+      ]
+  }
+
+Analyzing Flight Recorder Dumps
+-------------------------------
+
+We have convenient scripts available in `pytorch/tools/flight_recorder` directory for analyzing captured
+data.
+
+To run the convenience script, follow these steps:
+
+1. Copy all files from a rank into a single directory.
+
+2. To run the script, use this command:
+
+.. code:: shell
+
+  python fr_trace.py <dump dir containing trace files> [-o <output file>]
+
+If you install the PyTorch nightly build or build from scratch with ``USE_DISTRIBUTED=1``, you can directly use the following
+command directly:
+
+.. code:: shell
+
+  torchfrtrace <dump dir containing trace files> [-o <output file>]
+
+
+Currently, we support two modes for the analyzer script. The first mode allows the script to apply some heuristics to the parsed flight
+recorder dumps to generate a report identifying potential culprits for the timeout. The second mode is simply outputs the raw dumps.
+By default, the script prints flight recoder dumps for all ranks and all ``ProcessGroups``(PGs). This can be narrowed down to certain
+ranks and PGs using the *--selected-ranks* argument for ranks and *--pg-filters* argument for PGs. An example command is:
+
+Caveat: tabulate module is needed, so you might need pip install it first.
+
+.. code:: shell
+
+  python fr_trace.py <dump dir containing trace files> -j [--selected-ranks i j k ...] [--pg-filters tp dp]
+  torchfrtrace <dump dir containing trace files> -j [--selected-ranks i j k ...] [--pg-filters 0 2]
+
+An End-to-End Example
+------------------------------------
+To demonstrate the use of Flight Recorder, we will use a small program where we induce mismatched collectives.
+In this example, ``rank0`` is programmed to do an additional collective.
+The Flight Recorder dump files are saved to the ``/tmp`` directory.
+For demonstration purposes, we named this program ``crash.py``.
+
+.. note::
+   Please note that this is a simplified example. In real-world scenarios, the process would involve more
+   complexities.
+
+.. code:: python
+
+  import torch
+  import torch.distributed as dist
+  import os
+  from datetime import timedelta
+
+  local_rank = int(os.environ["LOCAL_RANK"])
+  world_size = int(os.environ["WORLD_SIZE"])
+  assert world_size <= 8, "world size must be less than or equal to 8"
+  os.environ["TORCH_NCCL_DEBUG_INFO_TEMP_FILE"] = "/tmp/trace_"
+  os.environ["TORCH_NCCL_DUMP_ON_TIMEOUT"] = "1"
+  os.environ["TORCH_NCCL_TRACE_BUFFER_SIZE"] = "2000"
+  device = torch.device(f"cuda:{local_rank}")
+  print(f"{local_rank=} {world_size=} master addr: {os.environ['MASTER_ADDR']} master port: {os.environ['MASTER_PORT']} {device=}")
+
+  # Initialize the process group with a small timeout so that jobs fail quickly
+  dist.init_process_group("nccl", world_size=world_size, rank=local_rank, timeout=timedelta(seconds=1))
+
+  a = torch.full((3, 4), float(local_rank), device=device)
+  # Write some collectives to populate Flight Recorder data
+  for i in range(2):
+    print(f"calling allreduce on {local_rank=}")
+    f = dist.all_reduce(a)
+
+  # rank0 is doing an additional collective
+  if local_rank == 0:
+    print("rank0 is doing an allreduce on tensor b, but other ranks forgot")
+    b = torch.full((4,5), float(local_rank), device=device)
+    f = dist.all_reduce(b)
+
+  for i in range(2):
+    print(f"calling allreduce on {local_rank=}")
+    f = dist.all_reduce(a)
+
+  torch.cuda.synchronize(device=device)
+  print(f"{local_rank=} exiting")
+
+
+To run this program, use ``torchrun``:
+
+
+.. code:: python
+
+  torchrun --nnodes=1 --nproc_per_node=2 crash.py
+
+You should see two files in the ``/tmp`` directory:
+
+.. code:: bash
+
+  $ls /tmp/trace*
+  # Expected output
+  /tmp/trace_0 /tmp/trace_1
+
+Finally, to analyze these two files, we use the ``torchfrtrace`` command:
+
+.. code:: bash
+
+  torchfrtrace --prefix "trace_" /tmp/
+
+The output from the trace command is meant to be human-readable. It includes information about the
+set of collectives that caused a failure.
+The output for the command above is shown below.
+We can clearly see that rank 1 did not join the "all_reduce" collective.
+
+.. code-block:: bash
+  $torchfrtrace --prefix "trace_" /tmp/
+  Not all ranks joining collective 5 at entry 4
+  group info: 0:default_pg
+  collective: nccl:all_reduce
+  missing ranks: {1}
+  input sizes: [[3, 4]]
+  output sizes: [[3, 4]]
+  expected ranks: 2
+  collective state: scheduled
+  collective stack trace:
+    all_reduce at /home/cpio/local/pytorch/torch/distributed/distributed_c10d.py:2696
+    wrapper at /home/cpio/local/pytorch/torch/distributed/c10d_logger.py:83
+    <module> at /home/cpio/test/crash.py:44
+
+
+
+Conclusion
+----------
+In this tutorial, we have learned about a new PyTorch diagnostic tool called Flight Recorder.
+We have discussed how to enable Flight Recorder to collect diagnostic data from a machine.
+Additionally, we explored how to analyze the data captured from the Flight Recorder using a
+convenience script located in the `tools/flight_recorder <https://github.com/pytorch/pytorch/tree/main/tools/flight_recorder>`__
+directory of the PyTorch repository.
diff --git a/unstable_source/gpu_direct_storage.py b/unstable_source/gpu_direct_storage.py
new file mode 100644
index 00000000000..2b06c53bc7f
--- /dev/null
+++ b/unstable_source/gpu_direct_storage.py
@@ -0,0 +1,132 @@
+"""
+(prototype) Accelerating ``torch.save`` and ``torch.load`` with GPUDirect Storage
+=================================================================================
+
+GPUDirect Storage enables a direct data path for direct memory access transfers
+between GPU memory and storage, avoiding a bounce buffer through the CPU.
+
+In version **2.7**, we introduced new prototype APIs to ``torch.cuda.gds`` that serve as thin wrappers around
+the `cuFile APIs <https://docs.nvidia.com/gpudirect-storage/api-reference-guide/index.html#cufile-io-api>`_
+that can be used with ``torch.Tensor`` to achieve improved I/O performance.
+
+In this tutorial, we will demonstrate how to use the ``torch.cuda.gds`` APIs in conjunction with
+checkpoints generated by ``torch.save`` and ``torch.load`` on local filesystem. 
+
+.. grid:: 2
+
+    .. grid-item-card:: :octicon:`mortar-board;1em;` What you will learn
+       :class-card: card-prerequisites
+
+       * Understand how to use the ``torch.cuda.gds`` APIs in conjunction with
+         checkpoints generated by ``torch.save`` and ``torch.load`` on local filesystem
+    
+    .. grid-item-card:: :octicon:`list-unordered;1em;` Prerequisites
+       :class-card: card-prerequisites
+
+       * PyTorch v.2.7.0 or later
+       * GPUDirect Storage must be installed per
+         `the documentation <https://docs.nvidia.com/gpudirect-storage/troubleshooting-guide/contents.html>`_
+       * Ensure that the filesystem that you are saving/loading to supports GPUDirect Storage.
+"""
+
+################################################################################
+# Using GPUDirect Storage with ``torch.save`` and ``torch.load``
+# ------------------------------------------------------------------------------------
+# GPUDirect Storage requires a storage alignment of 4KB. You can toggle this by using
+# ``torch.utils.serialization.config.save.storage_alignment``:
+
+import torch
+from torch.utils.serialization import config as serialization_config
+
+serialization_config.save.storage_alignment = 4096
+
+################################################################################
+# The steps involved in the process are as follows:
+#    * Write the checkpoint file without any actual data. This reserves the space on disk.
+#    * Read the offsets for the storage associated with each tensor in the checkpoint using ``FakeTensor``.
+#    * Use ``GDSFile`` to write the appropriate data at these offsets.
+# 
+# Given a state dictionary of tensors that are on the GPU, one can use the ``torch.serialization.skip_data`` context
+# manager to save a checkpoint that contains all relevant metadata except the storage bytes. For each ``torch.Storage``
+# in the state dictionary, space will be reserved within the checkpoint for the storage bytes.
+
+import torch.nn as nn
+
+m = nn.Linear(5, 10, device='cuda')
+sd = m.state_dict()
+
+with torch.serialization.skip_data():
+    torch.save(sd, "checkpoint.pt")
+
+################################################################################
+# We can get the offsets that each storage should be written to within the checkpoint by loading under
+# a ``FakeTensorMode``. A FakeTensor is a tensor that has metadata (such as sizes, strides, dtype, device)
+# information about the tensor but does not have any storage bytes. The following snippet will not materialize
+# any data but will tag each ``FakeTensor`` with the offset within the checkpoint that
+# corresponds to the tensor.
+# 
+# If you are continuously saving the same state dictionary during training, you
+# would only need to obtain the offsets once and the same offsets can be re-used. Similarly if tensor is going to
+# be saved or loaded to repeatedly you can use the ``torch.cuda.gds.gds_register_buffer`` which wraps
+# ``cuFileBufRegister`` to register the storages as GDS buffers.
+#
+# Note that ``torch.cuda.gds.GdsFile.save_storage`` binds to the synchronous ``cuFileWrite`` API,
+# so no synchronization is needed afterwards.
+
+
+import os
+from torch._subclasses.fake_tensor import FakeTensorMode
+
+with FakeTensorMode() as mode:
+    fake_sd = torch.load("checkpoint.pt")
+
+for k, v in fake_sd.items():
+    print(f"key={k}, offset={v.untyped_storage()._checkpoint_offset}")
+
+f = torch.cuda.gds.GdsFile("checkpoint.pt", os.O_RDWR)
+
+for k, v in sd.items():
+    offset = fake_sd[k].untyped_storage()._checkpoint_offset
+    # save_storage is a wrapper around `cuFileWrite`
+    f.save_storage(v.untyped_storage(), offset)
+
+
+################################################################################
+# We verify correctness of the saved checkpoint by ``torch.load`` and comparing.
+
+sd_loaded = torch.load("checkpoint.pt")
+for k, v in sd_loaded.items():
+    assert torch.equal(v, sd[k])
+
+################################################################################
+# The loading flow is the inverse: you can use ``torch.load`` with the ``torch.serialization.skip_data`` context
+# manager to load everything except the storage bytes. This means that any tensors in the checkpoint will be
+# created but their storages will be empty (as if the tensors were created via ``torch.empty``).
+
+with torch.serialization.skip_data():
+    sd_loaded = torch.load("checkpoint.pt")
+
+################################################################################
+# We once again use the ``FakeTensorMode`` to get the checkpoint offsets and
+# ascertain that the loaded checkpoint is the same as the saved checkpoint.
+#
+# Similar to  ``torch.cuda.gds.GdsFile.save_storage``, ``torch.cuda.gds.GdsFile.load_storage``
+# binds to the synchronous ``cuFileRead`` API, so no synchronization is needed afterwards.
+
+for k, v in sd_loaded.items():
+    assert not torch.equal(v, sd[k])
+    offset = fake_sd[k].untyped_storage()._checkpoint_offset
+    # load_storage is a wrapper around `cuFileRead`
+    f.load_storage(v.untyped_storage(), offset)
+
+for k, v in sd_loaded.items():
+    assert torch.equal(v, sd[k])
+
+del f
+##########################################################
+# Conclusion
+# ==========
+#
+# In this tutorial we have demonstrated how to use the prototype ``torch.cuda.gds`` APIs
+# in conjunction with ``torch.save`` and ``torch.load`` on local filesystem. Please
+# file an issue in the PyTorch GitHub repo if you have any feedback.
diff --git a/unstable_source/gpu_quantization_torchao_tutorial.py b/unstable_source/gpu_quantization_torchao_tutorial.py
new file mode 100644
index 00000000000..874f3227636
--- /dev/null
+++ b/unstable_source/gpu_quantization_torchao_tutorial.py
@@ -0,0 +1,320 @@
+"""
+(prototype) GPU Quantization with TorchAO
+======================================================
+
+**Author**: `HDCharles <https://github.com/HDCharles>`_
+
+In this tutorial, we will walk you through the quantization and optimization
+of the popular `segment anything model <https://github.com/facebookresearch/segment-anything>`_. These
+steps will mimic some of those taken to develop the
+`segment-anything-fast <https://github.com/meta-pytorch/segment-anything-fast/blob/main/segment_anything_fast/modeling/image_encoder.py#L15>`_
+repo. This step-by-step guide demonstrates how you can
+apply these techniques to speed up your own models, especially those
+that use transformers. To that end, we will focus on widely applicable
+techniques, such as optimizing performance with ``torch.compile`` and
+quantization and measure their impact.
+
+"""
+
+
+######################################################################
+# Set up Your Environment
+# --------------------------------
+#
+# First, let's configure your environment. This guide was written for CUDA 12.1.
+# We have run this tutorial on an A100-PG509-200 power limited to 330.00 W. If you
+# are using a different hardware, you might see different performance numbers.
+#
+#
+# .. code-block:: bash
+#
+#    > conda create -n myenv python=3.10
+#    > pip3 install --pre torch torchvision torchaudio --index-url https://download.pytorch.org/whl/nightly/cu121
+#    > pip install git+https://github.com/facebookresearch/segment-anything.git
+#    > pip install git+https://github.com/pytorch/ao.git
+#
+# Segment Anything Model checkpoint setup:
+#
+# 1. Go to the `segment-anything repo checkpoint <https://github.com/facebookresearch/segment-anything/tree/main#model-checkpoints>`_ and download the ``vit_h`` checkpoint. Alternatively, you can use ``wget`` (for example, ``wget https://dl.fbaipublicfiles.com/segment_anything/sam_vit_h_4b8939.pth --directory-prefix=<path>``).
+# 2. Pass in that directory by editing the code below to say:
+#
+# .. code-block:: bash
+#
+#   {sam_checkpoint_base_path}=<path>
+#
+
+import torch
+from torchao.quantization.quant_api import quantize_, Int8DynamicActivationInt8WeightConfig
+from torchao.utils import unwrap_tensor_subclass, TORCH_VERSION_AT_LEAST_2_5
+from segment_anything import sam_model_registry
+from torch.utils.benchmark import Timer
+
+sam_checkpoint_base_path = "data"
+model_type = 'vit_h'
+model_name = 'sam_vit_h_4b8939.pth'
+checkpoint_path = f"{sam_checkpoint_base_path}/{model_name}"
+batchsize = 16
+only_one_block = True
+
+
+@torch.no_grad()
+def benchmark(f, *args, **kwargs):
+    for _ in range(3):
+        f(*args, **kwargs)
+        torch.cuda.synchronize()
+
+    torch.cuda.reset_peak_memory_stats()
+    t0 = Timer(
+        stmt="f(*args, **kwargs)", globals={"args": args, "kwargs": kwargs, "f": f}
+    )
+    res = t0.adaptive_autorange(.03, min_run_time=.2, max_run_time=20)
+    return {'time':res.median * 1e3, 'memory': torch.cuda.max_memory_allocated()/1e9}
+
+def get_sam_model(only_one_block=False, batchsize=1):
+    sam = sam_model_registry[model_type](checkpoint=checkpoint_path).cuda()
+    model = sam.image_encoder.eval()
+    image = torch.randn(batchsize, 3, 1024, 1024, device='cuda')
+
+    # code to use just a single block of the model
+    if only_one_block:
+        model = model.blocks[0]
+        image = torch.randn(batchsize, 64, 64, 1280, device='cuda')
+    return model, image
+
+
+######################################################################
+# In this tutorial, we focus on quantizing the ``image_encoder`` because the
+# inputs to it are statically sized while the prompt encoder and mask
+# decoder have variable sizes which makes them harder to quantize.
+#
+# We’ll focus on just a single block at first to make the analysis easier.
+#
+# Let's start by measuring the baseline runtime.
+
+try:
+    model, image = get_sam_model(only_one_block, batchsize)
+    fp32_res = benchmark(model, image)
+    print(f"base fp32 runtime of the model is {fp32_res['time']:0.2f}ms and peak memory {fp32_res['memory']:0.2f}GB")
+    # base fp32 runtime of the model is 186.16ms and peak memory 6.33GB
+except Exception as e:
+    print("unable to run fp32 model: ", e)
+
+
+
+######################################################################
+# We can achieve an instant performance boost by converting the model to bfloat16.
+# The reason we opt for bfloat16 over fp16 is due to its dynamic range, which is comparable to
+# that of fp32. Both bfloat16 and fp32 possess 8 exponential bits, whereas fp16 only has 4. This
+# larger dynamic range helps protect us from overflow errors and other issues that can arise
+# when scaling and rescaling tensors due to quantization.
+#
+
+model, image = get_sam_model(only_one_block, batchsize)
+model = model.to(torch.bfloat16)
+image = image.to(torch.bfloat16)
+bf16_res = benchmark(model, image)
+print(f"bf16 runtime of the block is {bf16_res['time']:0.2f}ms and peak memory {bf16_res['memory']: 0.2f}GB")
+# bf16 runtime of the block is 25.43ms and peak memory  3.17GB
+
+
+######################################################################
+# Just this quick change improves runtime by a factor of ~7x in the tests we have
+# conducted (186.16ms to 25.43ms).
+#
+# Next, let's use ``torch.compile`` with our model to see how much the performance
+# improves.
+#
+
+model_c = torch.compile(model, mode='max-autotune')
+comp_res = benchmark(model_c, image)
+print(f"bf16 compiled runtime of the block is {comp_res['time']:0.2f}ms and peak memory {comp_res['memory']: 0.2f}GB")
+# bf16 compiled runtime of the block is 19.95ms and peak memory  2.24GB
+
+
+######################################################################
+# The first time this is run, you should see a sequence of ``AUTOTUNE``
+# outputs which occurs when inductor compares the performance between
+# various kernel parameters for a kernel. This only happens once (unless
+# you delete your cache) so if you run the cell again you should just get
+# the benchmark output.
+#
+# ``torch.compile`` yields about another 27% improvement. This brings the
+# model to a reasonable baseline where we now have to work a bit harder
+# for improvements.
+#
+# Next, let's apply quantization. Quantization for GPUs comes in three main forms
+# in `torchao <https://github.com/pytorch/ao>`_ which is just native
+# pytorch+python code. This includes:
+#
+# * int8 dynamic quantization
+# * int8 weight-only quantization
+# * int4 weight-only quantization
+#
+# Different models, or sometimes different layers in a model can require different techniques.
+# For models which are heavily compute bound, dynamic quantization tends
+# to work the best since it swaps the normal expensive floating point
+# matmul ops with integer versions. Weight-only quantization works better
+# in memory bound situations where the benefit comes from loading less
+# weight data, rather than doing less computation. The torchao APIs:
+#
+# ``Int8DynamicActivationInt8WeightConfig()``,
+# ``Int8WeightOnlyConfig()`` or
+# ``Int4WeightOnlyConfig()``
+#
+# can be used to easily apply the desired quantization technique and then
+# once the model is compiled with ``torch.compile`` with ``max-autotune``, quantization is
+# complete and we can see our speedup.
+#
+# .. note::
+#    You might experience issues with these on older versions of PyTorch. If you run
+#    into an issue, you can use ``apply_dynamic_quant`` and
+#    ``apply_weight_only_int8_quant`` instead as drop in replacement for the two
+#    above (no replacement for int4).
+#
+# The difference between the two APIs is that the ``Int8DynamicActivationInt8WeightConfig`` API
+# alters the weight tensor of the linear module so instead of doing a
+# normal linear, it does a quantized operation. This is helpful when you
+# have non-standard linear ops that do more than one thing. The ``apply``
+# APIs directly swap the linear modules for a quantized module which
+# works on older versions but doesn’t work with non-standard linear
+# modules.
+#
+# In this case Segment Anything is compute-bound so we’ll use dynamic quantization:
+#
+
+del model_c, model, image
+model, image = get_sam_model(only_one_block, batchsize)
+model = model.to(torch.bfloat16)
+image = image.to(torch.bfloat16)
+quantize_(model, Int8DynamicActivationInt8WeightConfig())
+if not TORCH_VERSION_AT_LEAST_2_5:
+    # needed for subclass + compile to work on older versions of pytorch
+    unwrap_tensor_subclass(model)
+model_c = torch.compile(model, mode='max-autotune')
+quant_res = benchmark(model_c, image)
+print(f"bf16 compiled runtime of the quantized block is {quant_res['time']:0.2f}ms and peak memory {quant_res['memory']: 0.2f}GB")
+# bf16 compiled runtime of the quantized block is 19.04ms and peak memory  3.58GB
+
+
+######################################################################
+# With quantization, we have improved performance a bit more but memory usage increased
+# significantly.
+#
+# This is for two reasons:
+#
+# 1) Quantization adds overhead to the model
+#    since we need to quantize and dequantize the input and output. For small
+#    batch sizes this overhead can actually make the model go slower.
+# 2) Even though we are doing a quantized matmul, such as ``int8 x int8``,
+#    the result of the multiplication gets stored in an int32 tensor
+#    which is twice the size of the result from the non-quantized model.
+#    If we can avoid creating this int32 tensor, our memory usage will improve a lot.
+#
+# We can fix #2 by fusing the integer matmul with the subsequent rescale
+# operation since the final output will be bf16, if we immediately convert
+# the int32 tensor to bf16 and instead store that we’ll get better
+# performance in terms of both runtime and memory.
+#
+# The way to do this, is to enable the option
+# ``force_fuse_int_mm_with_mul`` in the inductor config.
+#
+
+del model_c, model, image
+model, image = get_sam_model(only_one_block, batchsize)
+model = model.to(torch.bfloat16)
+image = image.to(torch.bfloat16)
+torch._inductor.config.force_fuse_int_mm_with_mul = True
+quantize_(model, Int8DynamicActivationInt8WeightConfig())
+if not TORCH_VERSION_AT_LEAST_2_5:
+    # needed for subclass + compile to work on older versions of pytorch
+    unwrap_tensor_subclass(model)
+model_c = torch.compile(model, mode='max-autotune')
+quant_res = benchmark(model_c, image)
+print(f"bf16 compiled runtime of the fused quantized block is {quant_res['time']:0.2f}ms and peak memory {quant_res['memory']: 0.2f}GB")
+# bf16 compiled runtime of the fused quantized block is 18.78ms and peak memory  2.37GB
+
+
+######################################################################
+# The fusion improves performance by another small bit (about 6% over the
+# baseline in total) and removes almost all the memory increase, the
+# remaining amount (2.37GB quantized vs 2.24GB unquantized) is due to
+# quantization overhead which cannot be helped.
+#
+# We’re still not done though, we can apply a few general purpose
+# optimizations to get our final best-case performance.
+#
+# 1) We can sometimes improve performance by disabling epilogue fusion
+#    since the autotuning process can be confused by fusions and choose
+#    bad kernel parameters.
+# 2) We can apply coordinate descent tuning in all directions to enlarge
+#    the search area for kernel parameters.
+#
+
+del model_c, model, image
+model, image = get_sam_model(only_one_block, batchsize)
+model = model.to(torch.bfloat16)
+image = image.to(torch.bfloat16)
+torch._inductor.config.epilogue_fusion = False
+torch._inductor.config.coordinate_descent_tuning = True
+torch._inductor.config.coordinate_descent_check_all_directions = True
+torch._inductor.config.force_fuse_int_mm_with_mul = True
+quantize_(model, Int8DynamicActivationInt8WeightConfig())
+if not TORCH_VERSION_AT_LEAST_2_5:
+    # needed for subclass + compile to work on older versions of pytorch
+    unwrap_tensor_subclass(model)
+model_c = torch.compile(model, mode='max-autotune')
+quant_res = benchmark(model_c, image)
+print(f"bf16 compiled runtime of the final quantized block is {quant_res['time']:0.2f}ms and peak memory {quant_res['memory']: 0.2f}GB")
+# bf16 compiled runtime of the final quantized block is 18.16ms and peak memory  2.39GB
+
+
+######################################################################
+# As you can see, we’ve squeezed another small improvement from the model,
+# taking our total improvement to over 10x compared to our original. To
+# get a final estimate of the impact of quantization lets do an apples to
+# apples comparison on the full model since the actual improvement will
+# differ block by block depending on the shapes involved.
+#
+
+try:
+    del model_c, model, image
+    model, image = get_sam_model(False, batchsize)
+    model = model.to(torch.bfloat16)
+    image = image.to(torch.bfloat16)
+    model_c = torch.compile(model, mode='max-autotune')
+    quant_res = benchmark(model_c, image)
+    print(f"bf16 compiled runtime of the compiled full model is {quant_res['time']:0.2f}ms and peak memory {quant_res['memory']: 0.2f}GB")
+    # bf16 compiled runtime of the compiled full model is 729.65ms and peak memory  23.96GB
+
+    del model_c, model, image
+    model, image = get_sam_model(False, batchsize)
+    model = model.to(torch.bfloat16)
+    image = image.to(torch.bfloat16)
+    quantize_(model, Int8DynamicActivationInt8WeightConfig())
+    if not TORCH_VERSION_AT_LEAST_2_5:
+        # needed for subclass + compile to work on older versions of pytorch
+        unwrap_tensor_subclass(model)
+    model_c = torch.compile(model, mode='max-autotune')
+    quant_res = benchmark(model_c, image)
+    print(f"bf16 compiled runtime of the quantized full model is {quant_res['time']:0.2f}ms and peak memory {quant_res['memory']: 0.2f}GB")
+    # bf16 compiled runtime of the quantized full model is 677.28ms and peak memory  24.93GB
+except Exception as e:
+    print("unable to run full model: ", e)
+
+
+
+######################################################################
+# Conclusion
+# -----------------
+# In this tutorial, we have learned about the quantization and optimization techniques
+# on the example of the segment anything model.
+#
+# In the end, we achieved a full-model apples to apples quantization speedup
+# of about 7.7% on batch size 16 (677.28ms to 729.65ms). We can push this a
+# bit further by increasing the batch size and optimizing other parts of
+# the model. For example, this can be done with some form of flash attention.
+#
+# For more information visit
+# `torchao <https://github.com/pytorch/ao>`_ and try it on your own
+# models.
+#
diff --git a/unstable_source/inductor_cpp_wrapper_tutorial.rst b/unstable_source/inductor_cpp_wrapper_tutorial.rst
new file mode 100644
index 00000000000..4bcc9009075
--- /dev/null
+++ b/unstable_source/inductor_cpp_wrapper_tutorial.rst
@@ -0,0 +1,159 @@
+Inductor C++ Wrapper Tutorial
+==============================================================
+
+**Author**: `Chunyuan Wu <https://github.com/chunyuan-w>`_, `Bin Bao <https://github.com/desertfire>`__, `Jiong Gong <https://github.com/jgong5>`__
+
+Prerequisites:
+----------------
+-  `torch.compile and TorchInductor concepts in PyTorch <https://pytorch.org/tutorials/intermediate/torch_compile_tutorial.html>`__
+
+Introduction
+------------
+
+Python, as the primary interface of PyTorch, is easy to use and efficient for development and debugging. 
+The Inductor's default wrapper generates Python code to invoke generated kernels and external kernels.
+However, in deployments requiring high performance, Python, as an interpreted language, runs relatively slower compared to compiled languages.
+
+We implemented an Inductor C++ wrapper by leveraging the PyTorch C++ APIs
+to generate pure C++ code that combines the generated and external kernels.
+This allows for the execution of each captured Dynamo graph in pure C++,
+thereby reducing the Python overhead within the graph.
+
+
+Enabling the API
+----------------
+This feature is still in prototype stage. To activate this feature, add the following to your code:
+
+.. code:: python
+
+    import torch._inductor.config as config
+    config.cpp_wrapper = True
+
+This will speed up your models by reducing the Python overhead of the Inductor wrapper.
+
+
+Example code
+------------
+
+We will use the below frontend code as an example:
+
+.. code:: python
+    
+    import torch
+
+    def fn(x):
+        return torch.tensor(list(range(2, 40, 2)), device=x.device) + x
+
+    x = torch.randn(1)
+    opt_fn = torch.compile()(fn)
+    y = opt_fn(x)
+
+
+**For CPU**
+
+The main part of Inductor-generated code with the default Python wrapper will look like this:
+
+.. code:: python
+
+    def call(args):
+        arg0_1, = args
+        args.clear()
+        assert_size_stride(arg0_1, (1, ), (1, ))
+        buf0 = empty_strided((19, ), (1, ), device='cpu', dtype=torch.float32)
+        cpp_fused_add_lift_fresh_0(c_void_p(constant0.data_ptr()), c_void_p(arg0_1.data_ptr()), c_void_p(buf0.data_ptr()))
+        del arg0_1
+        return (buf0, )
+
+By turning on the C++ wrapper, the generated code for the ``call`` function becomes a C++ function
+``inductor_entry_cpp`` of the C++ extension ``module``:
+
+.. code:: python
+
+    std::vector<at::Tensor> inductor_entry_cpp(const std::vector<at::Tensor>& args) {
+        at::Tensor arg0_1 = args[0];
+        at::Tensor constant0 = args[1];
+        auto buf0 = at::empty_strided({19L, }, {1L, }, at::device(at::kCPU).dtype(at::kFloat));
+        cpp_fused_add_lift_fresh_0((long*)(constant0.data_ptr()), (float*)(arg0_1.data_ptr()), (float*)(buf0.data_ptr()));
+        arg0_1.reset();
+        return {buf0};
+    }
+
+    module = CppWrapperCodeCache.load(cpp_wrapper_src, 'inductor_entry_cpp', 'c2buojsvlqbywxe3itb43hldieh4jqulk72iswa2awalwev7hjn2', False)
+
+    def _wrap_func(f):
+        def g(args):
+            args_tensor = [arg if isinstance(arg, torch.Tensor) else torch.tensor(arg) for arg in args]
+            constants_tensor = [constant0]
+            args_tensor.extend(constants_tensor)                    
+
+            return f(args_tensor)
+        return g
+    call = _wrap_func(module.inductor_entry_cpp)
+
+**For GPU**
+
+Based on the same example code, the generated code for GPU will look like this:
+
+.. code:: python
+
+    def call(args):
+        arg0_1, = args
+        args.clear()
+        assert_size_stride(arg0_1, (1, ), (1, ))
+        with torch.cuda._DeviceGuard(0):
+            torch.cuda.set_device(0) # no-op to ensure context
+            buf0 = empty_strided((19, ), (1, ), device='cuda', dtype=torch.float32)
+            # Source Nodes: [add, tensor], Original ATen: [aten.add, aten.lift_fresh]
+            stream0 = get_cuda_stream(0)
+            triton_poi_fused_add_lift_fresh_0.run(constant0, arg0_1, buf0, 19, grid=grid(19), stream=stream0)
+            run_intermediate_hooks('add', buf0)
+            del arg0_1
+            return (buf0, )
+
+With the C++ wrapper turned on, the below equivalent C++ code will be generated:
+
+.. code:: python
+
+    std::vector<at::Tensor> inductor_entry_cpp(const std::vector<at::Tensor>& args) {
+        at::Tensor arg0_1 = args[0];
+        at::Tensor constant0 = args[1];
+
+        at::cuda::CUDAGuard device_guard(0);
+        auto buf0 = at::empty_strided({19L, }, {1L, }, at::TensorOptions(c10::Device(at::kCUDA, 0)).dtype(at::kFloat));
+        // Source Nodes: [add, tensor], Original ATen: [aten.add, aten.lift_fresh]
+        if (triton_poi_fused_add_lift_fresh_0 == nullptr) {
+            triton_poi_fused_add_lift_fresh_0 = loadKernel("/tmp/torchinductor_user/mm/cmm6xjgijjffxjku4akv55eyzibirvw6bti6uqmfnruujm5cvvmw.cubin", "triton_poi_fused_add_lift_fresh_0_0d1d2d3");
+        }
+        CUdeviceptr var_0 = reinterpret_cast<CUdeviceptr>(constant0.data_ptr());
+        CUdeviceptr var_1 = reinterpret_cast<CUdeviceptr>(arg0_1.data_ptr());
+        CUdeviceptr var_2 = reinterpret_cast<CUdeviceptr>(buf0.data_ptr());
+        auto var_3 = 19;
+        void* kernel_args_var_0[] = {&var_0, &var_1, &var_2, &var_3};
+        cudaStream_t stream0 = at::cuda::getCurrentCUDAStream(0);
+        launchKernel(triton_poi_fused_add_lift_fresh_0, 1, 1, 1, 1, 0, kernel_args_var_0, stream0);
+        arg0_1.reset();
+        return {buf0};
+    }
+
+    module = CppWrapperCodeCache.load(cpp_wrapper_src, 'inductor_entry_cpp', 'czbpeilh4qqmbyejdgsbpdfuk2ss5jigl2qjb7xs4gearrjvuwem', True)
+
+    def _wrap_func(f):
+        def g(args):
+            args_tensor = [arg if isinstance(arg, torch.Tensor) else torch.tensor(arg) for arg in args]
+            constants_tensor = [constant0]
+            args_tensor.extend(constants_tensor)
+
+            return f(args_tensor)
+        return g
+    call = _wrap_func(module.inductor_entry_cpp)
+
+
+Conclusion
+------------
+
+In this tutorial, we introduced a new C++ wrapper in TorchInductor to speed up your models with just two lines of code changes.
+We explained the motivation of this new feature and walked through the easy-to-use API to activate this experimental feature.
+Furthermore, we demonstrated the Inductor-generated code using the default Python wrapper and the new C++ wrapper on both CPU and GPU
+to visually showcase the difference between these two wrappers.
+
+This feature is still in prototype stage. If you have any feature requests or run into any issues, please file a bug report at `GitHub issues <https://github.com/pytorch/pytorch/issues>`_.
diff --git a/unstable_source/inductor_windows.rst b/unstable_source/inductor_windows.rst
new file mode 100644
index 00000000000..871cc48a33e
--- /dev/null
+++ b/unstable_source/inductor_windows.rst
@@ -0,0 +1,105 @@
+How to use ``torch.compile`` on Windows CPU/XPU
+===============================================
+
+**Author**: `Zhaoqiong Zheng <https://github.com/ZhaoqiongZ>`_, `Xu, Han <https://github.com/xuhancn>`_
+
+
+Introduction
+------------
+
+TorchInductor is the new compiler backend that compiles the FX Graphs generated by TorchDynamo into optimized C++/Triton kernels.
+
+This tutorial introduces the steps for using TorchInductor via ``torch.compile`` on Windows CPU/XPU.
+
+
+Software Installation
+---------------------
+
+Now, we will walk you through a step-by-step tutorial for how to use ``torch.compile`` on Windows CPU/XPU.
+
+Install a Compiler
+^^^^^^^^^^^^^^^^^^
+
+C++ compiler is required for TorchInductor optimization, let's take Microsoft Visual C++ (MSVC) as an example.
+
+#. Download and install `MSVC <https://visualstudio.microsoft.com/downloads/>`_.
+
+#. During Installation, select **Workloads** and then **Desktop & Mobile**. Select a checkmark on **Desktop Development with C++** and install.
+
+.. image:: ../_static/img/install_msvc.png
+
+
+.. note::
+
+    Windows CPU inductor also support C++ compiler `LLVM Compiler <https://github.com/llvm/llvm-project/releases>`_ and `Intel Compiler <https://www.intel.com/content/www/us/en/developer/tools/oneapi/dpc-compiler-download.html>`_ for better performance.
+    Please check `Alternative Compiler for better performance on CPU <#alternative-compiler-for-better-performance>`_.
+
+Set Up Environment
+^^^^^^^^^^^^^^^^^^
+Next, let's configure our environment.
+
+#. Open a command line environment via cmd.exe.
+#. Activate ``MSVC`` via below command::
+    
+    "C:/Program Files/Microsoft Visual Studio/2022/Community/VC/Auxiliary/Build/vcvars64.bat"
+#. Create and activate a virtual environment: ::
+
+#. Install `PyTorch 2.5 <https://pytorch.org/get-started/locally/>`_ or later for CPU Usage. Install PyTorch 2.7 or later refer to `Getting Started on Intel GPU <https://pytorch.org/docs/main/notes/get_start_xpu.html>`_ for XPU usage.
+
+#. Here is an example of how to use TorchInductor on Windows:
+
+    .. code-block:: python
+
+        import torch
+        device="cpu" # or "xpu" for XPU
+        def foo(x, y):
+            a = torch.sin(x)
+            b = torch.cos(x)
+            return a + b
+        opt_foo1 = torch.compile(foo)
+        print(opt_foo1(torch.randn(10, 10).to(device), torch.randn(10, 10).to(device)))
+
+#. Below is the output of the above example::
+
+    tensor([[-3.9074e-02,  1.3994e+00,  1.3894e+00,  3.2630e-01,  8.3060e-01,
+            1.1833e+00,  1.4016e+00,  7.1905e-01,  9.0637e-01, -1.3648e+00],
+            [ 1.3728e+00,  7.2863e-01,  8.6888e-01, -6.5442e-01,  5.6790e-01,
+            5.2025e-01, -1.2647e+00,  1.2684e+00, -1.2483e+00, -7.2845e-01],
+            [-6.7747e-01,  1.2028e+00,  1.1431e+00,  2.7196e-02,  5.5304e-01,
+            6.1945e-01,  4.6654e-01, -3.7376e-01,  9.3644e-01,  1.3600e+00],
+            [-1.0157e-01,  7.7200e-02,  1.0146e+00,  8.8175e-02, -1.4057e+00,
+            8.8119e-01,  6.2853e-01,  3.2773e-01,  8.5082e-01,  8.4615e-01],
+            [ 1.4140e+00,  1.2130e+00, -2.0762e-01,  3.3914e-01,  4.1122e-01,
+            8.6895e-01,  5.8852e-01,  9.3310e-01,  1.4101e+00,  9.8318e-01],
+            [ 1.2355e+00,  7.9290e-02,  1.3707e+00,  1.3754e+00,  1.3768e+00,
+            9.8970e-01,  1.1171e+00, -5.9944e-01,  1.2553e+00,  1.3394e+00],
+            [-1.3428e+00,  1.8400e-01,  1.1756e+00, -3.0654e-01,  9.7973e-01,
+            1.4019e+00,  1.1886e+00, -1.9194e-01,  1.3632e+00,  1.1811e+00],
+            [-7.1615e-01,  4.6622e-01,  1.2089e+00,  9.2011e-01,  1.0659e+00,
+            9.0892e-01,  1.1932e+00,  1.3888e+00,  1.3898e+00,  1.3218e+00],
+            [ 1.4139e+00, -1.4000e-01,  9.1192e-01,  3.0175e-01, -9.6432e-01,
+            -1.0498e+00,  1.4115e+00, -9.3212e-01, -9.0964e-01,  1.0127e+00],
+            [ 5.7244e-04,  1.2799e+00,  1.3595e+00,  1.0907e+00,  3.7191e-01,
+            1.4062e+00,  1.3672e+00,  6.8502e-02,  8.5216e-01,  8.6046e-01]])
+
+Alternative Compiler for better performance on CPU
+--------------------------------------------------
+
+To enhance performance for inductor on Windows CPU, you can use the Intel Compiler or LLVM Compiler. However, they rely on the runtime libraries from Microsoft Visual C++ (MSVC). Therefore, your first step should be to install MSVC.
+
+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 via environment variable ``set CXX=icx-cl``.
+
+LLVM Compiler
+^^^^^^^^^^^^^
+
+#. Download and install `LLVM Compiler <https://github.com/llvm/llvm-project/releases>`_ and choose win64 version.
+#. Set Windows Inductor Compiler via environment variable ``set CXX=clang-cl``.
+
+Conclusion
+----------
+
+In this tutorial, we introduce how to use Inductor on Windows CPU with PyTorch 2.5 or later, and on Windows XPU with PyTorch 2.7 or later. We can also use Intel Compiler or LLVM Compiler to get better performance on CPU.
diff --git a/unstable_source/inductor_windows_cpu.rst b/unstable_source/inductor_windows_cpu.rst
new file mode 100644
index 00000000000..24ce55a82f9
--- /dev/null
+++ b/unstable_source/inductor_windows_cpu.rst
@@ -0,0 +1,7 @@
+This tutorial has been moved to https://pytorch.org/tutorials/prototype/inductor_windows.html.
+
+Redirecting in 3 seconds...
+
+.. raw:: html
+
+   <meta http-equiv="Refresh" content="3; url='https://pytorch.org/tutorials/prototype/inductor_windows.html'" />
diff --git a/unstable_source/ios_coreml_workflow.rst b/unstable_source/ios_coreml_workflow.rst
new file mode 100644
index 00000000000..db9abcc5076
--- /dev/null
+++ b/unstable_source/ios_coreml_workflow.rst
@@ -0,0 +1,10 @@
+(Prototype) Convert Mobilenetv2 to Core ML
+==========================================
+
+PyTorch Mobile is no longer actively supported. Please check out `ExecuTorch <https://github.com/pytorch/executorch>`__.
+
+Redirecting in 3 seconds...
+
+.. raw:: html
+
+    <meta http-equiv="Refresh" content="3; url='https://pytorch.org/executorch/stable/index.html'" />
diff --git a/unstable_source/ios_gpu_workflow.rst b/unstable_source/ios_gpu_workflow.rst
new file mode 100644
index 00000000000..8915e1c4fad
--- /dev/null
+++ b/unstable_source/ios_gpu_workflow.rst
@@ -0,0 +1,10 @@
+(Prototype) Use iOS GPU in PyTorch
+==================================
+
+PyTorch Mobile is no longer actively supported. Please check out `ExecuTorch <https://github.com/pytorch/executorch>`__.
+
+Redirecting in 3 seconds...
+
+.. raw:: html
+
+    <meta http-equiv="Refresh" content="3; url='https://pytorch.org/executorch/stable/index.html'" />
diff --git a/unstable_source/lite_interpreter.rst b/unstable_source/lite_interpreter.rst
new file mode 100644
index 00000000000..73e950d72e2
--- /dev/null
+++ b/unstable_source/lite_interpreter.rst
@@ -0,0 +1,9 @@
+(Prototype) Introduce lite interpreter workflow in Android and iOS
+=======================
+
+This tutorial has been moved to https://pytorch.org/tutorials/recipes/mobile_interpreter.html
+
+
+.. raw:: html
+
+   <meta http-equiv="Refresh" content="0; url='https://pytorch.org/tutorials/recipes/mobile_interpreter.html'" />
diff --git a/unstable_source/maskedtensor_adagrad.py b/unstable_source/maskedtensor_adagrad.py
new file mode 100644
index 00000000000..d4eca31c5cb
--- /dev/null
+++ b/unstable_source/maskedtensor_adagrad.py
@@ -0,0 +1,218 @@
+# -*- coding: utf-8 -*-
+
+"""
+Efficiently writing "sparse" semantics for Adagrad with MaskedTensor
+================================================================================
+"""
+
+######################################################################
+# Before working through this tutorial, please review the MaskedTensor
+# `Overview <https://pytorch.org/tutorials/prototype/maskedtensor_overview.html>`__ and
+# `Sparsity <https://pytorch.org/tutorials/prototype/maskedtensor_sparsity.html>`__ tutorials.
+#
+# Introduction and Motivation
+# ---------------------------
+# `Issue 1369 <https://github.com/pytorch/pytorch/issues/1369>`__ discussed the additional lines of code
+# that were introduced while writing "sparse" semantics for Adagrad, but really,
+# the code uses sparsity as a proxy for masked semantics rather than the intended use case of sparsity:
+# a compression and optimization technique.
+# Previously, we worked around the lack of formal masked semantics by introducing one-off semantics and operators
+# while forcing users to be aware of storage details such as indices and values.
+#
+# Now that we have masked semantics, we are better equipped to point out when sparsity is used as a semantic extension.
+# We'll also compare and contrast this with equivalent code written using MaskedTensor.
+# In the end the code snippets are repeated without additional comments to show the difference in brevity.
+#
+# Preparation
+# -----------
+#
+
+import torch
+import warnings
+
+# Disable prototype warnings and such
+warnings.filterwarnings(action='ignore', category=UserWarning)
+
+# Some hyperparameters
+eps = 1e-10
+clr = 0.1
+
+i = torch.tensor([[0, 1, 1], [2, 0, 2]])
+v = torch.tensor([3, 4, 5], dtype=torch.float32)
+grad = torch.sparse_coo_tensor(i, v, [2, 4])
+
+######################################################################
+# Simpler Code with MaskedTensor
+# ------------------------------
+#
+# Before we get too far in the weeds, let's introduce the problem a bit more concretely. We will be taking a look
+# into the `Adagrad (functional) <https://github.com/pytorch/pytorch/blob/6c2f235d368b697072699e5ca9485fd97d0b9bcc/torch/optim/_functional.py#L16-L51>`__
+# implementation in PyTorch with the ultimate goal of simplifying and more faithfully representing the masked approach.
+#
+# For reference, this is the regular, dense code path without masked gradients or sparsity:
+#
+# .. code-block:: python
+#
+#     state_sum.addcmul_(grad, grad, value=1)
+#     std = state_sum.sqrt().add_(eps)
+#     param.addcdiv_(grad, std, value=-clr)
+#
+# The vanilla tensor implementation for sparse is:
+#
+# .. code-block:: python
+#
+#     def _make_sparse(grad, grad_indices, values):
+#         size = grad.size()
+#         if grad_indices.numel() == 0 or values.numel() == 0:
+#             return torch.empty_like(grad)
+#         return torch.sparse_coo_tensor(grad_indices, values, size)
+#
+#     grad = grad.coalesce()  # the update is non-linear so indices must be unique
+#     grad_indices = grad._indices()
+#     grad_values = grad._values()
+#
+#     state_sum.add_(_make_sparse(grad, grad_indices, grad_values.pow(2)))   # a different _make_sparse per layout
+#     std = state_sum.sparse_mask(grad)
+#     std_values = std._values().sqrt_().add_(eps)
+#     param.add_(_make_sparse(grad, grad_indices, grad_values / std_values), alpha=-clr)
+#
+# while :class:`MaskedTensor` minimizes the code to the snippet:
+#
+# .. code-block:: python
+#
+#     state_sum2 = state_sum2 + masked_grad.pow(2).get_data()
+#     std2 = masked_tensor(state_sum2.to_sparse(), mask)
+#     std2 = std2.sqrt().add(eps)
+#     param2 = param2.add((masked_grad / std2).get_data(), alpha=-clr)
+#
+# In this tutorial, we will go through each implementation line by line, but at first glance, we can notice
+# (1) how much shorter the MaskedTensor implementation is, and
+# (2) how it avoids conversions between dense and sparse tensors.
+#
+
+######################################################################
+# Original Sparse Implementation
+# ------------------------------
+#
+# Now, let's break down the code with some inline comments:
+#
+
+def _make_sparse(grad, grad_indices, values):
+    size = grad.size()
+    if grad_indices.numel() == 0 or values.numel() == 0:
+        return torch.empty_like(grad)
+    return torch.sparse_coo_tensor(grad_indices, values, size)
+
+# We don't support sparse gradients
+param = torch.arange(8).reshape(2, 4).float()
+state_sum = torch.full_like(param, 0.5)  # initial value for state sum
+
+grad = grad.coalesce()  # the update is non-linear so indices must be unique
+grad_indices = grad._indices()
+grad_values = grad._values()
+# pow(2) has the same semantics for both sparse and dense memory layouts since 0^2 is zero
+state_sum.add_(_make_sparse(grad, grad_indices, grad_values.pow(2)))
+
+# We take care to make std sparse, even though state_sum clearly is not.
+# This means that we're only applying the gradient to parts of the state_sum
+# for which it is specified. This further drives the point home that the passed gradient is not sparse, but masked.
+# We currently dodge all these concerns using the private method `_values`.
+std = state_sum.sparse_mask(grad)
+std_values = std._values().sqrt_().add_(eps)
+
+# Note here that we currently don't support div for sparse Tensors because zero / zero is not well defined,
+# so we're forced to perform `grad_values / std_values` outside the sparse semantic and then convert back to a
+# sparse tensor with `make_sparse`.
+# We'll later see that MaskedTensor will actually handle these operations for us as well as properly denote
+# undefined / undefined = undefined!
+param.add_(_make_sparse(grad, grad_indices, grad_values / std_values), alpha=-clr)
+
+######################################################################
+# The third to last line -- `std = state_sum.sparse_mask(grad)` -- is where we have a very important divergence.
+#
+# The addition of eps should technically be applied to all values but instead is only applied to specified values.
+# Here we're using sparsity as a semantic extension and to enforce a certain pattern of defined and undefined values.
+# If parts of the values of the gradient are zero, they are still included if materialized even though they
+# could be compressed by other sparse storage layouts. This is theoretically quite brittle!
+# That said, one could argue that eps is always very small, so it might not matter so much in practice.
+#
+# Moreover, an implementation `add_` for sparsity as a storage layout and compression scheme
+# should cause densification, but we force it not to for performance.
+# For this one-off case it is fine.. until we want to introduce new compression scheme, such as
+# `CSC <https://pytorch.org/docs/master/sparse.html#sparse-csc-docs>`__,
+# `BSR <https://pytorch.org/docs/master/sparse.html#sparse-bsr-docs>`__,
+# or `BSC <https://pytorch.org/docs/master/sparse.html#sparse-bsc-docs>`__.
+# We will then need to introduce separate Tensor types for each and write variations for gradients compressed
+# using different storage formats, which is inconvenient and not quite scalable nor clean.
+#
+# MaskedTensor Sparse Implementation
+# ----------------------------------
+#
+# We've been conflating sparsity as an optimization with sparsity as a semantic extension to PyTorch.
+# MaskedTensor proposes to disentangle the sparsity optimization from the semantic extension; for example,
+# currently we can't have dense semantics with sparse storage or masked semantics with dense storage.
+# MaskedTensor enables these ideas by purposefully separating the storage from the semantics.
+#
+# Consider the above example using a masked gradient:
+#
+
+# Let's now import MaskedTensor!
+from torch.masked import masked_tensor
+
+# Create an entirely new set of parameters to avoid errors
+param2 = torch.arange(8).reshape(2, 4).float()
+state_sum2 = torch.full_like(param, 0.5)  # initial value for state sum
+
+mask = (grad.to_dense() != 0).to_sparse()
+masked_grad = masked_tensor(grad, mask)
+
+state_sum2 = state_sum2 + masked_grad.pow(2).get_data()
+std2 = masked_tensor(state_sum2.to_sparse(), mask)
+
+# We can add support for in-place operations later. Notice how this doesn't
+# need to access any storage internals and is in general a lot shorter
+std2 = std2.sqrt().add(eps)
+
+param2 = param2.add((masked_grad / std2).get_data(), alpha=-clr)
+
+######################################################################
+# Note that the implementations look quite similar, but the MaskedTensor implementation is shorter and simpler.
+# In particular, much of the boilerplate code around ``_make_sparse``
+# (and needing to have a separate implementation per layout) is handled for the user with :class:`MaskedTensor`.
+#
+# At this point, let's print both this version and original version for easier comparison:
+#
+
+print("state_sum:\n", state_sum)
+print("state_sum2:\n", state_sum2)
+
+######################################################################
+#
+
+print("std:\n", std)
+print("std2:\n", std2)
+
+######################################################################
+#
+
+print("param:\n", param)
+print("param2:\n", param2)
+
+######################################################################
+# Conclusion
+# ----------
+#
+# In this tutorial, we've discussed how native masked semantics can enable a cleaner developer experience for
+# Adagrad's existing implementation in PyTorch, which used sparsity as a proxy for writing masked semantics.
+# But more importantly, allowing masked semantics to be a first class citizen through MaskedTensor
+# removes the reliance on sparsity or unreliable hacks to mimic masking, thereby allowing for proper independence
+# and development, while enabling sparse semantics, such as this one.
+#
+# Further Reading
+# ---------------
+#
+# To continue learning more, you can find our final review (for now) on
+# `MaskedTensor Advanced Semantics <https://pytorch.org/tutorials/prototype/maskedtensor_advanced_semantics.html>`__
+# to see some of the differences in design decisions between :class:`MaskedTensor` and NumPy's MaskedArray, as well
+# as reduction semantics.
+#
diff --git a/unstable_source/maskedtensor_advanced_semantics.py b/unstable_source/maskedtensor_advanced_semantics.py
new file mode 100644
index 00000000000..3517691611d
--- /dev/null
+++ b/unstable_source/maskedtensor_advanced_semantics.py
@@ -0,0 +1,170 @@
+# -*- coding: utf-8 -*-
+
+"""
+MaskedTensor Advanced Semantics
+===========================================
+"""
+
+######################################################################
+# 
+# Before working on this tutorial, please make sure to review our
+# `MaskedTensor Overview tutorial <https://pytorch.org/tutorials/prototype/maskedtensor_overview.html>`.
+#
+# The purpose of this tutorial is to help users understand how some of the advanced semantics work
+# and how they came to be. We will focus on two particular ones:
+#
+# *. Differences between MaskedTensor and `NumPy's MaskedArray <https://numpy.org/doc/stable/reference/maskedarray.html>`__  
+# *. Reduction semantics
+#
+# Preparation
+# -----------
+#
+
+import torch
+from torch.masked import masked_tensor
+import numpy as np
+import warnings
+
+# Disable prototype warnings and such
+warnings.filterwarnings(action='ignore', category=UserWarning)
+
+######################################################################
+# MaskedTensor vs NumPy's MaskedArray
+# -----------------------------------
+#
+# NumPy's ``MaskedArray`` has a few fundamental semantics differences from MaskedTensor.
+#
+# *. Their factory function and basic definition inverts the mask (similar to ``torch.nn.MHA``); that is, MaskedTensor
+#    uses ``True`` to denote "specified" and ``False`` to denote "unspecified", or "valid"/"invalid",
+#    whereas NumPy does the opposite. We believe that our mask definition is not only more intuitive,
+#    but it also aligns more with the existing semantics in PyTorch as a whole.
+# *. Intersection semantics. In NumPy, if one of two elements are masked out, the resulting element will be
+#    masked out as well -- in practice, they
+#    `apply the logical_or operator <https://github.com/numpy/numpy/blob/68299575d8595d904aff6f28e12d21bf6428a4ba/numpy/ma/core.py#L1016-L1024>`__.
+#
+
+data = torch.arange(5.)
+mask = torch.tensor([True, True, False, True, False])
+npm0 = np.ma.masked_array(data.numpy(), (~mask).numpy())
+npm1 = np.ma.masked_array(data.numpy(), (mask).numpy())
+
+print("npm0:\n", npm0)
+print("npm1:\n", npm1)
+print("npm0 + npm1:\n", npm0 + npm1)
+
+######################################################################
+# Meanwhile, MaskedTensor does not support addition or binary operators with masks that don't match --
+# to understand why, please find the :ref:`section on reductions <reduction-semantics>`.
+#
+
+mt0 = masked_tensor(data, mask)
+mt1 = masked_tensor(data, ~mask)
+print("mt0:\n", mt0)
+print("mt1:\n", mt1)
+
+try:
+    mt0 + mt1
+except ValueError as e:
+    print ("mt0 + mt1 failed. Error: ", e)
+
+######################################################################
+# However, if this behavior is desired, MaskedTensor does support these semantics by giving access to the data and masks
+# and conveniently converting a MaskedTensor to a Tensor with masked values filled in using :func:`to_tensor`.
+# For example:
+#
+
+t0 = mt0.to_tensor(0)
+t1 = mt1.to_tensor(0)
+mt2 = masked_tensor(t0 + t1, mt0.get_mask() & mt1.get_mask())
+
+print("t0:\n", t0)
+print("t1:\n", t1)
+print("mt2 (t0 + t1):\n", mt2)
+
+######################################################################
+# Note that the mask is `mt0.get_mask() & mt1.get_mask()` since :class:`MaskedTensor`'s mask is the inverse of NumPy's.
+#
+# .. _reduction-semantics:
+#
+# Reduction Semantics
+# -------------------
+#
+# Recall in `MaskedTensor's Overview tutorial <https://pytorch.org/tutorials/prototype/maskedtensor_overview.html>`__
+# we discussed "Implementing missing torch.nan* ops". Those are examples of reductions -- operators that remove one
+# (or more) dimensions from a Tensor and then aggregate the result. In this section, we will use reduction semantics
+# to motivate our strict requirements around matching masks from above.
+#
+# Fundamentally, :class:`MaskedTensor`s perform the same reduction operation while ignoring the masked out
+# (unspecified) values. By way of example:
+#
+
+data = torch.arange(12, dtype=torch.float).reshape(3, 4)
+mask = torch.randint(2, (3, 4), dtype=torch.bool)
+mt = masked_tensor(data, mask)
+
+print("data:\n", data)
+print("mask:\n", mask)
+print("mt:\n", mt)
+
+######################################################################
+# Now, the different reductions (all on dim=1):
+#
+
+print("torch.sum:\n", torch.sum(mt, 1))
+print("torch.mean:\n", torch.mean(mt, 1))
+print("torch.prod:\n", torch.prod(mt, 1))
+print("torch.amin:\n", torch.amin(mt, 1))
+print("torch.amax:\n", torch.amax(mt, 1))
+
+######################################################################
+# Of note, the value under a masked out element is not guaranteed to have any specific value, especially if the
+# row or column is entirely masked out (the same is true for normalizations).
+# For more details on masked semantics, you can find this `RFC <https://github.com/pytorch/rfcs/pull/27>`__.
+#
+# Now, we can revisit the question: why do we enforce the invariant that masks must match for binary operators?
+# In other words, why don't we use the same semantics as ``np.ma.masked_array``? Consider the following example:
+#
+
+data0 = torch.arange(10.).reshape(2, 5)
+data1 = torch.arange(10.).reshape(2, 5) + 10
+mask0 = torch.tensor([[True, True, False, False, False], [False, False, False, True, True]])
+mask1 = torch.tensor([[False, False, False, True, True], [True, True, False, False, False]])
+npm0 = np.ma.masked_array(data0.numpy(), (mask0).numpy())
+npm1 = np.ma.masked_array(data1.numpy(), (mask1).numpy())
+
+print("npm0:", npm0)
+print("npm1:", npm1)
+
+######################################################################
+# Now, let's try addition:
+#
+
+print("(npm0 + npm1).sum(0):\n", (npm0 + npm1).sum(0))
+print("npm0.sum(0) + npm1.sum(0):\n", npm0.sum(0) + npm1.sum(0))
+
+######################################################################
+# Sum and addition should clearly be associative, but with NumPy's semantics, they are not,
+# which can certainly be confusing for the user.
+#
+# :class:`MaskedTensor`, on the other hand, will simply not allow this operation since `mask0 != mask1`.
+# That being said, if the user wishes, there are ways around this
+# (for example, filling in the MaskedTensor's undefined elements with 0 values using :func:`to_tensor`
+# like shown below), but the user must now be more explicit with their intentions.
+#
+
+mt0 = masked_tensor(data0, ~mask0)
+mt1 = masked_tensor(data1, ~mask1)
+
+(mt0.to_tensor(0) + mt1.to_tensor(0)).sum(0)
+
+######################################################################
+# Conclusion
+# ----------
+#
+# In this tutorial, we have learned about the different design decisions behind MaskedTensor and
+# NumPy's MaskedArray, as well as reduction semantics.
+# In general, MaskedTensor is designed to avoid ambiguity and confusing semantics (for example, we try to preserve
+# the associative property amongst binary operations), which in turn can necessitate the user
+# to be more intentional with their code at times, but we believe this to be the better move.
+# If you have any thoughts on this, please `let us know <https://github.com/pytorch/pytorch/issues>`__!
+# 
diff --git a/unstable_source/maskedtensor_overview.py b/unstable_source/maskedtensor_overview.py
new file mode 100644
index 00000000000..955268e0d76
--- /dev/null
+++ b/unstable_source/maskedtensor_overview.py
@@ -0,0 +1,333 @@
+# -*- coding: utf-8 -*-
+
+"""
+MaskedTensor Overview
+*********************************
+"""
+
+######################################################################
+# This tutorial is designed to serve as a starting point for using MaskedTensors
+# and discuss its masking semantics.
+#
+# MaskedTensor serves as an extension to :class:`torch.Tensor` that provides the user with the ability to:
+#
+# * use any masked semantics (for example, variable length tensors, nan* operators, etc.)
+# * differentiation between 0 and NaN gradients
+# * various sparse applications (see tutorial below)
+#
+# For a more detailed introduction on what MaskedTensors are, please find the
+# `torch.masked documentation <https://pytorch.org/docs/master/masked.html>`__.
+#
+# Using MaskedTensor
+# ==================
+#
+# In this section we discuss how to use MaskedTensor including how to construct, access, the data
+# and mask, as well as indexing and slicing.
+#
+# Preparation
+# -----------
+#
+# We'll begin by doing the necessary setup for the tutorial:
+#
+
+import torch
+from torch.masked import masked_tensor, as_masked_tensor
+import warnings
+
+# Disable prototype warnings and such
+warnings.filterwarnings(action='ignore', category=UserWarning)
+
+######################################################################
+# Construction
+# ------------
+#
+# There are a few different ways to construct a MaskedTensor:
+#
+# * The first way is to directly invoke the MaskedTensor class
+# * The second (and our recommended way) is to use :func:`masked.masked_tensor` and :func:`masked.as_masked_tensor`
+#   factory functions, which are analogous to :func:`torch.tensor` and :func:`torch.as_tensor`
+#
+# Throughout this tutorial, we will be assuming the import line: `from torch.masked import masked_tensor`.
+#
+# Accessing the data and mask
+# ---------------------------
+#
+# The underlying fields in a MaskedTensor can be accessed through:
+#
+# * the :meth:`MaskedTensor.get_data` function
+# * the :meth:`MaskedTensor.get_mask` function. Recall that ``True`` indicates "specified" or "valid"
+#   while ``False`` indicates "unspecified" or "invalid".
+#
+# In general, the underlying data that is returned may not be valid in the unspecified entries, so we recommend that
+# when users require a Tensor without any masked entries, that they use :meth:`MaskedTensor.to_tensor` (as shown above) to
+# return a Tensor with filled values.
+#
+# Indexing and slicing
+# --------------------
+#
+# :class:`MaskedTensor` is a Tensor subclass, which means that it inherits the same semantics for indexing and slicing
+# as :class:`torch.Tensor`. Below are some examples of common indexing and slicing patterns:
+#
+
+data = torch.arange(24).reshape(2, 3, 4)
+mask = data % 2 == 0
+
+print("data:\n", data)
+print("mask:\n", mask)
+
+######################################################################
+#
+
+# float is used for cleaner visualization when being printed
+mt = masked_tensor(data.float(), mask)
+
+print("mt[0]:\n", mt[0])
+print("mt[:, :, 2:4]:\n", mt[:, :, 2:4])
+
+######################################################################
+# Why is MaskedTensor useful?
+# ===========================
+#
+# Because of :class:`MaskedTensor`'s treatment of specified and unspecified values as a first-class citizen
+# instead of an afterthought (with filled values, nans, etc.), it is able to solve for several of the shortcomings
+# that regular Tensors are unable to; indeed, :class:`MaskedTensor` was born in a large part due to these recurring issues.
+#
+# Below, we will discuss some of the most common issues that are still unresolved in PyTorch today
+# and illustrate how :class:`MaskedTensor` can solve these problems.
+#
+# Distinguishing between 0 and NaN gradient
+# -----------------------------------------
+#
+# One issue that :class:`torch.Tensor` runs into is the inability to distinguish between gradients that are
+# undefined (NaN) vs. gradients that are actually 0. Because PyTorch does not have a way of marking a value
+# as specified/valid vs. unspecified/invalid, it is forced to rely on NaN or 0 (depending on the use case), leading
+# to unreliable semantics since many operations aren't meant to handle NaN values properly. What is even more confusing
+# is that sometimes depending on the order of operations, the gradient could vary (for example, depending on how early
+# in the chain of operations a NaN value manifests).
+#
+# :class:`MaskedTensor` is the perfect solution for this!
+#
+# torch.where
+# ^^^^^^^^^^^
+#
+# In `Issue 10729 <https://github.com/pytorch/pytorch/issues/10729>`__, we notice a case where the order of operations
+# can matter when using :func:`torch.where` because we have trouble differentiating between if the 0 is a real 0
+# or one from undefined gradients. Therefore, we remain consistent and mask out the results:
+#
+# Current result:
+#
+
+x = torch.tensor([-10., -5, 0, 5, 10, 50, 60, 70, 80, 90, 100], requires_grad=True, dtype=torch.float)
+y = torch.where(x < 0, torch.exp(x), torch.ones_like(x))
+y.sum().backward()
+x.grad
+
+######################################################################
+# :class:`MaskedTensor` result:
+#
+
+x = torch.tensor([-10., -5, 0, 5, 10, 50, 60, 70, 80, 90, 100])
+mask = x < 0
+mx = masked_tensor(x, mask, requires_grad=True)
+my = masked_tensor(torch.ones_like(x), ~mask, requires_grad=True)
+y = torch.where(mask, torch.exp(mx), my)
+y.sum().backward()
+mx.grad
+
+######################################################################
+# The gradient here is only provided to the selected subset. Effectively, this changes the gradient of `where`
+# to mask out elements instead of setting them to zero.
+#
+# Another torch.where
+# ^^^^^^^^^^^^^^^^^^^
+#
+# `Issue 52248 <https://github.com/pytorch/pytorch/issues/52248>`__ is another example.
+#
+# Current result:
+#
+
+a = torch.randn((), requires_grad=True)
+b = torch.tensor(False)
+c = torch.ones(())
+print("torch.where(b, a/0, c):\n", torch.where(b, a/0, c))
+print("torch.autograd.grad(torch.where(b, a/0, c), a):\n", torch.autograd.grad(torch.where(b, a/0, c), a))
+
+######################################################################
+# :class:`MaskedTensor` result:
+#
+
+a = masked_tensor(torch.randn(()), torch.tensor(True), requires_grad=True)
+b = torch.tensor(False)
+c = torch.ones(())
+print("torch.where(b, a/0, c):\n", torch.where(b, a/0, c))
+print("torch.autograd.grad(torch.where(b, a/0, c), a):\n", torch.autograd.grad(torch.where(b, a/0, c), a))
+
+######################################################################
+# This issue is similar (and even links to the next issue below) in that it expresses frustration with
+# unexpected behavior because of the inability to differentiate "no gradient" vs "zero gradient",
+# which in turn makes working with other ops difficult to reason about.
+#
+# When using mask, x/0 yields NaN grad
+# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#
+# In `Issue 4132 <https://github.com/pytorch/pytorch/issues/4132>`__, the user proposes that
+# `x.grad` should be `[0, 1]` instead of the `[nan, 1]`,
+# whereas :class:`MaskedTensor` makes this very clear by masking out the gradient altogether.
+#
+# Current result:
+#
+
+x = torch.tensor([1., 1.], requires_grad=True)
+div = torch.tensor([0., 1.])
+y = x/div # => y is [inf, 1]
+mask = (div != 0)  # => mask is [0, 1]
+y[mask].backward()
+x.grad
+
+######################################################################
+# :class:`MaskedTensor` result:
+#
+
+x = torch.tensor([1., 1.], requires_grad=True)
+div = torch.tensor([0., 1.])
+y = x/div # => y is [inf, 1]
+mask = (div != 0) # => mask is [0, 1]
+loss = as_masked_tensor(y, mask)
+loss.sum().backward()
+x.grad
+
+######################################################################
+# :func:`torch.nansum` and :func:`torch.nanmean`
+# ----------------------------------------------
+#
+# In `Issue 67180 <https://github.com/pytorch/pytorch/issues/67180>`__,
+# the gradient isn't calculate properly (a longstanding issue), whereas :class:`MaskedTensor` handles it correctly.
+#
+# Current result:
+#
+
+a = torch.tensor([1., 2., float('nan')])
+b = torch.tensor(1.0, requires_grad=True)
+c = a * b
+c1 = torch.nansum(c)
+bgrad1, = torch.autograd.grad(c1, b, retain_graph=True)
+bgrad1
+
+######################################################################
+# :class:`MaskedTensor` result:
+#
+
+a = torch.tensor([1., 2., float('nan')])
+b = torch.tensor(1.0, requires_grad=True)
+mt = masked_tensor(a, ~torch.isnan(a))
+c = mt * b
+c1 = torch.sum(c)
+bgrad1, = torch.autograd.grad(c1, b, retain_graph=True)
+bgrad1
+
+######################################################################
+# Safe Softmax
+# ------------
+#
+# Safe softmax is another great example of `an issue <https://github.com/pytorch/pytorch/issues/55056>`__
+# that arises frequently. In a nutshell, if there is an entire batch that is "masked out"
+# or consists entirely of padding (which, in the softmax case, translates to being set `-inf`),
+# then this will result in NaNs, which can lead to training divergence.
+#
+# Luckily, :class:`MaskedTensor` has solved this issue. Consider this setup:
+#
+
+data = torch.randn(3, 3)
+mask = torch.tensor([[True, False, False], [True, False, True], [False, False, False]])
+x = data.masked_fill(~mask, float('-inf'))
+mt = masked_tensor(data, mask)
+print("x:\n", x)
+print("mt:\n", mt)
+
+######################################################################
+# For example, we want to calculate the softmax along `dim=0`. Note that the second column is "unsafe" (i.e. entirely
+# masked out), so when the softmax is calculated, the result will yield `0/0 = nan` since `exp(-inf) = 0`.
+# However, what we would really like is for the gradients to be masked out since they are unspecified and would be
+# invalid for training.
+#
+# PyTorch result:
+#
+
+x.softmax(0)
+
+######################################################################
+# :class:`MaskedTensor` result:
+#
+
+mt.softmax(0)
+
+######################################################################
+# Implementing missing torch.nan* operators
+# -----------------------------------------
+#
+# In `Issue 61474 <https://github.com/pytorch/pytorch/issues/61474>`__,
+# there is a request to add additional operators to cover the various `torch.nan*` applications,
+# such as ``torch.nanmax``, ``torch.nanmin``, etc.
+#
+# In general, these problems lend themselves more naturally to masked semantics, so instead of introducing additional
+# operators, we propose using :class:`MaskedTensor` instead.
+# Since `nanmean has already landed <https://github.com/pytorch/pytorch/issues/21987>`__,
+# we can use it as a comparison point:
+#
+
+x = torch.arange(16).float()
+y = x * x.fmod(4)
+z = y.masked_fill(y == 0, float('nan'))  # we want to get the mean of y when ignoring the zeros
+
+######################################################################
+#
+print("y:\n", y)
+# z is just y with the zeros replaced with nan's
+print("z:\n", z)
+
+######################################################################
+#
+
+print("y.mean():\n", y.mean())
+print("z.nanmean():\n", z.nanmean())
+# MaskedTensor successfully ignores the 0's
+print("torch.mean(masked_tensor(y, y != 0)):\n", torch.mean(masked_tensor(y, y != 0)))
+
+######################################################################
+# In the above example, we've constructed a `y` and would like to calculate the mean of the series while ignoring
+# the zeros. `torch.nanmean` can be used to do this, but we don't have implementations for the rest of the
+# `torch.nan*` operations. :class:`MaskedTensor` solves this issue by being able to use the base operation,
+# and we already have support for the other operations listed in the issue. For example:
+#
+
+torch.argmin(masked_tensor(y, y != 0))
+
+######################################################################
+# Indeed, the index of the minimum argument when ignoring the 0's is the 1 in index 1.
+#
+# :class:`MaskedTensor` can also support reductions when the data is fully masked out, which is equivalent
+# to the case above when the data Tensor is completely ``nan``. ``nanmean`` would return ``nan``
+# (an ambiguous return value), while MaskedTensor would more accurately indicate a masked out result.
+#
+
+x = torch.empty(16).fill_(float('nan'))
+print("x:\n", x)
+print("torch.nanmean(x):\n", torch.nanmean(x))
+print("torch.nanmean via maskedtensor:\n", torch.mean(masked_tensor(x, ~torch.isnan(x))))
+
+######################################################################
+# This is a similar problem to safe softmax where `0/0 = nan` when what we really want is an undefined value.
+#
+# Conclusion
+# ==========
+#
+# In this tutorial, we've introduced what MaskedTensors are, demonstrated how to use them, and motivated their
+# value through a series of examples and issues that they've helped resolve.
+#
+# Further Reading
+# ===============
+#
+# To continue learning more, you can find our
+# `MaskedTensor Sparsity tutorial <https://pytorch.org/tutorials/prototype/maskedtensor_sparsity.html>`__
+# to see how MaskedTensor enables sparsity and the different storage formats we currently support.
+#
diff --git a/unstable_source/maskedtensor_sparsity.py b/unstable_source/maskedtensor_sparsity.py
new file mode 100644
index 00000000000..a1353805f1d
--- /dev/null
+++ b/unstable_source/maskedtensor_sparsity.py
@@ -0,0 +1,315 @@
+# -*- coding: utf-8 -*-
+
+"""
+MaskedTensor Sparsity
+=================================
+"""
+
+######################################################################
+# Before working on this tutorial, please make sure to review our
+# `MaskedTensor Overview tutorial <https://pytorch.org/tutorials/prototype/maskedtensor_overview.html>`.
+#
+# Introduction
+# ------------
+#
+# Sparsity has been an area of rapid growth and importance within PyTorch; if any sparsity terms are confusing below,
+# please refer to the `sparsity tutorial <https://pytorch.org/docs/stable/sparse.html>`__ for additional details.
+#
+# Sparse storage formats have been proven to be powerful in a variety of ways. As a primer, the first use case
+# most practitioners think about is when the majority of elements are equal to zero (a high degree of sparsity),
+# but even in cases of lower sparsity, certain formats (e.g. BSR) can take advantage of substructures within a matrix.
+#
+# .. note::
+#
+#     At the moment, MaskedTensor supports COO and CSR tensors with plans to support additional formats
+#     (such as BSR and CSC) in the future. If you have any requests for additional formats,
+#     please file a feature request `here <https://github.com/pytorch/pytorch/issues>`__!
+#
+# Principles
+# ----------
+#
+# When creating a :class:`MaskedTensor` with sparse tensors, there are a few principles that must be observed:
+#
+# 1. ``data`` and ``mask`` must have the same storage format, whether that's :attr:`torch.strided`, :attr:`torch.sparse_coo`, or :attr:`torch.sparse_csr`
+# 2. ``data`` and ``mask`` must have the same size, indicated by :func:`size()`
+#
+# .. _sparse-coo-tensors:
+#
+# Sparse COO tensors
+# ------------------
+#
+# In accordance with Principle #1, a sparse COO MaskedTensor is created by passing in two sparse COO tensors,
+# which can be initialized by any of its constructors, for example :func:`torch.sparse_coo_tensor`.
+#
+# As a recap of `sparse COO tensors <https://pytorch.org/docs/stable/sparse.html#sparse-coo-tensors>`__, the COO format
+# stands for "coordinate format", where the specified elements are stored as tuples of their indices and the
+# corresponding values. That is, the following are provided:
+#
+# * ``indices``: array of size ``(ndim, nse)`` and dtype ``torch.int64``
+# * ``values``: array of size `(nse,)` with any integer or floating point dtype
+#
+# where ``ndim`` is the dimensionality of the tensor and ``nse`` is the number of specified elements.
+#
+# For both sparse COO and CSR tensors, you can construct a :class:`MaskedTensor` by doing either:
+#
+# 1. ``masked_tensor(sparse_tensor_data, sparse_tensor_mask)``
+# 2. ``dense_masked_tensor.to_sparse_coo()`` or ``dense_masked_tensor.to_sparse_csr()``
+#
+# The second method is easier to illustrate so we've shown that below, but for more on the first and the nuances behind
+# the approach, please read the :ref:`Sparse COO Appendix <sparse-coo-appendix>`.
+#
+
+import torch
+from torch.masked import masked_tensor
+import warnings
+
+# Disable prototype warnings and such
+warnings.filterwarnings(action='ignore', category=UserWarning)
+
+values = torch.tensor([[0, 0, 3], [4, 0, 5]])
+mask = torch.tensor([[False, False, True], [False, False, True]])
+mt = masked_tensor(values, mask)
+sparse_coo_mt = mt.to_sparse_coo()
+
+print("mt:\n", mt)
+print("mt (sparse coo):\n", sparse_coo_mt)
+print("mt data (sparse coo):\n", sparse_coo_mt.get_data())
+
+######################################################################
+# Sparse CSR tensors
+# ------------------
+#
+# Similarly, :class:`MaskedTensor` also supports the
+# `CSR (Compressed Sparse Row) <https://pytorch.org/docs/stable/sparse.html#sparse-csr-tensor>`__
+# sparse tensor format. Instead of storing the tuples of the indices like sparse COO tensors, sparse CSR tensors
+# aim to decrease the memory requirements by storing compressed row indices.
+# In particular, a CSR sparse tensor consists of three 1-D tensors:
+#
+# * ``crow_indices``: array of compressed row indices with size ``(size[0] + 1,)``. This array indicates which row
+#   a given entry in values lives in. The last element is the number of specified elements,
+#   while `crow_indices[i+1] - crow_indices[i]` indicates the number of specified elements in row i.
+# * ``col_indices``: array of size ``(nnz,)``. Indicates the column indices for each value.
+# * ``values``: array of size ``(nnz,)``. Contains the values of the CSR tensor.
+#
+# Of note, both sparse COO and CSR tensors are in a `beta <https://pytorch.org/docs/stable/index.html>`__ state.
+#
+# By way of example:
+#
+
+mt_sparse_csr = mt.to_sparse_csr()
+
+print("mt (sparse csr):\n", mt_sparse_csr)
+print("mt data (sparse csr):\n", mt_sparse_csr.get_data())
+
+######################################################################
+# Supported Operations
+# --------------------
+#
+# Unary
+# ^^^^^
+# All `unary operators <https://pytorch.org/docs/master/masked.html#unary-operators>`__ are supported, e.g.:
+#
+
+mt.sin()
+
+######################################################################
+# Binary
+# ^^^^^^
+# `Binary operators <https://pytorch.org/docs/master/masked.html#unary-operators>`__ are also supported, but the
+# input masks from the two masked tensors must match. For more information on why this decision was made, please
+# find our `MaskedTensor: Advanced Semantics tutorial <https://pytorch.org/tutorials/prototype/maskedtensor_advanced_semantics.html>`__.
+#
+# Please find an example below:
+#
+
+i = [[0, 1, 1],
+     [2, 0, 2]]
+v1 = [3, 4, 5]
+v2 = [20, 30, 40]
+m = torch.tensor([True, False, True])
+
+s1 = torch.sparse_coo_tensor(i, v1, (2, 3))
+s2 = torch.sparse_coo_tensor(i, v2, (2, 3))
+mask = torch.sparse_coo_tensor(i, m, (2, 3))
+
+mt1 = masked_tensor(s1, mask)
+mt2 = masked_tensor(s2, mask)
+
+print("mt1:\n", mt1)
+print("mt2:\n", mt2)
+
+######################################################################
+#
+
+print("torch.div(mt2, mt1):\n", torch.div(mt2, mt1))
+print("torch.mul(mt1, mt2):\n", torch.mul(mt1, mt2))
+
+######################################################################
+# Reductions
+# ^^^^^^^^^^
+# Finally, `reductions <https://pytorch.org/docs/master/masked.html#reductions>`__ are supported:
+#
+
+mt
+
+######################################################################
+#
+
+print("mt.sum():\n", mt.sum())
+print("mt.sum(dim=1):\n", mt.sum(dim=1))
+print("mt.amin():\n", mt.amin())
+
+######################################################################
+# MaskedTensor Helper Methods
+# ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+# For convenience, :class:`MaskedTensor` has a number of methods to help convert between the different layouts
+# and identify the current layout:
+#
+# Setup:
+#
+
+v = [[3, 0, 0],
+     [0, 4, 5]]
+m = [[True, False, False],
+     [False, True, True]]
+
+mt = masked_tensor(torch.tensor(v), torch.tensor(m))
+mt
+
+######################################################################
+# :meth:`MaskedTensor.to_sparse_coo()` / :meth:`MaskedTensor.to_sparse_csr()` / :meth:`MaskedTensor.to_dense()`
+# to help convert between the different layouts.
+#
+
+mt_sparse_coo = mt.to_sparse_coo()
+mt_sparse_csr = mt.to_sparse_csr()
+mt_dense = mt_sparse_coo.to_dense()
+
+######################################################################
+# :meth:`MaskedTensor.is_sparse` -- this will check if the :class:`MaskedTensor`'s layout
+# matches any of the supported sparse layouts (currently COO and CSR).
+#
+
+print("mt_dense.is_sparse: ", mt_dense.is_sparse)
+print("mt_sparse_coo.is_sparse: ", mt_sparse_coo.is_sparse)
+print("mt_sparse_csr.is_sparse: ", mt_sparse_csr.is_sparse)
+
+######################################################################
+# :meth:`MaskedTensor.is_sparse_coo()`
+#
+
+print("mt_dense.is_sparse_coo(): ", mt_dense.is_sparse_coo())
+print("mt_sparse_coo.is_sparse_coo: ", mt_sparse_coo.is_sparse_coo())
+print("mt_sparse_csr.is_sparse_coo: ", mt_sparse_csr.is_sparse_coo())
+
+######################################################################
+# :meth:`MaskedTensor.is_sparse_csr()`
+#
+
+print("mt_dense.is_sparse_csr(): ", mt_dense.is_sparse_csr())
+print("mt_sparse_coo.is_sparse_csr: ", mt_sparse_coo.is_sparse_csr())
+print("mt_sparse_csr.is_sparse_csr: ", mt_sparse_csr.is_sparse_csr())
+
+######################################################################
+# Appendix
+# --------
+#
+# .. _sparse-coo-appendix:
+#
+# Sparse COO Construction
+# ^^^^^^^^^^^^^^^^^^^^^^^
+#
+# Recall in our :ref:`original example <sparse-coo-tensors>`, we created a :class:`MaskedTensor`
+# and then converted it to a sparse COO MaskedTensor with :meth:`MaskedTensor.to_sparse_coo`.
+#
+# Alternatively, we can also construct a sparse COO MaskedTensor directly by passing in two sparse COO tensors:
+#
+
+values = torch.tensor([[0, 0, 3], [4, 0, 5]]).to_sparse()
+mask = torch.tensor([[False, False, True], [False, False, True]]).to_sparse()
+mt = masked_tensor(values, mask)
+
+print("values:\n", values)
+print("mask:\n", mask)
+print("mt:\n", mt)
+
+######################################################################
+# Instead of using :meth:`torch.Tensor.to_sparse`, we can also create the sparse COO tensors directly,
+# which brings us to a warning:
+#
+# .. warning::
+#
+#   When using a function like :meth:`MaskedTensor.to_sparse_coo` (analogous to :meth:`Tensor.to_sparse`),
+#   if the user does not specify the indices like in the above example,
+#   then the 0 values will be "unspecified" by default.
+#
+# Below, we explicitly specify the 0's:
+#
+
+i = [[0, 1, 1],
+     [2, 0, 2]]
+v = [3, 4, 5]
+m = torch.tensor([True, False, True])
+values = torch.sparse_coo_tensor(i, v, (2, 3))
+mask = torch.sparse_coo_tensor(i, m, (2, 3))
+mt2 = masked_tensor(values, mask)
+
+print("values:\n", values)
+print("mask:\n", mask)
+print("mt2:\n", mt2)
+
+######################################################################
+# Note that ``mt`` and ``mt2`` look identical on the surface, and in the vast majority of operations, will yield the same
+# result. But this brings us to a detail on the implementation:
+#
+# ``data`` and ``mask`` -- only for sparse MaskedTensors -- can have a different number of elements (:func:`nnz`)
+# **at creation**, but the indices of ``mask`` must then be a subset of the indices of ``data``. In this case,
+# ``data`` will assume the shape of ``mask`` by ``data = data.sparse_mask(mask)``; in other words, any of the elements
+# in ``data`` that are not ``True`` in ``mask`` (that is, not specified) will be thrown away.
+#
+# Therefore, under the hood, the data looks slightly different; ``mt2`` has the "4" value masked out and ``mt``
+# is completely without it. Their underlying data has different shapes,
+# which would make operations like ``mt + mt2`` invalid.
+#
+
+print("mt data:\n", mt.get_data())
+print("mt2 data:\n", mt2.get_data())
+
+######################################################################
+# .. _sparse-csr-appendix:
+#
+# Sparse CSR Construction
+# ^^^^^^^^^^^^^^^^^^^^^^^
+#
+# We can also construct a sparse CSR MaskedTensor using sparse CSR tensors,
+# and like the example above, this results in a similar treatment under the hood.
+#
+
+crow_indices = torch.tensor([0, 2, 4])
+col_indices = torch.tensor([0, 1, 0, 1])
+values = torch.tensor([1, 2, 3, 4])
+mask_values = torch.tensor([True, False, False, True])
+
+csr = torch.sparse_csr_tensor(crow_indices, col_indices, values, dtype=torch.double)
+mask = torch.sparse_csr_tensor(crow_indices, col_indices, mask_values, dtype=torch.bool)
+mt = masked_tensor(csr, mask)
+
+print("mt:\n", mt)
+print("mt data:\n", mt.get_data())
+
+######################################################################
+# Conclusion
+# ----------
+# In this tutorial, we have introduced how to use :class:`MaskedTensor` with sparse COO and CSR formats and
+# discussed some of the subtleties under the hood in case users decide to access the underlying data structures
+# directly. Sparse storage formats and masked semantics indeed have strong synergies, so much so that they are
+# sometimes used as proxies for each other (as we will see in the next tutorial). In the future, we certainly plan
+# to invest and continue developing in this direction.
+#
+# Further Reading
+# ---------------
+#
+# To continue learning more, you can find our
+# `Efficiently writing "sparse" semantics for Adagrad with MaskedTensor tutorial <https://pytorch.org/tutorials/prototype/maskedtensor_adagrad.html>`__
+# to see an example of how MaskedTensor can simplify existing workflows with native masking semantics.
+#
diff --git a/unstable_source/max_autotune_on_CPU_tutorial.rst b/unstable_source/max_autotune_on_CPU_tutorial.rst
new file mode 100644
index 00000000000..47374744938
--- /dev/null
+++ b/unstable_source/max_autotune_on_CPU_tutorial.rst
@@ -0,0 +1,215 @@
+Using Max-Autotune Compilation on CPU for Better Performance
+================================================================================
+
+**Author**: `Jiong Gong <https://github.com/jgong5>`__, `Leslie Fang <https://github.com/leslie-fang-intel>`__, `Chunyuan Wu <https://github.com/chunyuan-w>`__
+
+In this tutorial, you will learn how to boost your PyTorch models' performance on CPU by 
+leveraging the max-autotune mode in the Inductor CPU backend. Explore the activation
+process, understand the differences from traditional methods, and integrate max-autotune
+into your code for enhanced computational efficiency. Dive into the use of advanced
+GEMM templates for faster processing and superior runtime performance.
+
+Prerequisites:
+----------------
+-  `torch.compile and TorchInductor concepts in PyTorch <https://pytorch.org/tutorials/intermediate/torch_compile_tutorial.html>`__
+
+Introduction
+------------
+The ``max-autotune`` mode for the Inductor CPU backend in ``torch.compile`` (`RFC link <https://github.com/pytorch/pytorch/issues/125683>`_)
+profiles multiple implementations of operations at compile time and selects the best-performing one,
+trading longer compilation times for improved runtime performance. This enhancement is particularly beneficial for GEMM-related operations.
+In the Inductor CPU backend, we’ve introduced a C++ template-based GEMM implementation as an alternative to the ATen-based approach that relies on oneDNN and MKL libraries.
+This is similar to the max-autotune mode on CUDA, where implementations from ATen, Triton, and CUTLASS are considered.
+
+We have covered most popular data types, including FP32, BF16, FP16, and INT8, with epilogue fusions for x86 CPUs.
+
+While the development is still in progress, we have already seen promising speedups over pure ATen-based GEMMs as measured by the three benchmark suites and the inference of LLMs. 
+
+Activating the ``max-autotune`` mode
+-------------------------------------
+To activate the ``max-autotune`` mode in PyTorch, set the ``mode`` argument to ``max-autotune`` when compiling your model using ``torch.compile``.
+If you prefer to bypass the tuning process and always use the C++ template implementations, you can configure this via an environment variable: 
+``export TORCHINDUCTOR_MAX_AUTOTUNE_GEMM_BACKENDS=CPP``.
+
+
+Example
+------------
+The below code is an example of using the ``max-autotune`` mode on a simple neural network with a linear layer followed by a ReLU activation.
+
+In the C++ template-based GEMM implementation, we will pre-pack the weight for good cache usage.
+In the case of inference which is the primary scenario of CPU AI workloads,
+model weights are constant and we pack them upfront during compilation
+so that the data accesses are contiguous within the cache blocks.
+Thus, We only support frozen model with ``torch.no_grad`` or the inference mode.
+You need to set the environment variable ``export TORCHINDUCTOR_FREEZING=1``
+and ensure that both the compilation and inference steps are executed within the ``torch.no_grad`` context.
+
+.. code:: python
+
+    import torch
+    from torch._inductor import config
+    config.trace.log_autotuning_results = True # enable the log of autotuning results
+
+    class M(torch.nn.Module):
+        def __init__(
+            self,
+            in_features,
+            out_features,
+            bias,
+            **kwargs,
+        ):
+            super().__init__()
+            self.linear = torch.nn.Linear(
+                in_features,
+                out_features,
+                bias,
+                **kwargs,
+            )
+            self.relu = torch.nn.ReLU()
+
+        def forward(self, x):
+            x = self.linear(x)
+            x = self.relu(x)
+            return x
+
+    amp_enabled = True
+    batch_size = 64
+    in_features = 16
+    out_features = 32
+    bias = True
+
+    x = torch.randn(batch_size, in_features)
+    model = M(in_features, out_features, bias)
+
+    with torch.no_grad(), torch.cpu.amp.autocast(enabled=amp_enabled):
+        compiled = torch.compile(model, mode="max-autotune") # turn on "max-autotune" mode
+        y = compiled(x)
+
+
+When running the above code snippet, you will see the autotuning result (the performance numbers are for demonstration purposes).
+In this example, C++ template outperforms ATen kernel so that it will be selected.
+
+.. code:: shell
+
+    AUTOTUNE linear_unary(64x16, 32x16, 32)
+    cpp_packed_gemm_0 0.2142 ms 100.0% 
+    _linear_pointwise 0.2441 ms 87.7% 
+
+
+We could check the generated output code by setting ``export TORCH_LOGS="+output_code"``.
+When C++ template is selected, we won't have ``torch.ops.mkldnn._linear_pointwise.default`` (for bfloat16) or ``torch.ops.mkl._mkl_linear.default`` (for float32)
+in the generated code anymore, instead, we'll find kernel based on CPP GEMM template ``cpp_fused__to_copy_relu_1``
+(only part of the code is demonstrated below for simplicity) with the bias and relu epilogues fused inside the C++ GEMM template kernel.
+
+The generated code differs by CPU architecture and is implementation-specific, which is subject to change.
+
+.. code:: python
+
+    cpp_fused__to_copy_relu_1 = async_compile.cpp_pybinding(['const bfloat16*', 'const bfloat16*', 'const bfloat16*', 'bfloat16*'], '''
+    
+    ...
+
+    template <bool accum>
+    inline void kernel_micro_gemm_amx_kernel_32_2(
+        AMXState& amx_state,
+        const bfloat16* __restrict__ A,
+        const bfloat16* __restrict__ B,
+        float* __restrict__ C,
+        int64_t K,
+        int64_t lda,
+        int64_t ldb,
+        int64_t ldc,
+        uint8_t tilecfg_rows
+    ) {
+        ...
+    }
+    
+    ...
+
+    template <bool accum>
+    inline void kernel_micro_gemm(
+        AMXState& amx_state,
+        const bfloat16* __restrict__ A,
+        const bfloat16* __restrict__ B,
+        float* __restrict__ C,
+        int64_t M,
+        int64_t N,
+        int64_t K,
+        int64_t lda,
+        int64_t ldb,
+        int64_t ldc
+    ) {
+        ...
+    }
+
+    extern "C" 
+    void kernel(const bfloat16* X, const bfloat16* W, const bfloat16* inp, bfloat16* Y)
+    {
+        constexpr int64_t num_threads = 40;
+        constexpr int64_t N = 32;
+        constexpr int64_t K = 16;
+        constexpr int64_t M = static_cast<int64_t>(64L);
+        ...
+        #pragma omp parallel num_threads(40)
+        {
+            const int tid = omp_get_thread_num();
+            ...
+            for (int64_t mc_block_id = 0; mc_block_id < num_Mc_blocks_per_thread; mc_block_id++) {
+                ...
+                for (int64_t nc = n_block_start; nc < n_block_end; nc += Nc_blocks) {
+                    ...
+                    for (int64_t kc = k_block_start; kc < k_block_end; kc += Kc_blocks) {
+                        ...
+                        for (int64_t nci = nc; nci < nc_block_end; nci++) {
+                            if (kc == k_block_start) {
+                                kernel_micro_gemm<static_cast<bool>(false)>(
+                                    ...
+                                );
+
+                            } else {
+                                kernel_micro_gemm<static_cast<bool>(true)>(
+                                    ...
+                                );
+
+                            }
+                        }
+                    }
+                    {
+                        {
+                            // Epilogue fusion here for bias and relu
+                            #pragma GCC ivdep
+                            for(int64_t x0=static_cast<int64_t>(0L); x0<static_cast<int64_t>(m_end + ((-1L)*m_start)); x0+=static_cast<int64_t>(1L))
+                            {
+                                for(int64_t x1=static_cast<int64_t>(0L); x1<static_cast<int64_t>(16L*(c10::div_floor_integer(static_cast<int64_t>((n_end + ((-1L)*n_start))), static_cast<int64_t>(16L)))); x1+=static_cast<int64_t>(16L))
+                                {
+                                    auto tmp0 = at::vec::Vectorized<bfloat16>::loadu(inp + static_cast<int64_t>(n_start + x1), static_cast<int64_t>(16));
+                                    auto tmp2 = at::vec::Vectorized<float>::loadu(local_acc_buf + static_cast<int64_t>(x1 + (Nc_blocks*Nr*x0)), static_cast<int64_t>(16));
+                                    auto tmp1 = at::vec::convert<float>(tmp0);
+                                    auto tmp3 = tmp1 + tmp2;
+                                    auto tmp4 = at::vec::convert<bfloat16>(tmp3);
+                                    auto tmp5 = static_cast<float>(0.0);
+                                    auto tmp6 = at::vec::Vectorized<float>(tmp5);
+                                    auto tmp7 = at::vec::maximum(tmp3, tmp6);
+                                    auto tmp8 = at::vec::convert<bfloat16>(tmp7);
+                                    tmp8.store(Y + static_cast<int64_t>(n_start + x1 + (32L*m_start) + (32L*x0)), static_cast<int64_t>(16));
+                                }
+                                
+                                ...
+
+                            }
+                        }
+
+                    }
+                }
+            }
+            ...
+        }
+    }
+    ''')
+
+Conclusion
+------------
+In this tutorial, we introduced max-autotune support on CPU with GEMM template. We explained the API to activate this feature, and demonstrated
+the generated code of the GEMM template.
+
+This feature is in prototype stage. If you have any feature requests or run into any issues, please file a bug report at `GitHub issues <https://github.com/pytorch/pytorch/issues>`_.
diff --git a/unstable_source/nestedtensor.py b/unstable_source/nestedtensor.py
new file mode 100644
index 00000000000..77f8a4cebe1
--- /dev/null
+++ b/unstable_source/nestedtensor.py
@@ -0,0 +1,376 @@
+"""
+
+Getting Started with Nested Tensors
+===============================================================
+
+Nested tensors generalize the shape of regular dense tensors, allowing for representation
+of ragged-sized data.
+
+* for a regular tensor, each dimension is regular and has a size
+
+* for a nested tensor, not all dimensions have regular sizes; some of them are ragged
+
+Nested tensors are a natural solution for representing sequential data within various domains:
+
+* in NLP, sentences can have variable lengths, so a batch of sentences forms a nested tensor
+
+* in CV, images can have variable shapes, so a batch of images forms a nested tensor
+
+In this tutorial, we will demonstrate basic usage of nested tensors and motivate their usefulness
+for operating on sequential data of varying lengths with a real-world example. In particular,
+they are invaluable for building transformers that can efficiently operate on ragged sequential
+inputs. Below, we present an implementation of multi-head attention using nested tensors that,
+combined usage of ``torch.compile``, out-performs operating naively on tensors with padding.
+
+Nested tensors are currently a prototype feature and are subject to change.
+"""
+
+import numpy as np
+import timeit
+import torch
+import torch.nn.functional as F
+
+from torch import nn
+
+torch.manual_seed(1)
+np.random.seed(1)
+
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+######################################################################
+# Nested tensor initialization
+# ----------------------------
+#
+# From the Python frontend, a nested tensor can be created from a list of tensors.
+# We denote nt[i] as the ith tensor component of a nestedtensor.
+nt = torch.nested.nested_tensor([torch.arange(12).reshape(
+    2, 6), torch.arange(18).reshape(3, 6)], dtype=torch.float, device=device)
+print(f"{nt=}")
+
+######################################################################
+# By padding every underlying tensor to the same shape,
+# a nestedtensor can be converted to a regular tensor.
+padded_out_tensor = torch.nested.to_padded_tensor(nt, padding=0.0)
+print(f"{padded_out_tensor=}")
+
+######################################################################
+# All tensors posses an attribute for determining if they are nested;
+print(f"nt is nested: {nt.is_nested}")
+print(f"padded_out_tensor is nested: {padded_out_tensor.is_nested}")
+
+######################################################################
+# It is common to construct nestedtensors from batches of irregularly shaped tensors.
+# i.e. dimension 0 is assumed to be the batch dimension.
+# Indexing dimension 0 gives back the first underlying tensor component.
+print("First underlying tensor component:", nt[0], sep='\n')
+print("last column of 2nd underlying tensor component:", nt[1, :, -1], sep='\n')
+
+# When indexing a nestedtensor's 0th dimension, the result is a regular tensor.
+print(f"First underlying tensor component is nested: {nt[0].is_nested}")
+
+######################################################################
+# An important note is that slicing in dimension 0 has not been supported yet.
+# Which means it not currently possible to construct a view that combines the underlying
+# tensor components.
+
+######################################################################
+# Nested Tensor Operations
+# ------------------------
+#
+# As each operation must be explicitly implemented for nestedtensors,
+# operation coverage for nestedtensors is currently narrower than that of regular tensors.
+# For now, only basic operations such as index, dropout, softmax, transpose, reshape, linear, bmm are covered.
+# However, coverage is being expanded.
+# If you need certain operations, please file an `issue <https://github.com/pytorch/pytorch>`__
+# to help us prioritize coverage.
+#
+# **reshape**
+#
+# The reshape op is for changing the shape of a tensor.
+# Its full semantics for regular tensors can be found
+# `here <https://pytorch.org/docs/stable/generated/torch.reshape.html>`__.
+# For regular tensors, when specifying the new shape,
+# a single dimension may be -1, in which case it is inferred
+# from the remaining dimensions and the number of elements.
+#
+# The semantics for nestedtensors are similar, except that -1 no longer infers.
+# Instead, it inherits the old size (here 2 for ``nt[0]`` and 3 for ``nt[1]``).
+# -1 is the only legal size to specify for a jagged dimension.
+nt_reshaped = nt.reshape(2, -1, 2, 3)
+print(f"{nt_reshaped=}")
+
+######################################################################
+# **transpose**
+#
+# The transpose op is for swapping two dimensions of a tensor.
+# Its full semantics can be found
+# `here <https://pytorch.org/docs/stable/generated/torch.transpose.html>`__.
+# Note that for nestedtensors dimension 0 is special;
+# it is assumed to be the batch dimension,
+# so transposes involving nestedtensor dimension 0 are not supported.
+nt_transposed = nt_reshaped.transpose(1, 2)
+print(f"{nt_transposed=}")
+
+######################################################################
+# **others**
+#
+# Other operations have the same semantics as for regular tensors.
+# Applying the operation on a nestedtensor is equivalent to
+# applying the operation to the underlying tensor components,
+# with the result being a nestedtensor as well.
+nt_mm = torch.nested.nested_tensor([torch.randn((2, 3, 4)), torch.randn((2, 3, 5))], device=device)
+nt3 = torch.matmul(nt_transposed, nt_mm)
+print(f"Result of Matmul:\n {nt3}")
+
+nt4 = F.dropout(nt3, 0.1)
+print(f"Result of Dropout:\n {nt4}")
+
+nt5 = F.softmax(nt4, -1)
+print(f"Result of Softmax:\n {nt5}")
+
+######################################################################
+# Why Nested Tensor
+# -----------------
+#
+
+######################################################################
+# When data is sequential, it is often the case that each sample has a different length.
+# For example, in a batch of sentences, each sentence has a different number of words.
+# A common technique for handling varying sequences is to manually pad each data tensor
+# to the same shape in order to form a batch.
+# For example, we have 2 sentences with different lengths and a vocabulary
+# In order to represent his as single tensor we pad with 0 to the max length in the batch.
+sentences = [["goodbye", "padding"],
+             ["embrace", "nested", "tensor"]]
+vocabulary = {"goodbye": 1.0, "padding": 2.0,
+              "embrace": 3.0, "nested": 4.0, "tensor": 5.0}
+padded_sentences = torch.tensor([[1.0, 2.0, 0.0],
+                                 [3.0, 4.0, 5.0]])
+nested_sentences = torch.nested.nested_tensor([torch.tensor([1.0, 2.0]),
+                                               torch.tensor([3.0, 4.0, 5.0])])
+print(f"{padded_sentences=}")
+print(f"{nested_sentences=}")
+
+######################################################################
+# This technique of padding a batch of data to its max length is not optimal.
+# The padded data is not needed for computation and wastes memory by allocating
+# larger tensors than necessary.
+# Further, not all operations have the same semnatics when applied to padded data.
+# For matrix multiplications in order to ignore the padded entries, one needs to pad
+# with 0 while for softmax one has to pad with -inf to ignore specific entries.
+# The primary objective of nested tensor is to facilitate operations on ragged
+# data using the standard PyTorch tensor UX, thereby eliminating the need
+# for inefficient and complex padding and masking.
+padded_sentences_for_softmax = torch.tensor([[1.0, 2.0, float("-inf")],
+                                             [3.0, 4.0, 5.0]])
+print(F.softmax(padded_sentences_for_softmax, -1))
+print(F.softmax(nested_sentences, -1))
+
+######################################################################
+# Let us take a look at a practical example: the multi-head attention component
+# utilized in `Transformers <https://arxiv.org/pdf/1706.03762.pdf>`__.
+# We can implement this in such a way that it can operate on either padded
+# or nested tensors.
+class MultiHeadAttention(nn.Module):
+    """
+    Computes multi-head attention. Supports nested or padded tensors.
+
+    Args:
+        E_q (int): Size of embedding dim for query
+        E_k (int): Size of embedding dim for key
+        E_v (int): Size of embedding dim for value
+        E_total (int): Total embedding dim of combined heads post input projection. Each head
+            has dim E_total // nheads
+        nheads (int): Number of heads
+        dropout_p (float, optional): Dropout probability. Default: 0.0
+    """
+    def __init__(self, E_q: int, E_k: int, E_v: int, E_total: int,
+                 nheads: int, dropout_p: float = 0.0):
+        super().__init__()
+        self.nheads = nheads
+        self.dropout_p = dropout_p
+        self.query_proj = nn.Linear(E_q, E_total)
+        self.key_proj = nn.Linear(E_k, E_total)
+        self.value_proj = nn.Linear(E_v, E_total)
+        E_out = E_q
+        self.out_proj = nn.Linear(E_total, E_out)
+        assert E_total % nheads == 0, "Embedding dim is not divisible by nheads"
+        self.E_head = E_total // nheads
+
+    def forward(self, query: torch.Tensor, key: torch.Tensor, value: torch.Tensor) -> torch.Tensor:
+        """
+        Forward pass; runs the following process:
+            1. Apply input projection
+            2. Split heads and prepare for SDPA
+            3. Run SDPA
+            4. Apply output projection
+
+        Args:
+            query (torch.Tensor): query of shape (N, L_t, E_q)
+            key (torch.Tensor): key of shape (N, L_s, E_k)
+            value (torch.Tensor): value of shape (N, L_s, E_v)
+
+        Returns:
+            attn_output (torch.Tensor): output of shape (N, L_t, E_q)
+        """
+        # Step 1. Apply input projection
+        # TODO: demonstrate packed projection
+        query = self.query_proj(query)
+        key = self.key_proj(key)
+        value = self.value_proj(value)
+
+        # Step 2. Split heads and prepare for SDPA
+        # reshape query, key, value to separate by head
+        # (N, L_t, E_total) -> (N, L_t, nheads, E_head) -> (N, nheads, L_t, E_head)
+        query = query.unflatten(-1, [self.nheads, self.E_head]).transpose(1, 2)
+        # (N, L_s, E_total) -> (N, L_s, nheads, E_head) -> (N, nheads, L_s, E_head)
+        key = key.unflatten(-1, [self.nheads, self.E_head]).transpose(1, 2)
+        # (N, L_s, E_total) -> (N, L_s, nheads, E_head) -> (N, nheads, L_s, E_head)
+        value = value.unflatten(-1, [self.nheads, self.E_head]).transpose(1, 2)
+
+        # Step 3. Run SDPA
+        # (N, nheads, L_t, E_head)
+        attn_output = F.scaled_dot_product_attention(
+            query, key, value, dropout_p=dropout_p, is_causal=True)
+        # (N, nheads, L_t, E_head) -> (N, L_t, nheads, E_head) -> (N, L_t, E_total)
+        attn_output = attn_output.transpose(1, 2).flatten(-2)
+
+        # Step 4. Apply output projection
+        # (N, L_t, E_total) -> (N, L_t, E_out)
+        attn_output = self.out_proj(attn_output)
+
+        return attn_output
+
+######################################################################
+# set hyperparameters following `the Transformer paper <https://arxiv.org/pdf/1706.03762.pdf>`__
+N = 512
+E_q, E_k, E_v, E_total = 512, 512, 512, 512
+E_out = E_q
+nheads = 8
+
+######################################################################
+# except for dropout probability: set to 0 for correctness check
+dropout_p = 0.0
+
+######################################################################
+# Let us generate some realistic fake data from Zipf's law.
+def zipf_sentence_lengths(alpha: float, batch_size: int) -> torch.Tensor:
+    # generate fake corpus by unigram Zipf distribution
+    # from wikitext-2 corpus, we get rank "." = 3, "!" = 386, "?" = 858
+    sentence_lengths = np.empty(batch_size, dtype=int)
+    for ibatch in range(batch_size):
+        sentence_lengths[ibatch] = 1
+        word = np.random.zipf(alpha)
+        while word != 3 and word != 386 and word != 858:
+            sentence_lengths[ibatch] += 1
+            word = np.random.zipf(alpha)
+    return torch.tensor(sentence_lengths)
+
+######################################################################
+# Create nested tensor batch inputs
+def gen_batch(N, E_q, E_k, E_v, device):
+    # generate semi-realistic data using Zipf distribution for sentence lengths
+    sentence_lengths = zipf_sentence_lengths(alpha=1.2, batch_size=N)
+
+    # Note: the torch.jagged layout is a nested tensor layout that supports a single ragged
+    # dimension and works with torch.compile. The batch items each have shape (B, S*, D)
+    # where B = batch size, S* = ragged sequence length, and D = embedding dimension.
+    query = torch.nested.nested_tensor([
+        torch.randn(l.item(), E_q, device=device)
+        for l in sentence_lengths
+    ], layout=torch.jagged)
+
+    key = torch.nested.nested_tensor([
+        torch.randn(s.item(), E_k, device=device)
+        for s in sentence_lengths
+    ], layout=torch.jagged)
+
+    value = torch.nested.nested_tensor([
+        torch.randn(s.item(), E_v, device=device)
+        for s in sentence_lengths
+    ], layout=torch.jagged)
+
+    return query, key, value, sentence_lengths
+
+query, key, value, sentence_lengths = gen_batch(N, E_q, E_k, E_v, device)
+
+######################################################################
+# Generate padded forms of query, key, value for comparison
+def jagged_to_padded(jt, padding_val):
+    # TODO: do jagged -> padded directly when this is supported
+    return torch.nested.to_padded_tensor(
+        torch.nested.nested_tensor(list(jt.unbind())),
+        padding_val)
+
+padded_query, padded_key, padded_value = (
+    jagged_to_padded(t, 0.0) for t in (query, key, value)
+)
+
+######################################################################
+# Construct the model
+mha = MultiHeadAttention(E_q, E_k, E_v, E_total, nheads, dropout_p).to(device=device)
+
+######################################################################
+# Check correctness and performance
+def benchmark(func, *args, **kwargs):
+    torch.cuda.synchronize()
+    begin = timeit.default_timer()
+    output = func(*args, **kwargs)
+    torch.cuda.synchronize()
+    end = timeit.default_timer()
+    return output, (end - begin)
+
+output_nested, time_nested = benchmark(mha, query, key, value)
+output_padded, time_padded = benchmark(mha, padded_query, padded_key, padded_value)
+
+# padding-specific step: remove output projection bias from padded entries for fair comparison
+for i, entry_length in enumerate(sentence_lengths):
+    output_padded[i, entry_length:] = 0.0
+
+print("=== without torch.compile ===")
+print("nested and padded calculations differ by", (jagged_to_padded(output_nested, 0.0) - output_padded).abs().max().item())
+print("nested tensor multi-head attention takes", time_nested, "seconds")
+print("padded tensor multi-head attention takes", time_padded, "seconds")
+
+# warm up compile first...
+compiled_mha = torch.compile(mha)
+compiled_mha(query, key, value)
+# ...now benchmark
+compiled_output_nested, compiled_time_nested = benchmark(
+    compiled_mha, query, key, value)
+
+# warm up compile first...
+compiled_mha(padded_query, padded_key, padded_value)
+# ...now benchmark
+compiled_output_padded, compiled_time_padded = benchmark(
+    compiled_mha, padded_query, padded_key, padded_value)
+
+# padding-specific step: remove output projection bias from padded entries for fair comparison
+for i, entry_length in enumerate(sentence_lengths):
+    compiled_output_padded[i, entry_length:] = 0.0
+
+print("=== with torch.compile ===")
+print("nested and padded calculations differ by", (jagged_to_padded(compiled_output_nested, 0.0) - compiled_output_padded).abs().max().item())
+print("nested tensor multi-head attention takes", compiled_time_nested, "seconds")
+print("padded tensor multi-head attention takes", compiled_time_padded, "seconds")
+
+######################################################################
+# Note that without ``torch.compile``, the overhead of the python subclass nested tensor
+# can make it slower than the equivalent computation on padded tensors. However, once
+# ``torch.compile`` is enabled, operating on nested tensors gives a multiple x speedup.
+# Avoiding wasted computation on padding becomes only more valuable as the percentage
+# of padding in the batch increases.
+print(f"Nested speedup: {compiled_time_padded / compiled_time_nested:.3f}")
+
+######################################################################
+# Conclusion
+# ----------
+# In this tutorial, we have learned how to perform basic operations with nested tensors and
+# how implement multi-head attention for transformers in a way that avoids computation on padding.
+# For more information, check out the docs for the
+# `torch.nested <https://pytorch.org/docs/stable/nested.html>`__ namespace.
+#
+# See Also
+# --------
+#
+# * `Accelerating PyTorch Transformers by replacing nn.Transformer with Nested Tensors and torch.compile <https://docs.pytorch.org/tutorials/intermediate/transformer_building_blocks.html>`__
diff --git a/unstable_source/nnapi_mobilenetv2.rst b/unstable_source/nnapi_mobilenetv2.rst
new file mode 100644
index 00000000000..ef7edc92d12
--- /dev/null
+++ b/unstable_source/nnapi_mobilenetv2.rst
@@ -0,0 +1,10 @@
+(Beta) Convert MobileNetV2 to NNAPI
+========================================
+
+PyTorch Mobile is no longer actively supported. Please check out `ExecuTorch <https://github.com/pytorch/executorch>`__.
+
+Redirecting in 3 seconds...
+
+.. raw:: html
+
+    <meta http-equiv="Refresh" content="3; url='https://pytorch.org/executorch/stable/index.html'" />
diff --git a/unstable_source/openvino_quantizer.rst b/unstable_source/openvino_quantizer.rst
new file mode 100644
index 00000000000..9412c772204
--- /dev/null
+++ b/unstable_source/openvino_quantizer.rst
@@ -0,0 +1,250 @@
+PyTorch 2 Export Quantization for OpenVINO torch.compile Backend
+===========================================================================
+
+**Authors**: `Daniil Lyakhov <https://github.com/daniil-lyakhov>`_,  `Aamir Nazir <https://github.com/anzr299>`_,  `Alexander Suslov <https://github.com/alexsu52>`_, `Yamini Nimmagadda <https://github.com/ynimmaga>`_, `Alexander Kozlov <https://github.com/AlexKoff88>`_
+
+Prerequisites
+--------------
+- `PyTorch 2 Export Post Training Quantization <https://pytorch.org/tutorials/prototype/pt2e_quant_ptq.html>`_
+- `How to Write a Quantizer for PyTorch 2 Export Quantization <https://pytorch.org/tutorials/prototype/pt2e_quantizer.html>`_
+
+Introduction
+--------------
+
+.. note::
+
+    This is an experimental feature, the quantization API is subject to change.
+
+This tutorial demonstrates how to use ``OpenVINOQuantizer`` from `Neural Network Compression Framework (NNCF) <https://github.com/openvinotoolkit/nncf/tree/develop>`_ in PyTorch 2 Export Quantization flow to generate a quantized model customized for the `OpenVINO torch.compile backend <https://docs.openvino.ai/2024/openvino-workflow/torch-compile.html>`_ and explains how to lower the quantized model into the `OpenVINO <https://docs.openvino.ai/2024/index.html>`_ representation.
+``OpenVINOQuantizer`` unlocks the full potential of low-precision OpenVINO kernels due to the placement of quantizers designed specifically for the OpenVINO.
+
+The PyTorch 2 export quantization flow uses ``torch.export`` to capture the model into a graph and performs quantization transformations on top of the ATen graph.
+This approach is expected to have significantly higher model coverage, improved flexibility, and a simplified UX.
+OpenVINO backend compiles the FX Graph generated by TorchDynamo into an optimized OpenVINO model.
+
+The quantization flow mainly includes four steps:
+
+- Step 1: Capture the FX Graph from the eager Model based on the `torch export mechanism <https://pytorch.org/docs/main/export.html>`_.
+- Step 2: Apply the PyTorch 2 Export Quantization flow with OpenVINOQuantizer based on the captured FX Graph.
+- Step 3: Lower the quantized model into OpenVINO representation with the `torch.compile <https://docs.openvino.ai/2024/openvino-workflow/torch-compile.html>`_ API.
+- Optional step 4: : Improve quantized model metrics via `quantize_pt2e <https://openvinotoolkit.github.io/nncf/autoapi/nncf/experimental/torch/fx/index.html#nncf.experimental.torch.fx.quantize_pt2e>`_ method.
+
+The high-level architecture of this flow could look like this:
+
+::
+
+    float_model(Python)                          Example Input
+        \                                              /
+         \                                            /
+    —--------------------------------------------------------
+    |                         export                       |
+    —--------------------------------------------------------
+                                |
+                        FX Graph in ATen
+                                |
+                                |           OpenVINOQuantizer
+                                |                 /
+    —--------------------------------------------------------
+    |                      prepare_pt2e                     |
+    |                           |                           |
+    |                       Calibrate
+    |                           |                           |
+    |                      convert_pt2e                     |
+    —--------------------------------------------------------
+                                |
+                         Quantized Model
+                                |
+    —--------------------------------------------------------
+    |                  Lower into Inductor                  |
+    —--------------------------------------------------------
+                                |
+                          OpenVINO model
+
+Post Training Quantization
+----------------------------
+
+Now, we will walk you through a step-by-step tutorial for how to use it with `torchvision resnet18 model <https://download.pytorch.org/models/resnet18-f37072fd.pth>`_
+for post training quantization.
+
+Prerequisite: OpenVINO and NNCF installation
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+OpenVINO and NNCF could be easily installed via `pip distribution <https://docs.openvino.ai/2024/get-started/install-openvino.html>`_:
+
+.. code-block:: bash
+
+    pip install -U pip
+    pip install openvino, nncf
+
+
+1. Capture FX Graph
+^^^^^^^^^^^^^^^^^^^^^
+
+We will start by performing the necessary imports, capturing the FX Graph from the eager module.
+
+.. code-block:: python
+
+    import copy
+    import openvino.torch
+    import torch
+    import torchvision.models as models
+    from torch.ao.quantization.quantize_pt2e import convert_pt2e
+    from torch.ao.quantization.quantize_pt2e import prepare_pt2e
+
+    import nncf.torch
+
+    # Create the Eager Model
+    model_name = "resnet18"
+    model = models.__dict__[model_name](pretrained=True)
+
+    # Set the model to eval mode
+    model = model.eval()
+
+    # Create the data, using the dummy data here as an example
+    traced_bs = 50
+    x = torch.randn(traced_bs, 3, 224, 224)
+    example_inputs = (x,)
+
+    # Capture the FX Graph to be quantized
+    with torch.no_grad(), nncf.torch.disable_patching():
+        exported_model = torch.export.export(model, example_inputs).module()
+
+
+
+2. Apply Quantization
+^^^^^^^^^^^^^^^^^^^^^^^
+
+After we capture the FX Module to be quantized, we will import the OpenVINOQuantizer.
+
+
+.. code-block:: python
+
+    from nncf.experimental.torch.fx import OpenVINOQuantizer
+
+    quantizer = OpenVINOQuantizer()
+
+``OpenVINOQuantizer`` has several optional parameters that allow tuning the quantization process to get a more accurate model.
+Below is the list of essential parameters and their description:
+
+
+* ``preset`` - defines quantization scheme for the model. Two types of presets are available:
+
+    * ``PERFORMANCE`` (default) - defines symmetric quantization of weights and activations
+
+    * ``MIXED`` - weights are quantized with symmetric quantization and the activations are quantized with asymmetric quantization. This preset is recommended for models with non-ReLU and asymmetric activation functions, e.g. ELU, PReLU, GELU, etc.
+
+    .. code-block:: python
+
+        OpenVINOQuantizer(preset=nncf.QuantizationPreset.MIXED)
+
+* ``model_type`` - used to specify quantization scheme required for specific type of the model. Transformer is the only supported special quantization scheme to preserve accuracy after quantization of Transformer models (BERT, Llama, etc.). None is default, i.e. no specific scheme is defined.
+
+    .. code-block:: python
+
+        OpenVINOQuantizer(model_type=nncf.ModelType.Transformer)
+
+* ``ignored_scope`` - this parameter can be used to exclude some layers from the quantization process to preserve the model accuracy.  For example, when you want to exclude the last layer of the model from quantization.  Below are some examples of how to use this parameter:
+
+    .. code-block:: python
+
+        #Exclude by layer name:
+        names = ['layer_1', 'layer_2', 'layer_3']
+        OpenVINOQuantizer(ignored_scope=nncf.IgnoredScope(names=names))
+
+        #Exclude by layer type:
+        types = ['Conv2d', 'Linear']
+        OpenVINOQuantizer(ignored_scope=nncf.IgnoredScope(types=types))
+
+        #Exclude by regular expression:
+        regex = '.*layer_.*'
+        OpenVINOQuantizer(ignored_scope=nncf.IgnoredScope(patterns=regex))
+
+        #Exclude by subgraphs:
+        # In this case, all nodes along all simple paths in the graph
+        # from input to output nodes will be excluded from the quantization process.
+        subgraph = nncf.Subgraph(inputs=['layer_1', 'layer_2'], outputs=['layer_3'])
+        OpenVINOQuantizer(ignored_scope=nncf.IgnoredScope(subgraphs=[subgraph]))
+
+
+* ``target_device`` - defines the target device, the specificity of which will be taken into account during optimization. The following values are supported: ``ANY`` (default), ``CPU``, ``CPU_SPR``, ``GPU``, and ``NPU``.
+
+    .. code-block:: python
+
+        OpenVINOQuantizer(target_device=nncf.TargetDevice.CPU)
+
+For further details on `OpenVINOQuantizer` please see the `documentation <https://openvinotoolkit.github.io/nncf/autoapi/nncf/experimental/torch/fx/index.html#nncf.experimental.torch.fx.OpenVINOQuantizer>`_.
+
+After we import the backend-specific Quantizer, we will prepare the model for post-training quantization.
+``prepare_pt2e`` folds BatchNorm operators into preceding Conv2d operators, and inserts observers in appropriate places in the model.
+
+.. code-block:: python
+
+    prepared_model = prepare_pt2e(exported_model, quantizer)
+
+Now, we will calibrate the ``prepared_model`` after the observers are inserted in the model.
+
+.. code-block:: python
+
+    # We use the dummy data as an example here
+    prepared_model(*example_inputs)
+
+Finally, we will convert the calibrated Model to a quantized Model. ``convert_pt2e`` takes a calibrated model and produces a quantized model.
+
+.. code-block:: python
+
+    quantized_model = convert_pt2e(prepared_model, fold_quantize=False)
+
+After these steps, we finished running the quantization flow, and we will get the quantized model.
+
+
+3. Lower into OpenVINO representation
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+After that the FX Graph can utilize OpenVINO optimizations using `torch.compile(…, backend=”openvino”) <https://docs.openvino.ai/2024/openvino-workflow/torch-compile.html>`_ functionality.
+
+.. code-block:: python
+
+    with torch.no_grad(), nncf.torch.disable_patching():
+        optimized_model = torch.compile(quantized_model, backend="openvino")
+
+        # Running some benchmark
+        optimized_model(*example_inputs)
+
+
+
+The optimized model is using low-level kernels designed specifically for Intel CPU.
+This should significantly speed up inference time in comparison with the eager model.
+
+4. Optional: Improve quantized model metrics
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+NNCF implements advanced quantization algorithms like `SmoothQuant <https://arxiv.org/abs/2211.10438>`_ and `BiasCorrection <https://arxiv.org/abs/1906.04721>`_, which help
+to improve the quantized model metrics while minimizing the output discrepancies between the original and compressed models.
+These advanced NNCF algorithms can be accessed via the NNCF `quantize_pt2e` API:
+
+.. code-block:: python
+
+    from nncf.experimental.torch.fx import quantize_pt2e
+
+    calibration_loader = torch.utils.data.DataLoader(...)
+
+
+    def transform_fn(data_item):
+        images, _ = data_item
+        return images
+
+
+    calibration_dataset = nncf.Dataset(calibration_loader, transform_fn)
+    quantized_model = quantize_pt2e(
+        exported_model, quantizer, calibration_dataset, smooth_quant=True, fast_bias_correction=False
+    )
+
+
+For further details, please see the `documentation <https://openvinotoolkit.github.io/nncf/autoapi/nncf/experimental/torch/fx/index.html#nncf.experimental.torch.fx.quantize_pt2e>`_
+and a complete `example on Resnet18 quantization <https://github.com/openvinotoolkit/nncf/blob/develop/examples/post_training_quantization/torch_fx/resnet18/README.md>`_.
+
+Conclusion
+------------
+
+This tutorial introduces how to use torch.compile with the OpenVINO backend and the OpenVINO quantizer.
+For more details on NNCF and the NNCF Quantization Flow for PyTorch models, refer to the `NNCF Quantization Guide <https://docs.openvino.ai/2025/openvino-workflow/model-optimization-guide/quantizing-models-post-training/basic-quantization-flow.html.>`_.
+For additional information, check out the `OpenVINO Deployment via torch.compile Documentation <https://docs.openvino.ai/2024/openvino-workflow/torch-compile.html>`_.
diff --git a/unstable_source/python_extension_autoload.rst b/unstable_source/python_extension_autoload.rst
new file mode 100644
index 00000000000..ee7af5d49ef
--- /dev/null
+++ b/unstable_source/python_extension_autoload.rst
@@ -0,0 +1,184 @@
+Autoloading Out-of-Tree Extension
+=================================
+
+**Author:** `Yuanhao Ji <https://github.com/shink>`__
+
+The extension autoloading mechanism enables PyTorch to automatically
+load out-of-tree backend extensions without explicit import statements. This
+feature is beneficial for users as it enhances their
+experience and enables them to follow the familiar PyTorch device
+programming model without having to explicitly load or import device-specific
+extensions. Additionally, it facilitates effortless
+adoption of existing PyTorch applications with zero-code changes on
+out-of-tree devices. For further details, refer to the
+`[RFC] Autoload Device Extension <https://github.com/pytorch/pytorch/issues/122468>`_.
+
+.. grid:: 2
+
+    .. grid-item-card:: :octicon:`mortar-board;1em;` What you will learn
+       :class-card: card-prerequisites
+
+       * How to use out-of-tree extension autoloading in PyTorch
+       * Review examples with Intel Gaudi HPU, Huawei Ascend NPU
+
+    .. grid-item-card:: :octicon:`list-unordered;1em;` Prerequisites
+       :class-card: card-prerequisites
+
+       * PyTorch v2.5 or later
+
+.. note::
+
+    This feature is enabled by default and can be disabled by using
+    ``export TORCH_DEVICE_BACKEND_AUTOLOAD=0``.
+    If you get an error like this: "Failed to load the backend extension",
+    this error is independent with PyTorch, you should disable this feature
+    and ask the out-of-tree extension maintainer for help.
+
+How to apply this mechanism to out-of-tree extensions?
+------------------------------------------------------
+
+For instance, suppose you have a backend named ``foo`` and a corresponding package named ``torch_foo``. Ensure that
+your package is compatible with PyTorch 2.5 or later and includes the following snippet in its ``__init__.py`` file:
+
+.. code-block:: python
+
+    def _autoload():
+        print("Check things are working with `torch.foo.is_available()`.")
+
+Then, the only thing you need to do is define an entry point within your Python package:
+
+.. code-block:: python
+
+    setup(
+        name="torch_foo",
+        version="1.0",
+        entry_points={
+            "torch.backends": [
+                "torch_foo = torch_foo:_autoload",
+            ],
+        }
+    )
+
+Now you can import the ``torch_foo`` module by simply adding the ``import torch`` statement without the need to add ``import torch_foo``:
+
+.. code-block:: python
+
+    >>> import torch
+    Check things are working with `torch.foo.is_available()`.
+    >>> torch.foo.is_available()
+    True
+
+In some cases, you might encounter issues with circular imports. The examples below demonstrate how you can address them.
+
+Examples
+^^^^^^^^
+
+In this example, we will be using Intel Gaudi HPU and Huawei Ascend NPU to determine how to
+integrate your out-of-tree extension with PyTorch using the autoloading feature.
+
+`habana_frameworks.torch`_ is a Python package that enables users to run
+PyTorch programs on Intel Gaudi by using the PyTorch ``HPU`` device key.
+
+.. _habana_frameworks.torch: https://docs.habana.ai/en/latest/PyTorch/Getting_Started_with_PyTorch_and_Gaudi/Getting_Started_with_PyTorch.html
+
+``habana_frameworks.torch`` is a submodule of ``habana_frameworks``, we add an entry point to
+``__autoload()`` in ``habana_frameworks/setup.py``:
+
+.. code-block:: diff
+
+    setup(
+        name="habana_frameworks",
+        version="2.5",
+    +   entry_points={
+    +       'torch.backends': [
+    +           "device_backend = habana_frameworks:__autoload",
+    +       ],
+    +   }
+    )
+
+In ``habana_frameworks/init.py``, we use a global variable to track if our module has been loaded:
+
+.. code-block:: python
+
+    import os
+
+    is_loaded = False  # A member variable of habana_frameworks module to track if our module has been imported
+
+    def __autoload():
+        # This is an entrypoint for pytorch autoload mechanism
+        # If the following condition is true, that means our backend has already been loaded, either explicitly
+        # or by the autoload mechanism and importing it again should be skipped to avoid circular imports
+        global is_loaded
+        if is_loaded:
+            return
+        import habana_frameworks.torch
+
+In ``habana_frameworks/torch/init.py``, we prevent circular imports by updating the state of the global variable:
+
+.. code-block:: python
+
+    import os
+
+    # This is to prevent torch autoload mechanism from causing circular imports
+    import habana_frameworks
+
+    habana_frameworks.is_loaded = True
+
+`torch_npu`_ enables users to run PyTorch programs on Huawei Ascend NPU, it
+leverages the ``PrivateUse1`` device key and exposes the device name
+as ``npu`` to the end users.
+
+.. _torch_npu: https://github.com/Ascend/pytorch
+
+We define an entry point in `torch_npu/setup.py`_:
+
+.. _torch_npu/setup.py: https://github.com/Ascend/pytorch/blob/master/setup.py#L618
+
+.. code-block:: diff
+
+    setup(
+        name="torch_npu",
+        version="2.5",
+    +   entry_points={
+    +       'torch.backends': [
+    +           'torch_npu = torch_npu:_autoload',
+    +       ],
+    +   }
+    )
+
+Unlike ``habana_frameworks``, ``torch_npu`` uses the environment variable ``TORCH_DEVICE_BACKEND_AUTOLOAD``
+to control the autoloading process. For example, we set it to ``0`` to disable autoloading to prevent circular imports:
+
+.. code-block:: python
+
+    # Disable autoloading before running 'import torch'
+    os.environ['TORCH_DEVICE_BACKEND_AUTOLOAD'] = '0'
+
+    import torch
+
+How it works
+------------
+
+.. image:: ../_static/img/python_extension_autoload_impl.png
+   :alt: Autoloading implementation
+   :align: center
+
+Autoloading is implemented based on Python's `Entrypoints
+<https://packaging.python.org/en/latest/specifications/entry-points/>`_
+mechanism. We discover and load all of the specific entry points
+in ``torch/__init__.py`` that are defined by out-of-tree extensions.
+
+As shown above, after installing ``torch_foo``, your Python module can be imported
+when loading the entrypoint that you have defined, and then you can do some necessary work when
+calling it.
+
+See the implementation in this pull request: `[RFC] Add support for device extension autoloading
+<https://github.com/pytorch/pytorch/pull/127074>`_.
+
+Conclusion
+----------
+
+In this tutorial, we learned about the out-of-tree extension autoloading mechanism in PyTorch, which automatically
+loads backend extensions eliminating the need to add additional import statements. We also learned how to apply
+this mechanism to out-of-tree extensions by defining an entry point and how to prevent circular imports.
+We also reviewed an example on how to use the autoloading mechanism with Intel Gaudi HPU and Huawei Ascend NPU.
diff --git a/unstable_source/tracing_based_selective_build.rst b/unstable_source/tracing_based_selective_build.rst
new file mode 100644
index 00000000000..a1b56072051
--- /dev/null
+++ b/unstable_source/tracing_based_selective_build.rst
@@ -0,0 +1,10 @@
+(prototype) Tracing-based Selective Build Mobile Interpreter in Android and iOS
+===============================================================================
+
+This tutorial has been replaced with a newer tutorial on this topic: https://pytorch.org/executorch/stable/kernel-library-selective-build.html
+
+Redirecting in 3 seconds...
+
+.. raw:: html
+
+    <meta http-equiv="Refresh" content="3; url='https://pytorch.org/executorch/stable/kernel-library-selective-build.html'" />
diff --git a/unstable_source/vmap_recipe.py b/unstable_source/vmap_recipe.py
new file mode 100644
index 00000000000..53d5377c3cc
--- /dev/null
+++ b/unstable_source/vmap_recipe.py
@@ -0,0 +1,123 @@
+"""
+torch.vmap
+==========
+This tutorial introduces torch.vmap, an autovectorizer for PyTorch operations.
+torch.vmap is a prototype feature and cannot handle a number of use cases;
+however, we would like to gather use cases for it to inform the design. If you
+are considering using torch.vmap or think it would be really cool for something,
+please contact us at https://github.com/pytorch/pytorch/issues/42368.
+
+So, what is vmap?
+-----------------
+vmap is a higher-order function. It accepts a function `func` and returns a new
+function that maps `func` over some dimension of the inputs. It is highly
+inspired by JAX's vmap.
+
+Semantically, vmap pushes the "map" into PyTorch operations called by `func`,
+effectively vectorizing those operations.
+"""
+import torch
+# NB: vmap is only available on nightly builds of PyTorch.
+# You can download one at pytorch.org if you're interested in testing it out.
+from torch import vmap
+
+####################################################################
+# The first use case for vmap is making it easier to handle
+# batch dimensions in your code. One can write a function `func`
+# that runs on examples and then lift it to a function that can
+# take batches of examples with `vmap(func)`. `func` however
+# is subject to many restrictions:
+#
+# - it must be functional (one cannot mutate a Python data structure
+#   inside of it), with the exception of in-place PyTorch operations.
+# - batches of examples must be provided as Tensors. This means that
+#   vmap doesn't handle variable-length sequences out of the box.
+#
+# One example of using `vmap` is to compute batched dot products. PyTorch
+# doesn't provide a batched `torch.dot` API; instead of unsuccessfully
+# rummaging through docs, use `vmap` to construct a new function:
+
+torch.dot                            # [D], [D] -> []
+batched_dot = torch.vmap(torch.dot)  # [N, D], [N, D] -> [N]
+x, y = torch.randn(2, 5), torch.randn(2, 5)
+batched_dot(x, y)
+
+####################################################################
+# `vmap` can be helpful in hiding batch dimensions, leading to a simpler
+# model authoring experience.
+batch_size, feature_size = 3, 5
+weights = torch.randn(feature_size, requires_grad=True)
+
+# Note that model doesn't work with a batch of feature vectors because
+# torch.dot must take 1D tensors. It's pretty easy to rewrite this
+# to use `torch.matmul` instead, but if we didn't want to do that or if
+# the code is more complicated (e.g., does some advanced indexing
+# shenanigins), we can simply call `vmap`. `vmap` batches over ALL
+# inputs, unless otherwise specified (with the in_dims argument,
+# please see the documentation for more details).
+def model(feature_vec):
+    # Very simple linear model with activation
+    return feature_vec.dot(weights).relu()
+
+examples = torch.randn(batch_size, feature_size)
+result = torch.vmap(model)(examples)
+expected = torch.stack([model(example) for example in examples.unbind()])
+assert torch.allclose(result, expected)
+
+####################################################################
+# `vmap` can also help vectorize computations that were previously difficult
+# or impossible to batch. This bring us to our second use case: batched
+# gradient computation.
+#
+# - https://github.com/pytorch/pytorch/issues/8304
+# - https://github.com/pytorch/pytorch/issues/23475
+#
+# The PyTorch autograd engine computes vjps (vector-Jacobian products).
+# Using vmap, we can compute (batched vector) - jacobian products.
+#
+# One example of this is computing a full Jacobian matrix (this can also be
+# applied to computing a full Hessian matrix).
+# Computing a full Jacobian matrix for some function f: R^N -> R^N usually
+# requires N calls to `autograd.grad`, one per Jacobian row.
+
+# Setup
+N = 5
+def f(x):
+    return x ** 2
+
+x = torch.randn(N, requires_grad=True)
+y = f(x)
+basis_vectors = torch.eye(N)
+
+# Sequential approach
+jacobian_rows = [torch.autograd.grad(y, x, v, retain_graph=True)[0]
+                 for v in basis_vectors.unbind()]
+jacobian = torch.stack(jacobian_rows)
+
+# Using `vmap`, we can vectorize the whole computation, computing the
+# Jacobian in a single call to `autograd.grad`.
+def get_vjp(v):
+    return torch.autograd.grad(y, x, v)[0]
+
+jacobian_vmap = vmap(get_vjp)(basis_vectors)
+assert torch.allclose(jacobian_vmap, jacobian)
+
+####################################################################
+# The third main use case for vmap is computing per-sample-gradients.
+# This is something that the vmap prototype cannot handle performantly
+# right now. We're not sure what the API for computing per-sample-gradients
+# should be, but if you have ideas, please comment in
+# https://github.com/pytorch/pytorch/issues/7786.
+
+def model(sample, weight):
+    # do something...    
+    return torch.dot(sample, weight)
+
+def grad_sample(sample):
+    return torch.autograd.functional.vjp(lambda weight: model(sample), weight)[1]
+
+# The following doesn't actually work in the vmap prototype. But it
+# could be an API for computing per-sample-gradients.
+
+# batch_of_samples = torch.randn(64, 5)
+# vmap(grad_sample)(batch_of_samples)