From 460419a6369bd00bfc3ce7a7c92b0ca2a832c91b Mon Sep 17 00:00:00 2001
From: Mark Daoust <markdaoust@google.com>
Date: Wed, 24 Jul 2024 12:40:29 -0700
Subject: [PATCH] Remove unnecessary external tags.

PiperOrigin-RevId: 655664766
---
 site/en/community/contribute/docs_style.md    | 10 ++---
 .../guide/core/logistic_regression_core.ipynb | 30 ++++++-------
 site/en/guide/core/quickstart_core.ipynb      | 10 ++---
 site/en/guide/profiler.md                     |  2 +-
 site/en/guide/tensor.ipynb                    |  8 ++--
 site/en/install/docker.md                     | 26 ++++++------
 site/en/install/errors.md                     |  6 +--
 site/en/install/gpu_plugins.md                | 18 ++++----
 site/en/install/lang_c.ipynb                  |  2 +-
 site/en/install/lang_java_legacy.md           |  6 +--
 site/en/install/pip.md                        | 42 +++++++++----------
 site/en/install/source.md                     | 16 +++----
 site/en/install/source_windows.md             | 14 +++----
 site/en/r1/tutorials/sequences/recurrent.md   |  2 +-
 site/en/tutorials/generative/pix2pix.ipynb    | 20 ++++-----
 site/en/tutorials/images/classification.ipynb |  2 +-
 site/en/tutorials/load_data/video.ipynb       |  4 +-
 17 files changed, 109 insertions(+), 109 deletions(-)

