Fix links everywhere (#16880)

Fix broken documentation URLs and add lint-ignore comments for URLs that
fail due to timeouts or authentication requirements.

Fixed 404 broken URLs:
- Updated torch.export documentation URLs from
pytorch.org/docs/stable/export.html to
docs.pytorch.org/docs/stable/user_guide/torch_compiler/export.html
- Fixed ARM Ethos-U backend URL to use new path structure
(/backends/arm-ethos-u/arm-ethos-u-overview.html)
- Fixed XNNPACK internals URL (xnnpack-internals.html →
xnnpack-arch-internals.html)
- Fixed XNNPACK delegate lowering tutorial URL
- Fixed Qualcomm backend URL

Added @lint-ignore for URLs that can't be automatically verified:
- HuggingFace gated model URLs (require authentication, return 401)
- PyTorch HUD URLs (timeout in CI environment, return 000)

Other cleanup:
- Removed outdated paragraph referencing non-existent
test_xnnpack_qnnpack.py file from delegate documentation

Test plan

- Verify link-check / lint-urls CI job passes
- Spot-check a few of the updated URLs manually

Co-authored-by: Mergen Nachin <[email protected]>

Author: pytorchbot

.ci/scripts/benchmark_tooling/get_benchmark_analysis_data.py

@@ -104,7 +104,7 @@ class BenchmarkFilters:
 
 BASE_URLS = {
     "local": "http://localhost:3000",
-    "prod": "https://hud.pytorch.org",
+    "prod": "https://hud.pytorch.org",  # @lint-ignore
 }
 
 

.ci/scripts/tests/test_get_benchmark_analysis_data.py

@@ -179,7 +179,9 @@ def setUp(self):
     def test_init(self):
         """Test initialization of ExecutorchBenchmarkFetcher."""
         self.assertEqual(self.fetcher.env, "prod")
-        self.assertEqual(self.fetcher.base_url, "https://hud.pytorch.org")
+        self.assertEqual(
+            self.fetcher.base_url, "https://hud.pytorch.org"  # @lint-ignore
+        )
         self.assertEqual(
             self.fetcher.query_group_table_by_fields,
             ["model", "backend", "device", "arch"],
@@ -193,7 +195,9 @@ def test_init(self):
 
     def test_get_base_url(self):
         """Test _get_base_url method."""
-        self.assertEqual(self.fetcher._get_base_url(), "https://hud.pytorch.org")
+        self.assertEqual(
+            self.fetcher._get_base_url(), "https://hud.pytorch.org"  # @lint-ignore
+        )
 
         # Test with local environment
         local_fetcher = self.module.ExecutorchBenchmarkFetcher(env="local")

CONTRIBUTING.md

@@ -324,7 +324,8 @@ the code you're modifying and find an author who has more context. Ask them
 for their help in the PR comments.
 
 ### Continuous Integration
-See https://hud.pytorch.org/hud/pytorch/executorch/main for the current state of
+
+See https://hud.pytorch.org/hud/pytorch/executorch/main for the current state of <!-- @lint-ignore -->
 the CI (continuous integration) jobs. If `main` is broken, consider rebasing
 your PR onto the `release/1.1` branch, which points to the most recent
 all-green commit.

backends/openvino/quantizer/quantizer.py

@@ -295,7 +295,7 @@ def _get_unified_scales_root_quantizer_id(
         """
         Identifies the earliest quantizer node ID based on the corresponding `nncf_node.node_id`
         in the given NNCFGraph. This is required by the `_get_obs_or_fq_map` function.
-        Refer to: https://github.com/pytorch/pytorch/blob/main/torch/ao/quantization/pt2e/prepare.py#L291
+        Refer to: https://github.com/pytorch/ao/blob/main/torchao/quantization/pt2e/prepare.py
 
         :param nncf_graph: The NNCFGraph instance.
         :param quantizer_ids: The list of quantizer IDs to evaluate.

backends/xnnpack/README.md

@@ -133,5 +133,5 @@ create an issue on [github](https://www.github.com/pytorch/executorch/issues).
 
 ## See Also
 For more information about the XNNPACK Backend, please check out the following resources:
-- [XNNPACK Backend](https://pytorch.org/executorch/main/backends-xnnpack)
-- [XNNPACK Backend Internals](https://pytorch.org/executorch/main/backends/xnnpack/backend-delegates-xnnpack-reference)
+- [XNNPACK Backend](https://docs.pytorch.org/executorch/main/backends/xnnpack/xnnpack-overview.html)
+- [XNNPACK Backend Internals](https://docs.pytorch.org/executorch/main/backends/xnnpack/xnnpack-arch-internals.html)

docs/source/Doxyfile

@@ -1535,7 +1535,7 @@ DOCSET_PUBLISHER_NAME  = Publisher
 # a.o. the download links, offline the HTML help workshop was already many years
 # in maintenance mode). You can download the HTML help workshop from the web
 # archives at Installation executable (see:
-# http://web.archive.org/web/20160201063255/http://download.microsoft.com/downlo
+# http://web.archive.org/web/20160201063255/http://download.microsoft.com/downlo @lint-ignore
 # ad/0/A/9/0A939EF6-E31C-430F-A3DF-DFAE7960D564/htmlhelp.exe).
 #
 # The HTML Help Workshop contains a compiler that can convert all HTML output

docs/source/archive/backends-cadence-legacy.md

@@ -137,7 +137,7 @@ python3 -m examples.cadence.operators.quantized_<linear,conv1d>_op
 
 ***Small Model: RNNT predictor***:
 
-The torchaudio [RNNT-emformer](https://pytorch.org/audio/stable/tutorials/online_asr_tutorial.html) model is an Automatic Speech Recognition (ASR) model, comprised of three different submodels: an encoder, a predictor and a joiner.
+The torchaudio [RNNT-emformer](https://docs.pytorch.org/audio/stable/generated/torchaudio.pipelines.EMFORMER_RNNT_BASE_LIBRISPEECH.html) model is an Automatic Speech Recognition (ASR) model, comprised of three different submodels: an encoder, a predictor and a joiner.
 The [predictor](https://github.com/pytorch/executorch/blob/main/examples/cadence/models/rnnt_predictor.py) is a sequence of basic ops (embedding, ReLU, linear, layer norm) and can be exported using:
 
 ```bash

docs/source/backends-cadence.md

@@ -197,7 +197,7 @@ In all cases the generated file is called `CadenceDemoModel.pte`.
 
 ***Speech/Audio Models***:
 
-The torchaudio [RNNT-emformer](https://pytorch.org/audio/stable/tutorials/online_asr_tutorial.html) model is an Automatic Speech Recognition (ASR) model, comprised of three different submodels:
+The torchaudio [RNNT-emformer](https://docs.pytorch.org/audio/stable/generated/torchaudio.pipelines.EMFORMER_RNNT_BASE_LIBRISPEECH.html) model is an Automatic Speech Recognition (ASR) model, comprised of three different submodels:
 
 - **RNNT Predictor**: Sequence of basic ops (embedding, ReLU, linear, layer norm)
   ```bash

docs/source/compiler-delegate-and-partitioner.md

@@ -187,18 +187,6 @@ exported_program_backend_1 = to_backend(exported_program, backend_1_parititioner
 exported_program_backend_1_and_2 = to_backend(exported_program_backend_1, backend_2_parititioner())
 ```
 
-A more concrete example be found
-[here](https://github.com/pytorch/executorch/blob/main/exir/backend/test/demos/test_xnnpack_qnnpack.py).
-In this example,
-qnnpack is one backend and xnnpack is another backend. We haven't open-sourced
-these two backends delegates yet, and this example won't run out of box. It can
-be used as a reference to see how it can be done.
-
-This option is easy to try because usually all backends will implement their own
-partitioner. However this option may get different results if we change the
-order of to_backend call. If we want to have a better control on the nodes, like
-which backend they should go, option 2 is better.
-
 *Option 2: Have a partitioner which partitions for different backends*
 
 Another option is to create a customized partitioner, say partitioner

docs/source/getting-started-architecture.md

@@ -22,7 +22,7 @@ leverages PyTorch 2 compiler and export functionality
 [AOTAutograd](https://pytorch.org/functorch/stable/notebooks/aot_autograd_optimizations.html),
 [Quantization](https://pytorch.org/docs/main/quantization.html),
 [dynamic shapes](https://pytorch.org/get-started/pytorch-2.0/#pytorch-2x-faster-more-pythonic-and-as-dynamic-as-ever),
-[control flow](https://pytorch.org/docs/main/export.html#data-shape-dependent-control-flow),
+[control flow](https://docs.pytorch.org/docs/stable/user_guide/torch_compiler/export.html#data-shape-dependent-control-flow),
 etc.) to prepare a PyTorch program for execution on devices.
 
 Program preparation is often simply called AOT (ahead-of-time) because export, transformations and compilations to the program are performed before it is eventually run with the ExecuTorch runtime, written in C++. To have a lightweight runtime and small overhead in execution, we push work as much as possible to AOT.
@@ -33,14 +33,14 @@ Starting from the program source code, below are the steps you would go through
 
 * Like all PyTorch use cases, ExecuTorch starts from model authoring, where standard `nn.Module` eager mode PyTorch programs are created.
 * Export-specific helpers are used to represent advanced features like [control
-  flow](https://pytorch.org/docs/main/export.html#data-shape-dependent-control-flow)
+  flow](https://docs.pytorch.org/docs/stable/user_guide/torch_compiler/export.html#data-shape-dependent-control-flow)
   (for example, helper functions to trace both branches of if-else) and [dynamic
   shapes](https://pytorch.org/get-started/pytorch-2.0/#pytorch-2x-faster-more-pythonic-and-as-dynamic-as-ever)
   (for example, data dependent dynamic shape constraint).
 
 ### Export
 
-To deploy the program to the device, engineers need to have a graph representation for compiling a model to run on various backends. With [`torch.export()`](https://pytorch.org/docs/main/export.html), an [EXIR](ir-exir.md) (export intermediate representation) is generated with ATen dialect. All AOT compilations are based on this EXIR, but can have multiple dialects along the lowering path as detailed below.
+To deploy the program to the device, engineers need to have a graph representation for compiling a model to run on various backends. With [`torch.export()`](https://docs.pytorch.org/docs/stable/user_guide/torch_compiler/export.html), an [EXIR](ir-exir.md) (export intermediate representation) is generated with ATen dialect. All AOT compilations are based on this EXIR, but can have multiple dialects along the lowering path as detailed below.
 
 * _[ATen Dialect](ir-exir.md#aten-dialect)_. PyTorch Edge is based on PyTorch’s Tensor library ATen, which has clear contracts for efficient execution. ATen Dialect is a graph represented by ATen nodes which are fully ATen compliant. Custom operators are allowed, but must be registered with the dispatcher. It’s flatten with no module hierarchy (submodules in a bigger module), but the source code and module hierarchy are preserved in the metadata. This representation is also autograd safe.
 * Optionally, _quantization_, either QAT (quantization-aware training) or PTQ (post training quantization) can be applied to the whole ATen graph before converting to Core ATen. Quantization helps with reducing the model size, which is important for edge devices.