diff --git a/site/en/community/contribute/docs_style.md b/site/en/community/contribute/docs_style.md
index d4e42cb5235..10f18e52699 100644
--- a/site/en/community/contribute/docs_style.md
+++ b/site/en/community/contribute/docs_style.md
@@ -65,8 +65,8 @@ repository like this:
 
 This is the preferred approach because this way the links on
 [tensorflow.org](https://www.tensorflow.org),
-[GitHub](https://github.com/tensorflow/docs){:.external} and
-[Colab](https://github.com/tensorflow/docs/tree/master/site/en/guide/bazics.ipynb){:.external}
+[GitHub](https://github.com/tensorflow/docs) and
+[Colab](https://github.com/tensorflow/docs/tree/master/site/en/guide/bazics.ipynb)
 all work. Also, the reader stays in the same site when they click a link.
 
 Note: You should include the file extension—such as `.ipynb` or `.md`—for
@@ -83,10 +83,10 @@ To link to source code, use a link starting with
 by the file name starting at the GitHub root.
 
 When linking off of [tensorflow.org](https://www.tensorflow.org), include a
-`{:.external}` on the Markdown link so that the "external link" symbol is shown.
+`` on the Markdown link so that the "external link" symbol is shown.
 
-* `[GitHub](https://github.com/tensorflow/docs){:.external}` produces
-  [GitHub](https://github.com/tensorflow/docs){:.external}
+* `[GitHub](https://github.com/tensorflow/docs)` produces
+  [GitHub](https://github.com/tensorflow/docs)
 
 Do not include URI query parameters in the link:
 
diff --git a/site/en/guide/core/logistic_regression_core.ipynb b/site/en/guide/core/logistic_regression_core.ipynb
index 60e433c9759..5a9af324ad5 100644
--- a/site/en/guide/core/logistic_regression_core.ipynb
+++ b/site/en/guide/core/logistic_regression_core.ipynb
@@ -68,9 +68,9 @@
         "id": "DauaqJ7WhIhO"
       },
       "source": [
-        "This guide demonstrates how to use the [TensorFlow Core low-level APIs](https://www.tensorflow.org/guide/core) to perform [binary classification](https://developers.google.com/machine-learning/glossary#binary_classification){:.external} with [logistic regression](https://developers.google.com/machine-learning/crash-course/logistic-regression/){:.external}. It uses the [Wisconsin Breast Cancer Dataset](https://archive.ics.uci.edu/ml/datasets/breast+cancer+wisconsin+(original)){:.external} for tumor classification.\n",
+        "This guide demonstrates how to use the [TensorFlow Core low-level APIs](https://www.tensorflow.org/guide/core) to perform [binary classification](https://developers.google.com/machine-learning/glossary#binary_classification) with [logistic regression](https://developers.google.com/machine-learning/crash-course/logistic-regression/). It uses the [Wisconsin Breast Cancer Dataset](https://archive.ics.uci.edu/ml/datasets/breast+cancer+wisconsin+(original)) for tumor classification.\n",
         "\n",
-        "[Logistic regression](https://developers.google.com/machine-learning/crash-course/logistic-regression/){:.external} is one of the most popular algorithms for binary classification. Given a set of examples with features, the goal of logistic regression is to output values between 0 and 1, which can be interpreted as the probabilities of each example belonging to a particular  class. "
+        "[Logistic regression](https://developers.google.com/machine-learning/crash-course/logistic-regression/) is one of the most popular algorithms for binary classification. Given a set of examples with features, the goal of logistic regression is to output values between 0 and 1, which can be interpreted as the probabilities of each example belonging to a particular  class. "
       ]
     },
     {
@@ -81,7 +81,7 @@
       "source": [
         "## Setup\n",
         "\n",
-        "This tutorial uses [pandas](https://pandas.pydata.org){:.external} for reading a CSV file into a [DataFrame](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.html){:.external}, [seaborn](https://seaborn.pydata.org){:.external} for plotting a pairwise relationship in a dataset, [Scikit-learn](https://scikit-learn.org/){:.external} for computing a confusion matrix, and [matplotlib](https://matplotlib.org/){:.external} for creating visualizations."
+        "This tutorial uses [pandas](https://pandas.pydata.org) for reading a CSV file into a [DataFrame](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.html), [seaborn](https://seaborn.pydata.org) for plotting a pairwise relationship in a dataset, [Scikit-learn](https://scikit-learn.org/) for computing a confusion matrix, and [matplotlib](https://matplotlib.org/) for creating visualizations."
       ]
     },
     {
@@ -128,7 +128,7 @@
       "source": [
         "## Load the data\n",
         "\n",
-        "Next, load the [Wisconsin Breast Cancer Dataset](https://archive.ics.uci.edu/ml/datasets/breast+cancer+wisconsin+(original)){:.external} from the [UCI Machine Learning Repository](https://archive.ics.uci.edu/ml/){:.external}. This dataset contains various features such as a tumor's radius, texture, and concavity."
+        "Next, load the [Wisconsin Breast Cancer Dataset](https://archive.ics.uci.edu/ml/datasets/breast+cancer+wisconsin+(original)) from the [UCI Machine Learning Repository](https://archive.ics.uci.edu/ml/). This dataset contains various features such as a tumor's radius, texture, and concavity."
       ]
     },
     {
@@ -156,7 +156,7 @@
         "id": "A3VR1aTP92nV"
       },
       "source": [
-        "Read the dataset into a pandas [DataFrame](){:.external} using [`pandas.read_csv`](https://pandas.pydata.org/docs/reference/api/pandas.read_csv.html){:.external}:"
+        "Read the dataset into a pandas [DataFrame]() using [`pandas.read_csv`](https://pandas.pydata.org/docs/reference/api/pandas.read_csv.html):"
       ]
     },
     {
@@ -207,7 +207,7 @@
         "id": "s4-Wn2jzVC1W"
       },
       "source": [
-        "Split the dataset into training and test sets using [`pandas.DataFrame.sample`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.sample.html){:.external}, [`pandas.DataFrame.drop`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.drop.html){:.external} and [`pandas.DataFrame.iloc`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.iloc.html){:.external}. Make sure to split the features from the target labels. The test set is used to evaluate your model's generalizability to unseen data."
+        "Split the dataset into training and test sets using [`pandas.DataFrame.sample`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.sample.html), [`pandas.DataFrame.drop`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.drop.html) and [`pandas.DataFrame.iloc`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.iloc.html). Make sure to split the features from the target labels. The test set is used to evaluate your model's generalizability to unseen data."
       ]
     },
     {
@@ -277,7 +277,7 @@
         "\n",
         "This dataset contains the mean, standard error, and largest values for each of the 10 tumor measurements collected per example. The `\"diagnosis\"` target column is a categorical variable with `'M'` indicating a malignant tumor and `'B'` indicating a benign tumor diagnosis. This column needs to be converted into a numerical binary format for model training.\n",
         "\n",
-        "The [`pandas.Series.map`](https://pandas.pydata.org/docs/reference/api/pandas.Series.map.html){:.external} function is useful for mapping binary values to the categories.\n",
+        "The [`pandas.Series.map`](https://pandas.pydata.org/docs/reference/api/pandas.Series.map.html) function is useful for mapping binary values to the categories.\n",
         "\n",
         "The dataset should also be converted to a tensor with the `tf.convert_to_tensor` function after the preprocessing is complete."
       ]
@@ -301,7 +301,7 @@
         "id": "J4ubs136WLNp"
       },
       "source": [
-        "Use [`seaborn.pairplot`](https://seaborn.pydata.org/generated/seaborn.pairplot.html){:.external} to review the joint distribution of a few pairs of mean-based features from the training set and observe how they relate to the target:"
+        "Use [`seaborn.pairplot`](https://seaborn.pydata.org/generated/seaborn.pairplot.html) to review the joint distribution of a few pairs of mean-based features from the training set and observe how they relate to the target:"
       ]
     },
     {
@@ -343,7 +343,7 @@
         "id": "_8pDCIFjMla8"
       },
       "source": [
-        "Given the inconsistent ranges, it is beneficial to standardize the data such that each feature has a zero mean and unit variance. This process is called [normalization](https://developers.google.com/machine-learning/glossary#normalization){:.external}."
+        "Given the inconsistent ranges, it is beneficial to standardize the data such that each feature has a zero mean and unit variance. This process is called [normalization](https://developers.google.com/machine-learning/glossary#normalization)."
       ]
     },
     {
@@ -384,11 +384,11 @@
         "\n",
         "### Logistic regression fundamentals\n",
         "\n",
-        "Linear regression returns a linear combination of its inputs; this output is unbounded. The output of a [logistic regression](https://developers.google.com/machine-learning/glossary#logistic_regression){:.external} is in the `(0, 1)` range. For each example, it represents the probability that the example belongs to the _positive_ class.\n",
+        "Linear regression returns a linear combination of its inputs; this output is unbounded. The output of a [logistic regression](https://developers.google.com/machine-learning/glossary#logistic_regression) is in the `(0, 1)` range. For each example, it represents the probability that the example belongs to the _positive_ class.\n",
         "\n",
         "Logistic regression maps the continuous outputs of traditional linear regression, `(-∞, ∞)`, to probabilities, `(0, 1)`. This transformation is also symmetric so that flipping the sign of the linear output results in the inverse of the original probability.\n",
         "\n",
-        "Let $Y$ denote the probability of being in class `1` (the tumor is malignant). The desired mapping can be achieved by interpreting the linear regression output as the [log odds](https://developers.google.com/machine-learning/glossary#log-odds){:.external} ratio of being in class `1` as opposed to class `0`:\n",
+        "Let $Y$ denote the probability of being in class `1` (the tumor is malignant). The desired mapping can be achieved by interpreting the linear regression output as the [log odds](https://developers.google.com/machine-learning/glossary#log-odds) ratio of being in class `1` as opposed to class `0`:\n",
         "\n",
         "$$\\ln(\\frac{Y}{1-Y}) = wX + b$$\n",
         "\n",
@@ -396,7 +396,7 @@
         "\n",
         "$$Y = \\frac{e^{z}}{1 + e^{z}} = \\frac{1}{1 + e^{-z}}$$\n",
         "\n",
-        "The expression $\\frac{1}{1 + e^{-z}}$ is known as the [sigmoid function](https://developers.google.com/machine-learning/glossary#sigmoid_function){:.external} $\\sigma(z)$. Hence, the equation for logistic regression can be written as $Y = \\sigma(wX + b)$.\n",
+        "The expression $\\frac{1}{1 + e^{-z}}$ is known as the [sigmoid function](https://developers.google.com/machine-learning/glossary#sigmoid_function) $\\sigma(z)$. Hence, the equation for logistic regression can be written as $Y = \\sigma(wX + b)$.\n",
         "\n",
         "The dataset in this tutorial deals with a high-dimensional feature matrix. Therefore, the above equation must be rewritten in a matrix vector form as follows:\n",
         "\n",
@@ -437,7 +437,7 @@
       "source": [
         "### The log loss function\n",
         "\n",
-        "The  [log loss](https://developers.google.com/machine-learning/glossary#Log_Loss){:.external}, or binary cross-entropy loss, is the ideal loss function for a binary classification problem with logistic regression. For each example, the log loss quantifies the similarity between a predicted probability and the example's true value. It is determined by the following equation:\n",
+        "The  [log loss](https://developers.google.com/machine-learning/glossary#Log_Loss), or binary cross-entropy loss, is the ideal loss function for a binary classification problem with logistic regression. For each example, the log loss quantifies the similarity between a predicted probability and the example's true value. It is determined by the following equation:\n",
         "\n",
         "$$L = -\\frac{1}{m}\\sum_{i=1}^{m}y_i\\cdot\\log(\\hat{y}_i) + (1- y_i)\\cdot\\log(1 - \\hat{y}_i)$$\n",
         "\n",
@@ -471,7 +471,7 @@
       "source": [
         "### The gradient descent update rule\n",
         "\n",
-        "The TensorFlow Core APIs support automatic differentiation with `tf.GradientTape`. If you are curious about the mathematics behind the logistic regression [gradient updates](https://developers.google.com/machine-learning/glossary#gradient_descent){:.external}, here is a short explanation:\n",
+        "The TensorFlow Core APIs support automatic differentiation with `tf.GradientTape`. If you are curious about the mathematics behind the logistic regression [gradient updates](https://developers.google.com/machine-learning/glossary#gradient_descent), here is a short explanation:\n",
         "\n",
         "In the above equation for the log loss, recall that each $\\hat{y}_i$ can be rewritten in terms of the inputs as $\\sigma({\\mathrm{X_i}}w + b)$.\n",
         "\n",
@@ -754,7 +754,7 @@
         "\n",
         "For this problem, the FPR is the proportion of malignant tumor predictions amongst tumors that are actually benign. Conversely, the FNR is the proportion of benign tumor predictions among tumors that are actually malignant.\n",
         "\n",
-        "Compute a confusion matrix using [`sklearn.metrics.confusion_matrix`](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.confusion_matrix.html#sklearn.metrics.confusion_matrix){:.external}, which evaluates the accuracy of the classification, and use matplotlib to display the matrix:"
+        "Compute a confusion matrix using [`sklearn.metrics.confusion_matrix`](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.confusion_matrix.html#sklearn.metrics.confusion_matrix), which evaluates the accuracy of the classification, and use matplotlib to display the matrix:"
       ]
     },
     {
diff --git a/site/en/guide/core/quickstart_core.ipynb b/site/en/guide/core/quickstart_core.ipynb
index 6e7d824f548..70586fd3f0c 100644
--- a/site/en/guide/core/quickstart_core.ipynb
+++ b/site/en/guide/core/quickstart_core.ipynb
@@ -68,13 +68,13 @@
         "id": "04QgGZc9bF5D"
       },
       "source": [
-        "This quickstart tutorial demonstrates how you can use the [TensorFlow Core low-level APIs](https://www.tensorflow.org/guide/core) to build and train a multiple linear regression model that predicts fuel efficiency. It uses the [Auto MPG](https://archive.ics.uci.edu/ml/datasets/auto+mpg){:.external} dataset which contains fuel efficiency data for late-1970s and early 1980s automobiles.\n",
+        "This quickstart tutorial demonstrates how you can use the [TensorFlow Core low-level APIs](https://www.tensorflow.org/guide/core) to build and train a multiple linear regression model that predicts fuel efficiency. It uses the [Auto MPG](https://archive.ics.uci.edu/ml/datasets/auto+mpg) dataset which contains fuel efficiency data for late-1970s and early 1980s automobiles.\n",
         "\n",
         "You will follow the typical stages of a machine learning process:\n",
         "\n",
         "1. Load the dataset.\n",
         "2. Build an [input pipeline](../data.ipynb).\n",
-        "3. Build a multiple [linear regression](https://developers.google.com/machine-learning/glossary#linear-regression){:.external} model.\n",
+        "3. Build a multiple [linear regression](https://developers.google.com/machine-learning/glossary#linear-regression) model.\n",
         "4. Evaluate the performance of the model."
       ]
     },
@@ -114,7 +114,7 @@
       "source": [
         "## Load and preprocess the dataset\n",
         "\n",
-        "Next, you need to load and preprocess the [Auto MPG dataset](https://archive.ics.uci.edu/ml/datasets/auto+mpg){:.external} from the [UCI Machine Learning Repository](https://archive.ics.uci.edu/ml/){:.external}. This dataset uses a variety of quantitative and categorical features such as cylinders, displacement, horsepower and weight to predict the fuel efficiencies of automobiles in the late-1970s and early 1980s.\n",
+        "Next, you need to load and preprocess the [Auto MPG dataset](https://archive.ics.uci.edu/ml/datasets/auto+mpg) from the [UCI Machine Learning Repository](https://archive.ics.uci.edu/ml/). This dataset uses a variety of quantitative and categorical features such as cylinders, displacement, horsepower and weight to predict the fuel efficiencies of automobiles in the late-1970s and early 1980s.\n",
         "\n",
         "The dataset contains a few unknown values. Make sure to drop any missing values with `pandas.DataFrame.dropna`, and convert the dataset to a `tf.float32` tensor type with the `tf.convert_to_tensor` and `tf.cast` functions."
       ]
@@ -376,7 +376,7 @@
       "source": [
         "Next, write a training loop to iteratively update your model's parameters by making use of the MSE loss function and its gradients with respect to the input parameters.\n",
         "\n",
-        "This iterative method is referred to as [gradient descent](https://developers.google.com/machine-learning/glossary#gradient-descent){:.external}. At each iteration, the model's parameters are updated by taking a step in the opposite direction of their computed gradients. The size of this step is determined by the learning rate, which is a configurable hyperparameter. Recall that the gradient of a function indicates the direction of its steepest ascent; therefore, taking a step in the opposite direction indicates the direction of steepest descent, which ultimately helps to minimize the MSE loss function."
+        "This iterative method is referred to as [gradient descent](https://developers.google.com/machine-learning/glossary#gradient-descent). At each iteration, the model's parameters are updated by taking a step in the opposite direction of their computed gradients. The size of this step is determined by the learning rate, which is a configurable hyperparameter. Recall that the gradient of a function indicates the direction of its steepest ascent; therefore, taking a step in the opposite direction indicates the direction of steepest descent, which ultimately helps to minimize the MSE loss function."
       ]
     },
     {
@@ -434,7 +434,7 @@
         "id": "4mDAAPFqVVgn"
       },
       "source": [
-        "Plot the changes in MSE loss over time. Calculating performance metrics on a designated [validation set](https://developers.google.com/machine-learning/glossary#validation-set){:.external} or [test set](https://developers.google.com/machine-learning/glossary#test-set){:.external} ensures the model does not overfit to the training dataset and can generalize well to unseen data."
+        "Plot the changes in MSE loss over time. Calculating performance metrics on a designated [validation set](https://developers.google.com/machine-learning/glossary#validation-set) or [test set](https://developers.google.com/machine-learning/glossary#test-set) ensures the model does not overfit to the training dataset and can generalize well to unseen data."
       ]
     },
     {
diff --git a/site/en/guide/profiler.md b/site/en/guide/profiler.md
index e92d1b9eae4..dee8a5a84af 100644
--- a/site/en/guide/profiler.md
+++ b/site/en/guide/profiler.md
@@ -55,7 +55,7 @@ found.
 When you run profiling with CUDA® Toolkit in a Docker environment or on Linux,
 you may encounter issues related to insufficient CUPTI privileges
 (`CUPTI_ERROR_INSUFFICIENT_PRIVILEGES`). Go to the
-[NVIDIA Developer Docs](https://developer.nvidia.com/nvidia-development-tools-solutions-ERR_NVGPUCTRPERM-permission-issue-performance-counters){:.external}
+[NVIDIA Developer Docs](https://developer.nvidia.com/nvidia-development-tools-solutions-ERR_NVGPUCTRPERM-permission-issue-performance-counters)
 to learn more about how you can resolve these issues on Linux.
 
 To resolve CUPTI privilege issues in a Docker environment, run
diff --git a/site/en/guide/tensor.ipynb b/site/en/guide/tensor.ipynb
index b9b72973db1..2eb261aad75 100644
--- a/site/en/guide/tensor.ipynb
+++ b/site/en/guide/tensor.ipynb
@@ -82,7 +82,7 @@
       "source": [
         "Tensors are multi-dimensional arrays with a uniform type (called a `dtype`).  You can see all supported `dtypes` at `tf.dtypes`.\n",
         "\n",
-        "If you're familiar with [NumPy](https://numpy.org/devdocs/user/quickstart.html){:.external}, tensors are (kind of) like `np.arrays`.\n",
+        "If you're familiar with [NumPy](https://numpy.org/devdocs/user/quickstart.html), tensors are (kind of) like `np.arrays`.\n",
         "\n",
         "All tensors are immutable like Python numbers and strings: you can never update the contents of a tensor, only create a new one.\n"
       ]
@@ -571,7 +571,7 @@
       "source": [
         "### Single-axis indexing\n",
         "\n",
-        "TensorFlow follows standard Python indexing rules, similar to [indexing a list or a string in Python](https://docs.python.org/3/tutorial/introduction.html#strings){:.external}, and the basic rules for NumPy indexing.\n",
+        "TensorFlow follows standard Python indexing rules, similar to [indexing a list or a string in Python](https://docs.python.org/3/tutorial/introduction.html#strings), and the basic rules for NumPy indexing.\n",
         "\n",
         "* indexes start at `0`\n",
         "* negative indices count backwards from the end\n",
@@ -1035,7 +1035,7 @@
       "source": [
         "## Broadcasting\n",
         "\n",
-        "Broadcasting is a concept borrowed from the [equivalent feature in NumPy](https://numpy.org/doc/stable/user/basics.broadcasting.html){:.external}.  In short, under certain conditions, smaller tensors are \"stretched\" automatically to fit larger tensors when running combined operations on them.\n",
+        "Broadcasting is a concept borrowed from the [equivalent feature in NumPy](https://numpy.org/doc/stable/user/basics.broadcasting.html).  In short, under certain conditions, smaller tensors are \"stretched\" automatically to fit larger tensors when running combined operations on them.\n",
         "\n",
         "The simplest and most common case is when you attempt to multiply or add a tensor to a scalar.  In that case, the scalar is broadcast to be the same shape as the other argument. "
       ]
@@ -1161,7 +1161,7 @@
       "source": [
         "Unlike a mathematical op, for example, `broadcast_to` does nothing special to save memory.  Here, you are materializing the tensor.\n",
         "\n",
-        "It can get even more complicated.  [This section](https://jakevdp.github.io/PythonDataScienceHandbook/02.05-computation-on-arrays-broadcasting.html){:.external} of Jake VanderPlas's book _Python Data Science Handbook_ shows more broadcasting tricks (again in NumPy)."
+        "It can get even more complicated.  [This section](https://jakevdp.github.io/PythonDataScienceHandbook/02.05-computation-on-arrays-broadcasting.html) of Jake VanderPlas's book _Python Data Science Handbook_ shows more broadcasting tricks (again in NumPy)."
       ]
     },
     {
diff --git a/site/en/install/docker.md b/site/en/install/docker.md
index 8a2b1347668..836d771c31e 100644
--- a/site/en/install/docker.md
+++ b/site/en/install/docker.md
@@ -1,36 +1,36 @@
 # Docker
 
-[Docker](https://docs.docker.com/install/){:.external} uses *containers* to
+[Docker](https://docs.docker.com/install/) uses *containers* to
 create virtual environments that isolate a TensorFlow installation from the rest
 of the system. TensorFlow programs are run *within* this virtual environment that
 can share resources with its host machine (access directories, use the GPU,
 connect to the Internet, etc.). The
-[TensorFlow Docker images](https://hub.docker.com/r/tensorflow/tensorflow/){:.external}
+[TensorFlow Docker images](https://hub.docker.com/r/tensorflow/tensorflow/)
 are tested for each release.
 
 Docker is the easiest way to enable TensorFlow [GPU support](./pip.md) on Linux since only the
-[NVIDIA® GPU driver](https://github.com/NVIDIA/nvidia-docker/wiki/Frequently-Asked-Questions#how-do-i-install-the-nvidia-driver){:.external}
+[NVIDIA® GPU driver](https://github.com/NVIDIA/nvidia-docker/wiki/Frequently-Asked-Questions#how-do-i-install-the-nvidia-driver)
 is required on the *host* machine (the *NVIDIA® CUDA® Toolkit* does not need to
 be installed).
 
 
 ## TensorFlow Docker requirements
 
-1. [Install Docker](https://docs.docker.com/install/){:.external} on
+1. [Install Docker](https://docs.docker.com/install/) on
    your local *host* machine.
-2. For GPU support on Linux, [install NVIDIA Docker support](https://github.com/NVIDIA/nvidia-docker){:.external}.
+2. For GPU support on Linux, [install NVIDIA Docker support](https://github.com/NVIDIA/nvidia-docker).
    * Take note of your Docker version with `docker -v`. Versions __earlier than__ 19.03 require nvidia-docker2 and the `--runtime=nvidia` flag. On versions __including and after__ 19.03, you will use the `nvidia-container-toolkit` package and the `--gpus all` flag. Both options are documented on the page linked above.
 
 Note: To run the `docker` command without `sudo`, create the `docker` group and
 add your user. For details, see the
-[post-installation steps for Linux](https://docs.docker.com/install/linux/linux-postinstall/){:.external}.
+[post-installation steps for Linux](https://docs.docker.com/install/linux/linux-postinstall/).
 
 
 ## Download a TensorFlow Docker image
 
 The official TensorFlow Docker images are located in the 
-[tensorflow/tensorflow](https://hub.docker.com/r/tensorflow/tensorflow/){:.external}
-Docker Hub repository. Image releases [are tagged](https://hub.docker.com/r/tensorflow/tensorflow/tags/){:.external}
+[tensorflow/tensorflow](https://hub.docker.com/r/tensorflow/tensorflow/)
+Docker Hub repository. Image releases [are tagged](https://hub.docker.com/r/tensorflow/tensorflow/tags/)
 using the following format:
 
 | Tag         | Description                                                                                                          |
@@ -64,7 +64,7 @@ To start a TensorFlow-configured container, use the following command form:
 docker run [-it] [--rm] [-p <em>hostPort</em>:<em>containerPort</em>] tensorflow/tensorflow[:<em>tag</em>] [<em>command</em>]
 </pre>
 
-For details, see the [docker run reference](https://docs.docker.com/engine/reference/run/){:.external}.
+For details, see the [docker run reference](https://docs.docker.com/engine/reference/run/).
 
 ### Examples using CPU-only images
 
@@ -98,7 +98,7 @@ docker run -it --rm -v $PWD:/tmp -w /tmp tensorflow/tensorflow python ./script.p
 Permission issues can arise when files created within a container are exposed to
 the host. It's usually best to edit files on the host system.
 
-Start a [Jupyter Notebook](https://jupyter.org/){:.external} server using
+Start a [Jupyter Notebook](https://jupyter.org/) server using
 TensorFlow's nightly build:
 
 <pre class="devsite-terminal devsite-click-to-copy">
@@ -112,13 +112,13 @@ Follow the instructions and open the URL in your host web browser:
 ## GPU support
 
 Docker is the easiest way to run TensorFlow on a GPU since the *host* machine
-only requires the [NVIDIA® driver](https://github.com/NVIDIA/nvidia-docker/wiki/Frequently-Asked-Questions#how-do-i-install-the-nvidia-driver){:.external}
+only requires the [NVIDIA® driver](https://github.com/NVIDIA/nvidia-docker/wiki/Frequently-Asked-Questions#how-do-i-install-the-nvidia-driver)
 (the *NVIDIA® CUDA® Toolkit* is not required).
 
-Install the [Nvidia Container Toolkit](https://github.com/NVIDIA/nvidia-docker/blob/master/README.md#quickstart){:.external} 
+Install the [Nvidia Container Toolkit](https://github.com/NVIDIA/nvidia-docker/blob/master/README.md#quickstart) 
 to add NVIDIA® GPU support to Docker. `nvidia-container-runtime` is only
 available for Linux. See the `nvidia-container-runtime` 
-[platform support FAQ](https://github.com/NVIDIA/nvidia-docker/wiki/Frequently-Asked-Questions#platform-support){:.external}
+[platform support FAQ](https://github.com/NVIDIA/nvidia-docker/wiki/Frequently-Asked-Questions#platform-support)
 for details.
 
 Check if a GPU is available:
diff --git a/site/en/install/errors.md b/site/en/install/errors.md
index d1ad9e50af5..938ba8b454f 100644
--- a/site/en/install/errors.md
+++ b/site/en/install/errors.md
@@ -1,8 +1,8 @@
 # Build and install error messages
 
-TensorFlow uses [GitHub issues](https://github.com/tensorflow/tensorflow/issues){:.external},
-[Stack Overflow](https://stackoverflow.com/questions/tagged/tensorflow){:.external} and
-[TensorFlow Forum](https://discuss.tensorflow.org/c/general-discussion/6){:.external}
+TensorFlow uses [GitHub issues](https://github.com/tensorflow/tensorflow/issues),
+[Stack Overflow](https://stackoverflow.com/questions/tagged/tensorflow) and
+[TensorFlow Forum](https://discuss.tensorflow.org/c/general-discussion/6)
 to track, document, and discuss build and installation problems.
 
 The following list links error messages to a solution or discussion. If you find
diff --git a/site/en/install/gpu_plugins.md b/site/en/install/gpu_plugins.md
index 5abfbc1ef03..39e3cf09b29 100644
--- a/site/en/install/gpu_plugins.md
+++ b/site/en/install/gpu_plugins.md
@@ -4,7 +4,7 @@ Note: This page is for non-NVIDIA® GPU devices. For NVIDIA® GPU support, go to
 the [Install TensorFlow with pip](./pip.md) guide.
 
 TensorFlow's
-[pluggable device](https://github.com/tensorflow/community/blob/master/rfcs/20200624-pluggable-device-for-tensorflow.md){:.external}
+[pluggable device](https://github.com/tensorflow/community/blob/master/rfcs/20200624-pluggable-device-for-tensorflow.md)
 architecture adds new device support as separate plug-in packages that are
 installed alongside the official TensorFlow package.
 
@@ -58,23 +58,23 @@ run()  # PluggableDevices also work with tf.function and graph mode.
 Metal `PluggableDevice` for macOS GPUs:
 
 *   Works with TF 2.5 or later.
-*   [Getting started guide](https://developer.apple.com/metal/tensorflow-plugin/){:.external}.
+*   [Getting started guide](https://developer.apple.com/metal/tensorflow-plugin/).
 *   For questions and feedback, please visit the
-    [Apple Developer Forum](https://developer.apple.com/forums/tags/tensorflow-metal){:.external}.
+    [Apple Developer Forum](https://developer.apple.com/forums/tags/tensorflow-metal).
 
 DirectML `PluggableDevice` for Windows and WSL (preview):
 
 *   Works with `tensorflow-cpu` package, version 2.10 or later.
-*   [PyPI wheel](https://pypi.org/project/tensorflow-directml-plugin/){:.external}.
-*   [GitHub repo](https://github.com/microsoft/tensorflow-directml-plugin){:.external}.
+*   [PyPI wheel](https://pypi.org/project/tensorflow-directml-plugin/).
+*   [GitHub repo](https://github.com/microsoft/tensorflow-directml-plugin).
 *   For questions, feedback or to raise issues, please visit the
-    [Issues page of `tensorflow-directml-plugin` on GitHub](https://github.com/microsoft/tensorflow-directml-plugin/issues){:.external}.
+    [Issues page of `tensorflow-directml-plugin` on GitHub](https://github.com/microsoft/tensorflow-directml-plugin/issues).
 
 Intel® Extension for TensorFlow `PluggableDevice` for Linux and WSL:
 
 *   Works with TF 2.10 or later.
 *   [Getting started guide](https://intel.github.io/intel-extension-for-tensorflow/latest/get_started.html)
-*   [PyPI wheel](https://pypi.org/project/intel-extension-for-tensorflow/){:.external}.
-*   [GitHub repo](https://github.com/intel/intel-extension-for-tensorflow){:.external}.
+*   [PyPI wheel](https://pypi.org/project/intel-extension-for-tensorflow/).
+*   [GitHub repo](https://github.com/intel/intel-extension-for-tensorflow).
 *   For questions, feedback, or to raise issues, please visit the
-    [Issues page of `intel-extension-for-tensorflow` on GitHub](https://github.com/intel/intel-extension-for-tensorflow/issues){:.external}.
+    [Issues page of `intel-extension-for-tensorflow` on GitHub](https://github.com/intel/intel-extension-for-tensorflow/issues).
diff --git a/site/en/install/lang_c.ipynb b/site/en/install/lang_c.ipynb
index 184f626a208..240cfc29865 100644
--- a/site/en/install/lang_c.ipynb
+++ b/site/en/install/lang_c.ipynb
@@ -355,7 +355,7 @@
         "## Build from source\n",
         "\n",
         "TensorFlow is open source. Read\n",
-        "[the instructions](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/tools/lib_package/README.md){:.external}\n",
+        "[the instructions](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/tools/lib_package/README.md)\n",
         "to build TensorFlow's C library from source code."
       ]
     }
diff --git a/site/en/install/lang_java_legacy.md b/site/en/install/lang_java_legacy.md
index 3a2e121cfc7..37341c36659 100644
--- a/site/en/install/lang_java_legacy.md
+++ b/site/en/install/lang_java_legacy.md
@@ -27,7 +27,7 @@ To use TensorFlow on Android see [TensorFlow Lite](https://tensorflow.org/lite)
 
 ## TensorFlow with Apache Maven
 
-To use TensorFlow with [Apache Maven](https://maven.apache.org){:.external},
+To use TensorFlow with [Apache Maven](https://maven.apache.org),
 add the dependency to the project's `pom.xml` file:
 
 ```xml
@@ -167,7 +167,7 @@ system and processor support:
 Note: On Windows, the native library (`tensorflow_jni.dll`) requires
 `msvcp140.dll` at runtime. See the
 [Windows build from source](./source_windows.md) guide to install the
-[Visual C++ 2019 Redistributable](https://visualstudio.microsoft.com/vs/){:.external}.
+[Visual C++ 2019 Redistributable](https://visualstudio.microsoft.com/vs/).
 
 ### Compile
 
@@ -203,5 +203,5 @@ Success: TensorFlow for Java is configured.
 ## Build from source
 
 TensorFlow is open source. Read
-[the instructions](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/java/README.md){:.external}
+[the instructions](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/java/README.md)
 to build TensorFlow's Java and native libraries from source code.
diff --git a/site/en/install/pip.md b/site/en/install/pip.md
index e5890a31ef5..ffa6cfeab61 100644
--- a/site/en/install/pip.md
+++ b/site/en/install/pip.md
@@ -62,11 +62,11 @@ step-by-step instructions.
     Note: TensorFlow with GPU access is supported for WSL2 on Windows 10 19044 or
     higher. This corresponds to Windows 10 version 21H2, the November 2021
     update. You can get the latest update from here:
-    [Download Windows 10](https://www.microsoft.com/software-download/windows10){:.external}.
+    [Download Windows 10](https://www.microsoft.com/software-download/windows10).
     For instructions, see
-    [Install WSL2](https://docs.microsoft.com/windows/wsl/install){:.external}
+    [Install WSL2](https://docs.microsoft.com/windows/wsl/install)
     and
-    [NVIDIA’s setup docs](https://docs.nvidia.com/cuda/wsl-user-guide/index.html){:.external}
+    [NVIDIA’s setup docs](https://docs.nvidia.com/cuda/wsl-user-guide/index.html)
     for CUDA in WSL.
 
     ```bash
@@ -108,14 +108,14 @@ step-by-step instructions.
 ## Hardware requirements
 
 Note: TensorFlow binaries use
-[AVX instructions](https://en.wikipedia.org/wiki/Advanced_Vector_Extensions#CPUs_with_AVX){:.external}
+[AVX instructions](https://en.wikipedia.org/wiki/Advanced_Vector_Extensions#CPUs_with_AVX)
 which may not run on older CPUs.
 
 The following GPU-enabled devices are supported:
 
 *   NVIDIA® GPU card with CUDA® architectures 3.5, 5.0, 6.0, 7.0, 7.5, 8.0 and
     higher. See the list of
-    [CUDA®-enabled GPU cards](https://developer.nvidia.com/cuda-gpus){:.external}.
+    [CUDA®-enabled GPU cards](https://developer.nvidia.com/cuda-gpus).
 *   For GPUs with unsupported CUDA® architectures, or to avoid JIT compilation
     from PTX, or to use different versions of the NVIDIA® libraries, see the
     [Linux build from source](./source.md) guide.
@@ -123,7 +123,7 @@ The following GPU-enabled devices are supported:
     architecture; therefore, TensorFlow fails to load on older GPUs when
     `CUDA_FORCE_PTX_JIT=1` is set. (See
     [Application Compatibility](https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#application-compatibility)
-    for details.) {:.external}
+    for details.) 
 
 Note: The error message "Status: device kernel image is invalid" indicates that
 the TensorFlow package does not contain PTX for your architecture. You can
@@ -144,18 +144,18 @@ Note: GPU support is available for Ubuntu and Windows with CUDA®-enabled cards.
 *   pip version 19.0 or higher for Linux (requires `manylinux2014` support) and
     Windows. pip version 20.3 or higher for macOS.
 *   Windows Native Requires
-    [Microsoft Visual C++ Redistributable for Visual Studio 2015, 2017 and 2019](https://support.microsoft.com/help/2977003/the-latest-supported-visual-c-downloads){:.external}
+    [Microsoft Visual C++ Redistributable for Visual Studio 2015, 2017 and 2019](https://support.microsoft.com/help/2977003/the-latest-supported-visual-c-downloads)
 
 
 The following NVIDIA® software are only required for GPU support.
 
-*   [NVIDIA® GPU drivers](https://www.nvidia.com/drivers){:.external}
+*   [NVIDIA® GPU drivers](https://www.nvidia.com/drivers)
     * >= 525.60.13 for Linux
     * >= 528.33 for WSL on Windows
-*   [CUDA® Toolkit 12.3](https://developer.nvidia.com/cuda-toolkit-archive){:.external}.
-*   [cuDNN SDK 8.9.7](https://developer.nvidia.com/cudnn){:.external}.
+*   [CUDA® Toolkit 12.3](https://developer.nvidia.com/cuda-toolkit-archive).
+*   [cuDNN SDK 8.9.7](https://developer.nvidia.com/cudnn).
 *   *(Optional)*
-    [TensorRT](https://docs.nvidia.com/deeplearning/tensorrt/archives/index.html#trt_7){:.external}
+    [TensorRT](https://docs.nvidia.com/deeplearning/tensorrt/archives/index.html#trt_7)
     to improve latency and throughput for inference.
 
 ## Step-by-step instructions
@@ -186,7 +186,7 @@ The following NVIDIA® software are only required for GPU support.
     You can skip this section if you only run TensorFlow on the CPU.
 
     Install the
-    [NVIDIA GPU driver](https://www.nvidia.com/Download/index.aspx){:.external}
+    [NVIDIA GPU driver](https://www.nvidia.com/Download/index.aspx)
     if you have not. You can use the following command to verify it is
     installed.
 
@@ -317,25 +317,25 @@ The following NVIDIA® software are only required for GPU support.
     with *Visual Studio 2019* but can be installed separately:
 
     1.  Go to the
-        [Microsoft Visual C++ downloads](https://support.microsoft.com/help/2977003/the-latest-supported-visual-c-downloads){:.external}.
+        [Microsoft Visual C++ downloads](https://support.microsoft.com/help/2977003/the-latest-supported-visual-c-downloads).
     2.  Scroll down the page to the *Visual Studio 2015, 2017 and 2019* section.
     3.  Download and install the *Microsoft Visual C++ Redistributable for
         Visual Studio 2015, 2017 and 2019* for your platform.
 
     Make sure
-    [long paths are enabled](https://superuser.com/questions/1119883/windows-10-enable-ntfs-long-paths-policy-option-missing){:.external}
+    [long paths are enabled](https://superuser.com/questions/1119883/windows-10-enable-ntfs-long-paths-policy-option-missing)
     on Windows.
 
     ### 3. Install Miniconda
 
-    [Miniconda](https://docs.conda.io/en/latest/miniconda.html){:.external}
+    [Miniconda](https://docs.conda.io/en/latest/miniconda.html)
     is the recommended approach for installing TensorFlow with GPU support.
     It creates a separate environment to avoid changing any installed
     software in your system. This is also the easiest way to install the
     required software especially for the GPU setup.
 
     Download the
-    [Miniconda Windows Installer](https://repo.anaconda.com/miniconda/Miniconda3-latest-Windows-x86_64.exe){:.external}.
+    [Miniconda Windows Installer](https://repo.anaconda.com/miniconda/Miniconda3-latest-Windows-x86_64.exe).
     Double-click the downloaded file and follow the instructions on the screen.
 
     ### 4. Create a conda environment
@@ -360,7 +360,7 @@ The following NVIDIA® software are only required for GPU support.
     You can skip this section if you only run TensorFlow on CPU.
 
     First install
-    [NVIDIA GPU driver](https://www.nvidia.com/Download/index.aspx){:.external}
+    [NVIDIA GPU driver](https://www.nvidia.com/Download/index.aspx)
     if you have not.
 
     Then install the CUDA, cuDNN with conda.
@@ -417,16 +417,16 @@ The following NVIDIA® software are only required for GPU support.
    
     See the following documents to:
    
-    * [Download the latest Windows 10 update](https://www.microsoft.com/software-download/windows10){:.external}.
-    * [Install WSL2](https://docs.microsoft.com/windows/wsl/install){:.external}
-    * [Setup NVIDIA® GPU support in WSL2](https://docs.nvidia.com/cuda/wsl-user-guide/index.html){:.external}
+    * [Download the latest Windows 10 update](https://www.microsoft.com/software-download/windows10).
+    * [Install WSL2](https://docs.microsoft.com/windows/wsl/install)
+    * [Setup NVIDIA® GPU support in WSL2](https://docs.nvidia.com/cuda/wsl-user-guide/index.html)
 
     ### 2. GPU setup
 
     You can skip this section if you only run TensorFlow on the CPU.
 
     Install the
-    [NVIDIA GPU driver](https://www.nvidia.com/Download/index.aspx){:.external}
+    [NVIDIA GPU driver](https://www.nvidia.com/Download/index.aspx)
     if you have not. You can use the following command to verify it is
     installed.
 
diff --git a/site/en/install/source.md b/site/en/install/source.md
index c4240b603df..629791134f8 100644
--- a/site/en/install/source.md
+++ b/site/en/install/source.md
@@ -117,8 +117,8 @@ Note: It is easier to set up one of TensorFlow's GPU-enabled [Docker images](#do
 
 ### Download the TensorFlow source code
 
-Use [Git](https://git-scm.com/){:.external} to clone the
-[TensorFlow repository](https://github.com/tensorflow/tensorflow){:.external}:
+Use [Git](https://git-scm.com/) to clone the
+[TensorFlow repository](https://github.com/tensorflow/tensorflow):
 
 <pre class="devsite-click-to-copy">
 <code class="devsite-terminal">git clone https://github.com/tensorflow/tensorflow.git</code>
@@ -126,7 +126,7 @@ Use [Git](https://git-scm.com/){:.external} to clone the
 </pre>
 
 The repo defaults to the `master` development branch. You can also check out a
-[release branch](https://github.com/tensorflow/tensorflow/releases){:.external}
+[release branch](https://github.com/tensorflow/tensorflow/releases)
 to build:
 
 <pre class="devsite-terminal prettyprint lang-bsh">
@@ -223,7 +223,7 @@ building.
 For compilation optimization flags, the default (`-march=native`) optimizes the
 generated code for your machine's CPU type. However, if building TensorFlow for
 a different CPU type, consider a more specific optimization flag. Check the
-[GCC manual](https://gcc.gnu.org/onlinedocs/gcc-4.5.3/gcc/i386-and-x86_002d64-Options.html){:.external}
+[GCC manual](https://gcc.gnu.org/onlinedocs/gcc-4.5.3/gcc/i386-and-x86_002d64-Options.html)
 for examples.
 
 #### Preconfigured configurations
@@ -235,7 +235,7 @@ There are some preconfigured build configs available that can be added to the
     [CONTRIBUTING.md](https://github.com/tensorflow/tensorflow/blob/master/CONTRIBUTING.md)
     for details.
 *   `--config=mkl` —Support for the
-    [Intel® MKL-DNN](https://github.com/intel/mkl-dnn){:.external}.
+    [Intel® MKL-DNN](https://github.com/intel/mkl-dnn).
 *   `--config=monolithic` —Configuration for a mostly static, monolithic build.
 
 
@@ -303,7 +303,7 @@ TensorFlow's Docker development images are an easy way to set up an environment
 to build Linux packages from source. These images already contain the source
 code and dependencies required to build TensorFlow. Go to the TensorFlow
 [Docker guide](./docker.md) for installation instructions and the
-[list of available image tags](https://hub.docker.com/r/tensorflow/tensorflow/tags/){:.external}.
+[list of available image tags](https://hub.docker.com/r/tensorflow/tensorflow/tags/).
 
 ### CPU-only
 
@@ -372,10 +372,10 @@ On your host machine, the TensorFlow *pip* package is in the current directory
 
 Docker is the easiest way to build GPU support for TensorFlow since the *host*
 machine only requires the
-[NVIDIA®&nbsp;driver](https://github.com/NVIDIA/nvidia-docker/wiki/Frequently-Asked-Questions#how-do-i-install-the-nvidia-driver){:.external}
+[NVIDIA®&nbsp;driver](https://github.com/NVIDIA/nvidia-docker/wiki/Frequently-Asked-Questions#how-do-i-install-the-nvidia-driver)
 (the *NVIDIA® CUDA® Toolkit* doesn't have to be installed). Refer to the
 [GPU support guide](./pip.md) and the TensorFlow [Docker guide](./docker.md) to
-set up [nvidia-docker](https://github.com/NVIDIA/nvidia-docker){:.external}
+set up [nvidia-docker](https://github.com/NVIDIA/nvidia-docker)
 (Linux only).
 
 The following example downloads the TensorFlow `:devel-gpu` image and uses
diff --git a/site/en/install/source_windows.md b/site/en/install/source_windows.md
index 1d2a99a218a..68fbcbf4785 100644
--- a/site/en/install/source_windows.md
+++ b/site/en/install/source_windows.md
@@ -13,7 +13,7 @@ environment.
 ### Install Python and the TensorFlow package dependencies
 
 Install a
-[Python 3.9+ 64-bit release for Windows](https://www.python.org/downloads/windows/){:.external}.
+[Python 3.9+ 64-bit release for Windows](https://www.python.org/downloads/windows/).
 Select *pip* as an optional feature and add it to your `%PATH%` environmental
 variable.
 
@@ -42,7 +42,7 @@ Add the location of the Bazel executable to your `%PATH%` environment variable.
 
 ### Install MSYS2
 
-[Install MSYS2](https://www.msys2.org/){:.external} for the bin tools needed to
+[Install MSYS2](https://www.msys2.org/) for the bin tools needed to
 build TensorFlow. If MSYS2 is installed to `C:\msys64`, add
 `C:\msys64\usr\bin` to your `%PATH%` environment variable. Then, using `cmd.exe`,
 run:
@@ -63,7 +63,7 @@ Install the *Visual C++ build tools 2022*. This comes with *Visual Studio Commun
 but can be installed separately:
 
 1.  Go to the
-    [Visual Studio downloads](https://visualstudio.microsoft.com/downloads/){:.external},
+    [Visual Studio downloads](https://visualstudio.microsoft.com/downloads/),
 2.  Select *Tools for Visual Studio or Other Tools, Framework and Redistributables*,
 3.  Download and install:
     -   *Build Tools for Visual Studio 2022*
@@ -74,7 +74,7 @@ Note: TensorFlow is tested against the *Visual Studio Community 2022*.
 ### Install LLVM
 
 1.  Go to the
-    [LLVM downloads](https://github.com/llvm/llvm-project/releases/){:.external},
+    [LLVM downloads](https://github.com/llvm/llvm-project/releases/),
 2.  Download and install Windows-compatible LLVM in C:/Program Files/LLVM e.g., LLVM-17.0.6-win64.exe
 
 
@@ -87,8 +87,8 @@ Note: GPU support on native-Windows is only available for 2.10 or earlier versio
 
 ### Download the TensorFlow source code
 
-Use [Git](https://git-scm.com/){:.external} to clone the
-[TensorFlow repository](https://github.com/tensorflow/tensorflow){:.external}
+Use [Git](https://git-scm.com/) to clone the
+[TensorFlow repository](https://github.com/tensorflow/tensorflow)
 (`git` is installed with MSYS2):
 
 <pre class="devsite-click-to-copy">
@@ -97,7 +97,7 @@ Use [Git](https://git-scm.com/){:.external} to clone the
 </pre>
 
 The repo defaults to the `master` development branch. You can also check out a
-[release branch](https://github.com/tensorflow/tensorflow/releases){:.external}
+[release branch](https://github.com/tensorflow/tensorflow/releases)
 to build:
 
 <pre class="devsite-terminal tfo-terminal-windows prettyprint lang-bsh">
diff --git a/site/en/r1/tutorials/sequences/recurrent.md b/site/en/r1/tutorials/sequences/recurrent.md
index 6654795d944..e7c1f8c0b16 100644
--- a/site/en/r1/tutorials/sequences/recurrent.md
+++ b/site/en/r1/tutorials/sequences/recurrent.md
@@ -2,7 +2,7 @@
 
 ## Introduction
 
-See [Understanding LSTM Networks](https://colah.github.io/posts/2015-08-Understanding-LSTMs/){:.external}
+See [Understanding LSTM Networks](https://colah.github.io/posts/2015-08-Understanding-LSTMs/)
 for an introduction to recurrent neural networks and LSTMs.
 
 ## Language Modeling
diff --git a/site/en/tutorials/generative/pix2pix.ipynb b/site/en/tutorials/generative/pix2pix.ipynb
index e45950dd923..0709353942d 100644
--- a/site/en/tutorials/generative/pix2pix.ipynb
+++ b/site/en/tutorials/generative/pix2pix.ipynb
@@ -70,16 +70,16 @@
         "id": "ITZuApL56Mny"
       },
       "source": [
-        "This tutorial demonstrates how to build and train a conditional generative adversarial network (cGAN) called pix2pix that learns a mapping from input images to output images, as described in [Image-to-image translation with conditional adversarial networks](https://arxiv.org/abs/1611.07004){:.external} by Isola et al. (2017). pix2pix is not application specific—it can be applied to a wide range of tasks, including synthesizing photos from label maps, generating colorized photos from black and white images, turning Google Maps photos into aerial images, and even transforming sketches into photos.\n",
+        "This tutorial demonstrates how to build and train a conditional generative adversarial network (cGAN) called pix2pix that learns a mapping from input images to output images, as described in [Image-to-image translation with conditional adversarial networks](https://arxiv.org/abs/1611.07004) by Isola et al. (2017). pix2pix is not application specific—it can be applied to a wide range of tasks, including synthesizing photos from label maps, generating colorized photos from black and white images, turning Google Maps photos into aerial images, and even transforming sketches into photos.\n",
         "\n",
-        "In this example, your network will generate images of building facades using the [CMP Facade Database](http://cmp.felk.cvut.cz/~tylecr1/facade/) provided by the [Center for Machine Perception](http://cmp.felk.cvut.cz/){:.external} at the [Czech Technical University in Prague](https://www.cvut.cz/){:.external}. To keep it short, you will use a [preprocessed copy](https://efrosgans.eecs.berkeley.edu/pix2pix/datasets/){:.external} of this dataset created by the pix2pix authors.\n",
+        "In this example, your network will generate images of building facades using the [CMP Facade Database](http://cmp.felk.cvut.cz/~tylecr1/facade/) provided by the [Center for Machine Perception](http://cmp.felk.cvut.cz/) at the [Czech Technical University in Prague](https://www.cvut.cz/). To keep it short, you will use a [preprocessed copy](https://efrosgans.eecs.berkeley.edu/pix2pix/datasets/) of this dataset created by the pix2pix authors.\n",
         "\n",
         "In the pix2pix cGAN, you condition on input images and generate corresponding output images. cGANs were first proposed in [Conditional Generative Adversarial Nets](https://arxiv.org/abs/1411.1784) (Mirza and Osindero, 2014)\n",
         "\n",
         "The architecture of your network will contain:\n",
         "\n",
-        "- A generator with a [U-Net](https://arxiv.org/abs/1505.04597){:.external}-based architecture.\n",
-        "- A discriminator represented by a convolutional PatchGAN classifier (proposed in the [pix2pix paper](https://arxiv.org/abs/1611.07004){:.external}).\n",
+        "- A generator with a [U-Net](https://arxiv.org/abs/1505.04597)-based architecture.\n",
+        "- A discriminator represented by a convolutional PatchGAN classifier (proposed in the [pix2pix paper](https://arxiv.org/abs/1611.07004)).\n",
         "\n",
         "Note that each epoch can take around 15 seconds on a single V100 GPU.\n",
         "\n",
@@ -125,7 +125,7 @@
       "source": [
         "## Load the dataset\n",
         "\n",
-        "Download the CMP Facade Database data (30MB). Additional datasets are available in the same format [here](http://efrosgans.eecs.berkeley.edu/pix2pix/datasets/){:.external}. In Colab you can select other datasets from the drop-down menu. Note that some of the other datasets are significantly larger (`edges2handbags` is 8GB in size). "
+        "Download the CMP Facade Database data (30MB). Additional datasets are available in the same format [here](http://efrosgans.eecs.berkeley.edu/pix2pix/datasets/). In Colab you can select other datasets from the drop-down menu. Note that some of the other datasets are significantly larger (`edges2handbags` is 8GB in size). "
       ]
     },
     {
@@ -274,7 +274,7 @@
         "id": "PVuZQTfI_c-s"
       },
       "source": [
-        "As described in the [pix2pix paper](https://arxiv.org/abs/1611.07004){:.external}, you need to apply random jittering and mirroring to preprocess the training set.\n",
+        "As described in the [pix2pix paper](https://arxiv.org/abs/1611.07004), you need to apply random jittering and mirroring to preprocess the training set.\n",
         "\n",
         "Define several functions that:\n",
         "\n",
@@ -490,7 +490,7 @@
       "source": [
         "## Build the generator\n",
         "\n",
-        "The generator of your pix2pix cGAN is a _modified_ [U-Net](https://arxiv.org/abs/1505.04597){:.external}. A U-Net consists of an encoder (downsampler) and decoder (upsampler). (You can find out more about it in the [Image segmentation](../images/segmentation.ipynb) tutorial and on the [U-Net project website](https://lmb.informatik.uni-freiburg.de/people/ronneber/u-net/){:.external}.)\n",
+        "The generator of your pix2pix cGAN is a _modified_ [U-Net](https://arxiv.org/abs/1505.04597). A U-Net consists of an encoder (downsampler) and decoder (upsampler). (You can find out more about it in the [Image segmentation](../images/segmentation.ipynb) tutorial and on the [U-Net project website](https://lmb.informatik.uni-freiburg.de/people/ronneber/u-net/).)\n",
         "\n",
         "- Each block in the encoder is: Convolution -> Batch normalization -> Leaky ReLU\n",
         "- Each block in the decoder is: Transposed convolution -> Batch normalization -> Dropout (applied to the first 3 blocks) -> ReLU\n",
@@ -722,7 +722,7 @@
       "source": [
         "### Define the generator loss\n",
         "\n",
-        "GANs learn a loss that adapts to the data, while cGANs learn a structured loss that penalizes a possible structure that differs from the network output and the target image, as described in the [pix2pix paper](https://arxiv.org/abs/1611.07004){:.external}.\n",
+        "GANs learn a loss that adapts to the data, while cGANs learn a structured loss that penalizes a possible structure that differs from the network output and the target image, as described in the [pix2pix paper](https://arxiv.org/abs/1611.07004).\n",
         "\n",
         "- The generator loss is a sigmoid cross-entropy loss of the generated images and an **array of ones**.\n",
         "- The pix2pix paper also mentions the L1 loss, which is a MAE (mean absolute error) between the generated image and the target image.\n",
@@ -797,7 +797,7 @@
       "source": [
         "## Build the discriminator\n",
         "\n",
-        "The discriminator in the pix2pix cGAN is a convolutional PatchGAN classifier—it tries to classify if each image _patch_ is real or not real, as described in the [pix2pix paper](https://arxiv.org/abs/1611.07004){:.external}.\n",
+        "The discriminator in the pix2pix cGAN is a convolutional PatchGAN classifier—it tries to classify if each image _patch_ is real or not real, as described in the [pix2pix paper](https://arxiv.org/abs/1611.07004).\n",
         "\n",
         "- Each block in the discriminator is: Convolution -> Batch normalization -> Leaky ReLU.\n",
         "- The shape of the output after the last layer is `(batch_size, 30, 30, 1)`.\n",
@@ -937,7 +937,7 @@
       "source": [
         "The training procedure for the discriminator is shown below.\n",
         "\n",
-        "To learn more about the architecture and the hyperparameters you can refer to the [pix2pix paper](https://arxiv.org/abs/1611.07004){:.external}."
+        "To learn more about the architecture and the hyperparameters you can refer to the [pix2pix paper](https://arxiv.org/abs/1611.07004)."
       ]
     },
     {
diff --git a/site/en/tutorials/images/classification.ipynb b/site/en/tutorials/images/classification.ipynb
index f54da222cce..73a0dafcd07 100644
--- a/site/en/tutorials/images/classification.ipynb
+++ b/site/en/tutorials/images/classification.ipynb
@@ -797,7 +797,7 @@
       "source": [
         "## Dropout\n",
         "\n",
-        "Another technique to reduce overfitting is to introduce [dropout](https://developers.google.com/machine-learning/glossary#dropout_regularization){:.external} regularization to the network.\n",
+        "Another technique to reduce overfitting is to introduce [dropout](https://developers.google.com/machine-learning/glossary#dropout_regularization) regularization to the network.\n",
         "\n",
         "When you apply dropout to a layer, it randomly drops out (by setting the activation to zero) a number of output units from the layer during the training process. Dropout takes a fractional number as its input value, in the form such as 0.1, 0.2, 0.4, etc. This means dropping out 10%, 20% or 40% of the output units randomly from the applied layer.\n",
         "\n",
diff --git a/site/en/tutorials/load_data/video.ipynb b/site/en/tutorials/load_data/video.ipynb
index 46bafb31d1c..42439404948 100644
--- a/site/en/tutorials/load_data/video.ipynb
+++ b/site/en/tutorials/load_data/video.ipynb
@@ -660,7 +660,7 @@
       "source": [
         "## Visualize video data\n",
         "\n",
-        "The `frames_from_video_file` function that returns a set of frames as a NumPy array. Try using this function on a new video from [Wikimedia](https://commons.wikimedia.org/wiki/Category:Videos_of_sports){:.external} by Patrick Gillett:"
+        "The `frames_from_video_file` function that returns a set of frames as a NumPy array. Try using this function on a new video from [Wikimedia](https://commons.wikimedia.org/wiki/Category:Videos_of_sports) by Patrick Gillett:"
       ]
     },
     {
@@ -965,7 +965,7 @@
       "source": [
         "## Next steps\n",
         "\n",
-        "Now that you have created a TensorFlow `Dataset` of video frames with their labels, you can use it with a deep learning model. The following classification model that uses a pre-trained [EfficientNet](https://arxiv.org/abs/1905.11946){:.external} trains to high accuracy in a few minutes:"
+        "Now that you have created a TensorFlow `Dataset` of video frames with their labels, you can use it with a deep learning model. The following classification model that uses a pre-trained [EfficientNet](https://arxiv.org/abs/1905.11946) trains to high accuracy in a few minutes:"
       ]
     },
     {