docs(zh): review and punctuation & space fix (#26627)

897a826d · Jabasukuriputo Wang · GitHub · 360ea8fc · 897a826d · 897a826d
Unverified Commit 897a826d authored Oct 06, 2023 by Jabasukuriputo Wang Committed by GitHub Oct 06, 2023
4 changed files
--- a/docs/source/zh/_toctree.yml
+++ b/docs/source/zh/_toctree.yml
 - sections:
  - local: index
-    title: 🤗 Transformers简介
+    title: 🤗 Transformers 简介
  - local: quicktour
    title: 快速上手
  - local: installation
    title: 安装
  title: 开始使用
\ No newline at end of file
--- a/docs/source/zh/index.md
+++ b/docs/source/zh/index.md
@@ -16,20 +16,20 @@ rendered properly in your Markdown viewer.
 # 🤗 Transformers简介
-为[PyTorch](https://pytorch.org/), [TensorFlow](https://www.tensorflow.org/)和[JAX](https://jax.readthedocs.io/en/latest/)打造的先进的机器学习工具.
+为 [PyTorch](https://pytorch.org/)、[TensorFlow](https://www.tensorflow.org/) 和 [JAX](https://jax.readthedocs.io/en/latest/) 打造的先进的机器学习工具.
-🤗 Transformers 提供了可以轻松地下载并且训练先进的预训练模型的API和工具. 使用预训练模型可以减少计算消耗和碳排放, 并且节省从头训练所需要的时间和资源. 这些模型支持不同模态中的常见任务，比如:
+🤗 Transformers 提供了可以轻松地下载并且训练先进的预训练模型的 API 和工具。使用预训练模型可以减少计算消耗和碳排放，并且节省从头训练所需要的时间和资源。这些模型支持不同模态中的常见任务，比如：
-📝 **自然语言处理**: 文本分类, 命名实体识别, 问答, 语言建模, 摘要, 翻译, 多项选择和文本生成.<br>
+📝 **自然语言处理**：文本分类、命名实体识别、问答、语言建模、摘要、翻译、多项选择和文本生成。<br>
-🖼️ **机器视觉**: 图像分类, 目标检测和语义分割.<br>
+🖼️ **机器视觉**：图像分类、目标检测和语义分割。<br>
-🗣️ **音频**: 自动语音识别和音频分类.<br>
+🗣️ **音频**：自动语音识别和音频分类。<br>
-🐙 **多模态**: 表格问答, 光学字符识别, 从扫描文档提取信息, 视频分类和视觉问答.
+🐙 **多模态**：表格问答、光学字符识别、从扫描文档提取信息、视频分类和视觉问答。
-🤗 Transformers支持在PyTorch, TensorFlow和JAX上的互操作性. 这给在模型的每个阶段使用不同的框架带来了灵活性; 在一个框架中使用几行代码训练一个模型, 然后在另一个框架中加载它并进行推理. 模型也可以被导出为ONNX和TorchScript格式, 用于在生产环境中部署.
+🤗 Transformers 支持在 PyTorch、TensorFlow 和 JAX 上的互操作性. 这给在模型的每个阶段使用不同的框架带来了灵活性；在一个框架中使用几行代码训练一个模型，然后在另一个框架中加载它并进行推理。模型也可以被导出为 ONNX 和 TorchScript 格式，用于在生产环境中部署。
-马上加入在[Hub](https://huggingface.co/models), [forum](https://discuss.huggingface.co/), 或者[Discord](https://discord.com/invite/JfAtkvEtRb)上正在快速发展的社区吧!
+马上加入在 [Hub](https://huggingface.co/models)、[论坛](https://discuss.huggingface.co/) 或者 [Discord](https://discord.com/invite/JfAtkvEtRb) 上正在快速发展的社区吧！
-## 如果你需要来自Hugging Face团队的个性化支持
+## 如果你需要来自 Hugging Face 团队的个性化支持
 <a target="_blank" href="https://huggingface.co/support">
    <img alt="HuggingFace Expert Acceleration Program" src="https://cdn-media.huggingface.co/marketing/transformers/new-support-improved.png" style="width: 100%; max-width: 600px; border: 1px solid #eee; border-radius: 4px; box-shadow: 0 1px 2px 0 rgba(0, 0, 0, 0.05);">
@@ -39,15 +39,15 @@ rendered properly in your Markdown viewer.
 这篇文档被组织为以下5个章节:
- **开始使用** 包含了库的快速上手和安装说明, 便于配置和运行.
+- **开始使用** 包含了库的快速上手和安装说明，便于配置和运行。
- **教程** 是一个初学者开始的好地方. 本章节将帮助你获得你会用到的使用这个库的基本技能.
+- **教程** 是一个初学者开始的好地方。本章节将帮助你获得你会用到的使用这个库的基本技能。
- **操作指南** 向你展示如何实现一个特定目标, 比如为语言建模微调一个预训练模型或者如何创造并分享个性化模型.
+- **操作指南** 向你展示如何实现一个特定目标，比如为语言建模微调一个预训练模型或者如何创造并分享个性化模型。
- **概念指南** 对🤗 Transformers的模型, 任务和设计理念背后的基本概念和思想做了更多的讨论和解释.
+- **概念指南** 对 🤗 Transformers 的模型，任务和设计理念背后的基本概念和思想做了更多的讨论和解释。
- **API介绍** 描述了所有的类和函数:
+- **API 介绍** 描述了所有的类和函数：
-  - **MAIN CLASSES** 详述了配置(configuration)、模型(model)、分词器(tokenizer)和流水线(pipeline)这几个最重要的类.
+  - **MAIN CLASSES** 详述了配置（configuration）、模型（model）、分词器（tokenizer）和流水线（pipeline）这几个最重要的类。
-  - **MODELS** 详述了在这个库中和每个模型实现有关的类和函数.
+  - **MODELS** 详述了在这个库中和每个模型实现有关的类和函数。
-  - **INTERNAL HELPERS** 详述了内部使用的工具类和函数.
+  - **INTERNAL HELPERS** 详述了内部使用的工具类和函数。
 ### 支持的模型
@@ -229,8 +229,8 @@ rendered properly in your Markdown viewer.
 ### 支持的框架
-下表展示了库中对每个模型的支持情况, 是否具有Python分词器 (表中的"Tokenizer slow"). 是否具有由🤗 Tokenizers库支持的快速分词器(表中的"Tokenizer fast"), 是否支持Jax (通过
+下表展示了库中对每个模型的支持情况，如是否具有 Python 分词器（表中的“Tokenizer slow”）、是否具有由 🤗 Tokenizers 库支持的快速分词器（表中的“Tokenizer fast”）、是否支持 Jax（通过
-Flax), PyTorch, 和/或者 TensorFlow.
+Flax）、PyTorch 与 TensorFlow。
 <!--This table is updated automatically from the auto modules with _make fix-copies_. Do not update manually!-->
@@ -395,4 +395,4 @@ Flax), PyTorch, 和/或者 TensorFlow.
 |             YOLOS             |       ❌       |       ❌       |       ✅        |         ❌         |      ❌      |
 |             YOSO              |       ❌       |       ❌       |       ✅        |         ❌         |      ❌      |
 <!-- End table-->
\ No newline at end of file
--- a/docs/source/zh/installation.md
+++ b/docs/source/zh/installation.md
@@ -20,17 +20,17 @@ rendered properly in your Markdown viewer.
 # 安装
-为你正在使用的深度学习框架安装 🤗 Transformers、设置缓存、并选择性配置 🤗 Transformers 以离线运行。
+为你正在使用的深度学习框架安装 🤗 Transformers、设置缓存，并选择性配置 🤗 Transformers 以离线运行。
-🤗 Transformers 已在Python 3.6+、PyTorch 1.1.0+、TensorFlow 2.0+以及Flax上进行测试。针对你使用的深度学习框架，请参照以下安装说明进行安装：
+🤗 Transformers 已在 Python 3.6+、PyTorch 1.1.0+、TensorFlow 2.0+ 以及 Flax 上进行测试。针对你使用的深度学习框架，请参照以下安装说明进行安装：
-* [PyTorch](https://pytorch.org/get-started/locally/)安装说明。
+* [PyTorch](https://pytorch.org/get-started/locally/) 安装说明。
-* [TensorFlow 2.0](https://www.tensorflow.org/install/pip)安装说明。
+* [TensorFlow 2.0](https://www.tensorflow.org/install/pip) 安装说明。
-* [Flax](https://flax.readthedocs.io/en/latest/)安装说明。
+* [Flax](https://flax.readthedocs.io/en/latest/) 安装说明。
-## 使用pip安装
+## 使用 pip 安装
-你应该使用[虚拟环境](https://docs.python.org/3/library/venv.html)安装 🤗 Transformers。如果你不熟悉Python虚拟环境，请查看此[教程](https://packaging.python.org/guides/installing-using-pip-and-virtual-environments/)。使用虚拟环境，你可以轻松管理不同项目，避免不同依赖项之间的兼容性问题。
+你应该使用 [虚拟环境](https://docs.python.org/3/library/venv.html) 安装 🤗 Transformers。如果你不熟悉 Python 虚拟环境，请查看此 [教程](https://packaging.python.org/guides/installing-using-pip-and-virtual-environments/)。使用虚拟环境，你可以轻松管理不同项目，避免不同依赖项之间的兼容性问题。
 首先，在项目目录中创建虚拟环境：
@@ -38,12 +38,12 @@ rendered properly in your Markdown viewer.
 python -m venv .env
 ```
-在Linux和MacOs系统中激活虚拟环境：
+在 Linux 和 MacOs 系统中激活虚拟环境：
 ```bash
 source .env/bin/activate
 ```
-在Windows系统中激活虚拟环境：
+在 Windows 系统中激活虚拟环境：
 ```bash
 .env/Scripts/activate
@@ -55,13 +55,13 @@ source .env/bin/activate
 pip install transformers
 ```
-若仅需CPU支持，可以使用单行命令方便地安装 🤗 Transformers 和深度学习库。例如，使用以下命令安装 🤗 Transformers 和PyTorch：
+若仅需 CPU 支持，可以使用单行命令方便地安装 🤗 Transformers 和深度学习库。例如，使用以下命令安装 🤗 Transformers 和 PyTorch：
 ```bash
 pip install 'transformers[torch]'
 ```
-🤗 Transformers 和TensorFlow 2.0:
+🤗 Transformers 和 TensorFlow 2.0：
 ```bash
 pip install 'transformers[tf-cpu]'
@@ -71,7 +71,7 @@ pip install 'transformers[tf-cpu]'
 M1 / ARM用户
-在安装TensorFLow 2.0前，你们需要安装以下库
+在安装 TensorFlow 2.0 前，你需要安装以下库：
 ```
 brew install cmake
 brew install pkg-config
@@ -79,7 +79,7 @@ brew install pkg-config
 </Tip>
-🤗 Transformers 和Flax:
+🤗 Transformers 和 Flax:
 ```bash
 pip install 'transformers[flax]'
@@ -105,7 +105,7 @@ python -c "from transformers import pipeline; print(pipeline('sentiment-analysis
 pip install git+https://github.com/huggingface/transformers
 ```
-此命令下载的是最新的前沿`main`版本而不是最新的`stable`版本。`main`版本适用于跟最新开发保持一致。例如，上次正式版发布带来的bug被修复了，但新版本尚未被推出。但是，这也说明`main`版本并不一定总是稳定的。我们努力保持`main`版本的可操作性，大多数问题通常在几个小时或一天以内就能被解决。如果你遇到问题，请提个[Issue](https://github.com/huggingface/transformers/issues)以便我们能更快修复。
+此命令下载的是最新的前沿 `main` 版本而不是最新的 `stable` 版本。`main` 版本适用于跟最新开发保持一致。例如，上次正式版发布带来的 bug 被修复了，但新版本尚未被推出。但是，这也说明 `main` 版本并不一定总是稳定的。我们努力保持 `main` 版本的可操作性，大多数问题通常在几个小时或一天以内就能被解决。如果你遇到问题，请提个 [Issue](https://github.com/huggingface/transformers/issues) 以便我们能更快修复。
 运行以下命令以检查 🤗 Transformers 是否已被正确安装：
@@ -117,7 +117,7 @@ python -c "from transformers import pipeline; print(pipeline('sentiment-analysis
 如果你有下列需求，需要进行可编辑安装：
-* 使用源码的`main`版本。
+* 使用源码的 `main` 版本。
 * 为 🤗 Transformers 贡献代码，需要测试代码中的更改。
 使用以下命令克隆仓库并安装 🤗 Transformers：
@@ -128,11 +128,11 @@ cd transformers
 pip install -e .
 ```
-这些命令将会链接你克隆的仓库以及你的Python库路径。现在，Python不仅会在正常的库路径中，也会在你克隆到的文件夹中进行查找。例如，如果你的Python包通常本安装在`~/anaconda3/envs/main/lib/python3.7/site-packages/`目录下，Python也会搜索你克隆到的文件夹：`~/transformers/`。
+这些命令将会链接你克隆的仓库以及你的 Python 库路径。现在，Python 不仅会在正常的库路径中搜索库，也会在你克隆到的文件夹中进行查找。例如，如果你的 Python 包通常本应安装在 `~/anaconda3/envs/main/lib/python3.7/site-packages/` 目录中，在这种情况下 Python 也会搜索你克隆到的文件夹：`~/transformers/`。
 <Tip warning={true}>
-如果你想继续使用这个库，必须保留`transformers`文件夹。
+如果你想继续使用这个库，必须保留 `transformers` 文件夹。
 </Tip>
@@ -143,11 +143,11 @@ cd ~/transformers/
 git pull
 ```
-你的Python环境将在下次运行时找到`main`版本的 🤗 Transformers。
+你的 Python 环境将在下次运行时找到 `main` 版本的 🤗 Transformers。
-## 使用conda安装
+## 使用 conda 安装
-从conda`huggingface`频道安装：
+从 conda 的 `huggingface` 频道安装：
 ```bash
 conda install -c huggingface transformers
@@ -155,25 +155,25 @@ conda install -c huggingface transformers
 ## 缓存设置
-预训练模型会被下载并本地缓存到：`~/.cache/huggingface/hub`。这是由shell环境变量`TRANSFORMERS_CACHE`指定的默认目录。在Windows上，默认目录为`C:\Users\username\.cache\huggingface\hub`。你可按照以下优先级改变下面显示的shell环境变量，以指定不同的缓存目录。
+预训练模型会被下载并本地缓存到 `~/.cache/huggingface/hub`。这是由环境变量 `TRANSFORMERS_CACHE` 指定的默认目录。在 Windows 上，默认目录为 `C:\Users\username\.cache\huggingface\hub`。你可以按照不同优先级改变下述环境变量，以指定不同的缓存目录。
-1. Shell环境变量（默认）: `HUGGINGFACE_HUB_CACHE`或`TRANSFORMERS_CACHE`。
+1. 环境变量（默认）: `HUGGINGFACE_HUB_CACHE` 或 `TRANSFORMERS_CACHE`。
-2. Shell环境变量：`HF_HOME`。
+2. 环境变量 `HF_HOME`。
-3. Shell环境变量： `XDG_CACHE_HOME` + `/huggingface`。
+3. 环境变量 `XDG_CACHE_HOME` + `/huggingface`。
 <Tip>
-🤗 Transformers 将会使用shell环境变量`PYTORCH_TRANSFORMERS_CACHE`或`PYTORCH_PRETRAINED_BERT_CACHE`如果你来自此库的较早版本并且已经设置了这些环境变量，除非你明确指定了shell环境变量`TRANSFORMERS_CACHE`.
+除非你明确指定了环境变量 `TRANSFORMERS_CACHE`，🤗 Transformers 将可能会使用较早版本设置的环境变量 `PYTORCH_TRANSFORMERS_CACHE` 或 `PYTORCH_PRETRAINED_BERT_CACHE`。
 </Tip>
 ## 离线模式
-🤗 Transformers 可以仅使用本地文件在防火墙或离线环境中运行。设置环境变量`TRANSFORMERS_OFFLINE=1`以启用该行为。
+🤗 Transformers 可以仅使用本地文件在防火墙或离线环境中运行。设置环境变量 `TRANSFORMERS_OFFLINE=1` 以启用该行为。
 <Tip>
-通过设置环境变量`HF_DATASETS_OFFLINE=1`将[🤗 Datasets](https://huggingface.co/docs/datasets/)添加至你的离线训练工作流程中。
+通过设置环境变量 `HF_DATASETS_OFFLINE=1` 将 [🤗 Datasets](https://huggingface.co/docs/datasets/) 添加至你的离线训练工作流程中。
 </Tip>
@@ -196,13 +196,13 @@ python examples/pytorch/translation/run_translation.py --model_name_or_path t5-s
 另一种离线时使用 🤗 Transformers 的方法是预先下载好文件，然后在需要离线使用时指向它们的离线路径。有三种实现的方法：
-* 单击[Model Hub](https://huggingface.co/models)用户界面上的 ↓ 图标下载文件。
+* 单击 [Model Hub](https://huggingface.co/models) 用户界面上的 ↓ 图标下载文件。
    ![下载图标](https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/download-icon.png)
-* 使用[`PreTrainedModel.from_pretrained`]和[`PreTrainedModel.save_pretrained`]工作流程：
+* 使用 [`PreTrainedModel.from_pretrained`] 和 [`PreTrainedModel.save_pretrained`] 工作流程：
-    1. 预先使用[`PreTrainedModel.from_pretrained`]下载文件：
+    1. 预先使用 [`PreTrainedModel.from_pretrained`] 下载文件：
    ```py
    >>> from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
@@ -211,29 +211,29 @@ python examples/pytorch/translation/run_translation.py --model_name_or_path t5-s
    >>> model = AutoModelForSeq2SeqLM.from_pretrained("bigscience/T0_3B")
    ```
-    2. 使用[`PreTrainedModel.save_pretrained`]将文件保存至指定目录：
+    2. 使用 [`PreTrainedModel.save_pretrained`] 将文件保存至指定目录：
    ```py
    >>> tokenizer.save_pretrained("./your/path/bigscience_t0")
    >>> model.save_pretrained("./your/path/bigscience_t0")
    ```
-    3. 现在，你可以在离线时从指定目录使用[`PreTrainedModel.from_pretrained`]重新加载你的文件：
+    3. 现在，你可以在离线时从指定目录使用 [`PreTrainedModel.from_pretrained`] 重新加载你的文件：
    ```py
    >>> tokenizer = AutoTokenizer.from_pretrained("./your/path/bigscience_t0")
    >>> model = AutoModel.from_pretrained("./your/path/bigscience_t0")
    ```
-* 使用代码用[huggingface_hub](https://github.com/huggingface/huggingface_hub/tree/main/src/huggingface_hub)库下载文件：
+* 使用代码用 [huggingface_hub](https://github.com/huggingface/huggingface_hub/tree/main/src/huggingface_hub) 库下载文件：
-    1. 在你的虚拟环境中安装`huggingface_hub`库：
+    1. 在你的虚拟环境中安装 `huggingface_hub` 库：
    ```bash
    python -m pip install huggingface_hub
    ```
-    2. 使用[`hf_hub_download`](https://huggingface.co/docs/hub/adding-a-library#download-files-from-the-hub)函数将文件下载到指定路径。例如，以下命令将`config.json`文件从[T0](https://huggingface.co/bigscience/T0_3B)模型下载至你想要的路径：
+    2. 使用 [`hf_hub_download`](https://huggingface.co/docs/hub/adding-a-library#download-files-from-the-hub) 函数将文件下载到指定路径。例如，以下命令将 `config.json` 文件从 [T0](https://huggingface.co/bigscience/T0_3B) 模型下载至你想要的路径：
    ```py
    >>> from huggingface_hub import hf_hub_download
@@ -251,6 +251,6 @@ python examples/pytorch/translation/run_translation.py --model_name_or_path t5-s
 <Tip>
-请参阅[如何从Hub下载文件](https://huggingface.co/docs/hub/how-to-downstream)部分，获取有关下载存储在Hub上文件的更多详细信息。
+请参阅 [如何从 Hub 下载文件](https://huggingface.co/docs/hub/how-to-downstream) 部分，获取有关下载存储在 Hub 上文件的更多详细信息。
 </Tip>
--- a/docs/source/zh/quicktour.md
+++ b/docs/source/zh/quicktour.md
@@ -18,15 +18,15 @@ rendered properly in your Markdown viewer.
 [[open-in-colab]]
-快来使用 🤗 Transformers 吧! 无论你是开发人员还是日常用户, 这篇快速上手教程都将帮助你入门并且向你展示如何使用[`pipeline`]进行推理, 使用[AutoClass](./model_doc/auto)加载一个预训练模型和预处理器, 以及使用PyTorch或TensorFlow快速训练一个模型. 如果你是一个初学者, 我们建议你接下来查看我们的教程或者[课程](https://huggingface.co/course/chapter1/1), 来更深入地了解在这里介绍到的概念.
+快来使用 🤗 Transformers 吧！无论你是开发人员还是日常用户，这篇快速上手教程都将帮助你入门并且向你展示如何使用 [`pipeline`] 进行推理，使用 [AutoClass](./model_doc/auto) 加载一个预训练模型和预处理器，以及使用 PyTorch 或 TensorFlow 快速训练一个模型。如果你是一个初学者，我们建议你接下来查看我们的教程或者[课程](https://huggingface.co/course/chapter1/1)，来更深入地了解在这里介绍到的概念。
-在开始之前, 确保你已经安装了所有必要的库:
+在开始之前，确保你已经安装了所有必要的库：
 ```bash
 !pip install transformers datasets
 ```
-你还需要安装喜欢的机器学习框架:
+你还需要安装喜欢的机器学习框架：
 <frameworkcontent>
 <pt>
@@ -47,25 +47,25 @@ pip install tensorflow
 <Youtube id="tiZFewofSLM"/>
-使用[`pipeline`]是利用预训练模型进行推理的最简单的方式. 你能够将[`pipeline`]开箱即用地用于跨不同模态的多种任务. 来看看它支持的任务列表:
+使用 [`pipeline`] 是利用预训练模型进行推理的最简单的方式。你能够将 [`pipeline`] 开箱即用地用于跨不同模态的多种任务。来看看它支持的任务列表：
-| **任务**                     | **描述**                                                                                                      | **模态**        | **Pipeline**                       |
+| **任务**                     | **描述**                            | **模态**        | **Pipeline**                       |
-|------------------------------|--------------------------------------------------------------------------------------------------------------|-----------------|-----------------------------------------------|
+|------------------------------|-----------------------------------|-----------------|-----------------------------------------------|
-| 文本分类                      | 为给定的文本序列分配一个标签                                                                                    | NLP             | pipeline(task="sentiment-analysis")           |
+| 文本分类                      | 为给定的文本序列分配一个标签                    | NLP             | pipeline(task="sentiment-analysis")           |
-| 文本生成                      | 根据给定的提示生成文本                                                                                         | NLP             | pipeline(task="text-generation")              |
+| 文本生成                      | 根据给定的提示生成文本                       | NLP             | pipeline(task="text-generation")              |
-| 命名实体识别                  | 为序列里的每个token分配一个标签(人, 组织, 地址等等)                                                              | NLP             | pipeline(task="ner")                          |
+| 命名实体识别                  | 为序列里的每个 token 分配一个标签（人, 组织, 地址等等） | NLP             | pipeline(task="ner")                          |
-| 问答系统                      | 通过给定的上下文和问题, 在文本中提取答案                                                                         | NLP             | pipeline(task="question-answering")           |
+| 问答系统                      | 通过给定的上下文和问题, 在文本中提取答案             | NLP             | pipeline(task="question-answering")           |
-| 掩盖填充                      | 预测出正确的在序列中被掩盖的token                                                                               | NLP             | pipeline(task="fill-mask")                    |
+| 掩盖填充                      | 预测出正确的在序列中被掩盖的token               | NLP             | pipeline(task="fill-mask")                    |
-| 文本摘要                      | 为文本序列或文档生成总结                                                                                        | NLP             | pipeline(task="summarization")                |
+| 文本摘要                      | 为文本序列或文档生成总结                      | NLP             | pipeline(task="summarization")                |
-| 文本翻译                      | 将文本从一种语言翻译为另一种语言                                                                                | NLP             | pipeline(task="translation")                  |
+| 文本翻译                      | 将文本从一种语言翻译为另一种语言                  | NLP             | pipeline(task="translation")                  |
-| 图像分类                      | 为图像分配一个标签                                                                                             | Computer vision | pipeline(task="image-classification")         |
+| 图像分类                      | 为图像分配一个标签                         | Computer vision | pipeline(task="image-classification")         |
-| 图像分割                      | 为图像中每个独立的像素分配标签(支持语义、全景和实例分割)                                                          | Computer vision | pipeline(task="image-segmentation")           |
+| 图像分割                      | 为图像中每个独立的像素分配标签（支持语义、全景和实例分割）     | Computer vision | pipeline(task="image-segmentation")           |
-| 目标检测                      | 预测图像中目标对象的边界框和类别                                                                                | Computer vision | pipeline(task="object-detection")             |
+| 目标检测                      | 预测图像中目标对象的边界框和类别                  | Computer vision | pipeline(task="object-detection")             |
-| 音频分类                      | 给音频文件分配一个标签                                                                                         | Audio           | pipeline(task="audio-classification")         |
+| 音频分类                      | 给音频文件分配一个标签                       | Audio           | pipeline(task="audio-classification")         |
-| 自动语音识别                   | 将音频文件中的语音提取为文本                                                                                   | Audio           | pipeline(task="automatic-speech-recognition") |
+| 自动语音识别                   | 将音频文件中的语音提取为文本                    | Audio           | pipeline(task="automatic-speech-recognition") |
-| 视觉问答                      | 给定一个图像和一个问题，正确地回答有关图像的问题                                                                  | Multimodal      | pipeline(task="vqa")                          |
+| 视觉问答                      | 给定一个图像和一个问题，正确地回答有关图像的问题          | Multimodal      | pipeline(task="vqa")                          |
-创建一个[`pipeline`]实例并且指定你想要将它用于的任务, 就可以开始了. 你可以将[`pipeline`]用于任何一个上面提到的任务, 如果想知道支持的任务的完整列表, 可以查阅[pipeline API 参考](./main_classes/pipelines). 不过, 在这篇教程中, 你将把 [`pipeline`]用在一个情感分析示例上:
+创建一个 [`pipeline`] 实例并且指定你想要将它用于的任务，就可以开始了。你可以将 [`pipeline`] 用于任何一个上面提到的任务，如果想知道支持的任务的完整列表，可以查阅 [pipeline API 参考](./main_classes/pipelines)。不过, 在这篇教程中，你将把 [`pipeline`] 用在一个情感分析示例上：
 ```py
 >>> from transformers import pipeline
@@ -73,14 +73,14 @@ pip install tensorflow
 >>> classifier = pipeline("sentiment-analysis")
 ```
-[`pipeline`] 会下载并缓存一个用于情感分析的默认的[预训练模型](https://huggingface.co/distilbert-base-uncased-finetuned-sst-2-english)和分词器. 现在你可以在目标文本上使用 `classifier`了:
+[`pipeline`] 会下载并缓存一个用于情感分析的默认的[预训练模型](https://huggingface.co/distilbert-base-uncased-finetuned-sst-2-english)和分词器。现在你可以在目标文本上使用 `classifier` 了：
 ```py
 >>> classifier("We are very happy to show you the 🤗 Transformers library.")
 [{'label': 'POSITIVE', 'score': 0.9998}]
 ```
-如果你有不止一个输入, 可以把所有输入放入一个列表然后传给[`pipeline`], 它将会返回一个字典列表:
+如果你有不止一个输入，可以把所有输入放入一个列表然后传给[`pipeline`]，它将会返回一个字典列表：
 ```py
 >>> results = classifier(["We are very happy to show you the 🤗 Transformers library.", "We hope you don't hate it."])
@@ -90,7 +90,7 @@ label: POSITIVE, with score: 0.9998
 label: NEGATIVE, with score: 0.5309
 ```
-[`pipeline`] 也可以为任何你喜欢的任务遍历整个数据集. 在下面这个示例中, 让我们选择自动语音识别作为我们的任务:
+[`pipeline`] 也可以为任何你喜欢的任务遍历整个数据集。在下面这个示例中，让我们选择自动语音识别作为我们的任务：
 ```py
 >>> import torch
@@ -99,7 +99,7 @@ label: NEGATIVE, with score: 0.5309
 >>> speech_recognizer = pipeline("automatic-speech-recognition", model="facebook/wav2vec2-base-960h")
 ```
-加载一个你想遍历的音频数据集 (查阅 🤗 Datasets [快速开始](https://huggingface.co/docs/datasets/quickstart#audio) 获得更多信息). 比如, 加载 [MInDS-14](https://huggingface.co/datasets/PolyAI/minds14) 数据集:
+加载一个你想遍历的音频数据集（查阅 🤗 Datasets [快速开始](https://huggingface.co/docs/datasets/quickstart#audio) 获得更多信息）。比如，加载 [MInDS-14](https://huggingface.co/datasets/PolyAI/minds14) 数据集：
 ```py
 >>> from datasets import load_dataset, Audio
@@ -107,14 +107,14 @@ label: NEGATIVE, with score: 0.5309
 >>> dataset = load_dataset("PolyAI/minds14", name="en-US", split="train")  # doctest: +IGNORE_RESULT
 ```
-你需要确保数据集中的音频的采样率与 [`facebook/wav2vec2-base-960h`](https://huggingface.co/facebook/wav2vec2-base-960h) 训练用到的音频的采样率一致:
+你需要确保数据集中的音频的采样率与 [`facebook/wav2vec2-base-960h`](https://huggingface.co/facebook/wav2vec2-base-960h) 训练用到的音频的采样率一致：
 ```py
 >>> dataset = dataset.cast_column("audio", Audio(sampling_rate=speech_recognizer.feature_extractor.sampling_rate))
 ```
-当调用`"audio"` column时, 音频文件将会自动加载并重采样.
+当调用 `"audio"` 列时, 音频文件将会自动加载并重采样。
-从前四个样本中提取原始波形数组, 将它作为列表传给pipeline:
+从前四个样本中提取原始波形数组，将它作为列表传给 pipeline：
 ```py
 >>> result = speech_recognizer(dataset[:4]["audio"])
@@ -122,11 +122,11 @@ label: NEGATIVE, with score: 0.5309
 ['I WOULD LIKE TO SET UP A JOINT ACCOUNT WITH MY PARTNER HOW DO I PROCEED WITH DOING THAT', "FODING HOW I'D SET UP A JOIN TO HET WITH MY WIFE AND WHERE THE AP MIGHT BE", "I I'D LIKE TOY SET UP A JOINT ACCOUNT WITH MY PARTNER I'M NOT SEEING THE OPTION TO DO IT ON THE AP SO I CALLED IN TO GET SOME HELP CAN I JUST DO IT OVER THE PHONE WITH YOU AND GIVE YOU THE INFORMATION OR SHOULD I DO IT IN THE AP AND I'M MISSING SOMETHING UQUETTE HAD PREFERRED TO JUST DO IT OVER THE PHONE OF POSSIBLE THINGS", 'HOW DO I THURN A JOIN A COUNT']
 ```
-对于输入非常庞大的大型数据集 (比如语音或视觉), 你会想到使用一个生成器, 而不是一个将所有输入都加载进内存的列表. 查阅 [pipeline API 参考](./main_classes/pipelines) 来获取更多信息.
+对于输入非常庞大的大型数据集（比如语音或视觉），你会想到使用一个生成器，而不是一个将所有输入都加载进内存的列表。查阅 [pipeline API 参考](./main_classes/pipelines) 来获取更多信息。
-### 在pipeline中使用另一个模型和分词器
+### 在 pipeline 中使用另一个模型和分词器
-[`pipeline`]可以容纳[Hub](https://huggingface.co/models)中的任何模型, 这让[`pipeline`]更容易适用于其他用例. 比如, 你想要一个能够处理法语文本的模型, 就可以使用Hub上的标记来筛选出合适的模型. 靠前的筛选结果会返回一个为情感分析微调的多语言的 [BERT 模型](https://huggingface.co/nlptown/bert-base-multilingual-uncased-sentiment), 你可以将它用于法语文本:
+[`pipeline`] 可以容纳 [Hub](https://huggingface.co/models) 中的任何模型，这让 [`pipeline`] 更容易适用于其他用例。比如，你想要一个能够处理法语文本的模型，就可以使用 Hub 上的标记来筛选出合适的模型。靠前的筛选结果会返回一个为情感分析微调的多语言的 [BERT 模型](https://huggingface.co/nlptown/bert-base-multilingual-uncased-sentiment)，你可以将它用于法语文本：
 ```py
 >>> model_name = "nlptown/bert-base-multilingual-uncased-sentiment"
@@ -134,7 +134,7 @@ label: NEGATIVE, with score: 0.5309
 <frameworkcontent>
 <pt>
-使用 [`AutoModelForSequenceClassification`]和[`AutoTokenizer`]来加载预训练模型和它关联的分词器 (更多信息可以参考下一节的 `AutoClass`):
+使用 [`AutoModelForSequenceClassification`] 和 [`AutoTokenizer`] 来加载预训练模型和它关联的分词器（更多信息可以参考下一节的 `AutoClass`）：
 ```py
 >>> from transformers import AutoTokenizer, AutoModelForSequenceClassification
@@ -144,7 +144,7 @@ label: NEGATIVE, with score: 0.5309
 ```
 </pt>
 <tf>
-使用 [`TFAutoModelForSequenceClassification`]和[`AutoTokenizer`] 来加载预训练模型和它关联的分词器 (更多信息可以参考下一节的 `TFAutoClass`):
+使用 [`TFAutoModelForSequenceClassification`] 和 [`AutoTokenizer`] 来加载预训练模型和它关联的分词器（更多信息可以参考下一节的 `TFAutoClass`）：
 ```py
 >>> from transformers import AutoTokenizer, TFAutoModelForSequenceClassification
@@ -155,7 +155,7 @@ label: NEGATIVE, with score: 0.5309
 </tf>
 </frameworkcontent>
-在[`pipeline`]中指定模型和分词器, 现在你就可以在法语文本上使用 `classifier`了:
+在 [`pipeline`] 中指定模型和分词器，现在你就可以在法语文本上使用 `classifier` 了：
 ```py
 >>> classifier = pipeline("sentiment-analysis", model=model, tokenizer=tokenizer)
@@ -163,21 +163,21 @@ label: NEGATIVE, with score: 0.5309
 [{'label': '5 stars', 'score': 0.7273}]
 ```
-如果你没有找到适合你的模型, 就需要在你的数据上微调一个预训练模型了. 查看[微调教程](./training) 来学习怎样进行微调. 最后, 微调完模型后, 考虑一下在Hub上与社区 [分享](./model_sharing) 这个模型, 把机器学习普及到每一个人! 🤗
+如果你没有找到适合你的模型，就需要在你的数据上微调一个预训练模型了。查看 [微调教程](./training) 来学习怎样进行微调。最后，微调完模型后，考虑一下在 Hub 上与社区 [分享](./model_sharing) 这个模型，把机器学习普及到每一个人! 🤗
 ## AutoClass
 <Youtube id="AhChOFRegn4"/>
-在幕后, 是由[`AutoModelForSequenceClassification`]和[`AutoTokenizer`]一起支持你在上面用到的[`pipeline`].  [AutoClass](./model_doc/auto) 是一个能够通过预训练模型的名称或路径自动查找其架构的快捷方式. 你只需要为你的任务选择合适的 `AutoClass` 和它关联的预处理类. 
+在幕后，是由 [`AutoModelForSequenceClassification`] 和 [`AutoTokenizer`] 一起支持你在上面用到的 [`pipeline`]。[AutoClass](./model_doc/auto) 是一个能够通过预训练模型的名称或路径自动查找其架构的快捷方式。你只需要为你的任务选择合适的 `AutoClass` 和它关联的预处理类。
-让我们回过头来看上一节的示例, 看看怎样使用 `AutoClass` 来重现使用[`pipeline`]的结果.
+让我们回过头来看上一节的示例，看看怎样使用 `AutoClass` 来重现使用 [`pipeline`] 的结果。
 ### AutoTokenizer
-分词器负责预处理文本, 将文本转换为用于输入模型的数字数组. 有多个用来管理分词过程的规则, 包括如何拆分单词和在什么样的级别上拆分单词 (在 [分词器总结](./tokenizer_summary)学习更多关于分词的信息). 要记住最重要的是你需要实例化的分词器要与模型的名称相同, 来确保和模型训练时使用相同的分词规则.
+分词器负责预处理文本，将文本转换为用于输入模型的数字数组。有多个用来管理分词过程的规则，包括如何拆分单词和在什么样的级别上拆分单词（在 [分词器总结](./tokenizer_summary) 学习更多关于分词的信息）。要记住最重要的是你需要实例化的分词器要与模型的名称相同, 来确保和模型训练时使用相同的分词规则。
-使用[`AutoTokenizer`]加载一个分词器:
+使用 [`AutoTokenizer`] 加载一个分词器:
 ```py
 >>> from transformers import AutoTokenizer
@@ -186,7 +186,7 @@ label: NEGATIVE, with score: 0.5309
 >>> tokenizer = AutoTokenizer.from_pretrained(model_name)
 ```
-将文本传入分词器:
+将文本传入分词器：
 ```py
 >>> encoding = tokenizer("We are very happy to show you the 🤗 Transformers library.")
@@ -198,10 +198,10 @@ label: NEGATIVE, with score: 0.5309
 分词器返回了含有如下内容的字典:
-* [input_ids](./glossary#input-ids): 用数字表示的token.
+* [input_ids](./glossary#input-ids)：用数字表示的 token。
-* [attention_mask](.glossary#attention-mask): 应该关注哪些token的指示.
+* [attention_mask](.glossary#attention-mask)：应该关注哪些 token 的指示。
-分词器也可以接受列表作为输入, 并填充和截断文本, 返回具有统一长度的批次:
+分词器也可以接受列表作为输入，并填充和截断文本，返回具有统一长度的批次：
 <frameworkcontent>
 <pt>
@@ -232,7 +232,7 @@ label: NEGATIVE, with score: 0.5309
 <Tip>
-查阅[预处理](./preprocessing)教程来获得有关分词的更详细的信息, 以及如何使用[`AutoFeatureExtractor`]和[`AutoProcessor`]来处理图像, 音频, 还有多模式输入.
+查阅[预处理](./preprocessing)教程来获得有关分词的更详细的信息，以及如何使用 [`AutoFeatureExtractor`] 和 [`AutoProcessor`] 来处理图像，音频，还有多模式输入。
 </Tip>
@@ -240,7 +240,7 @@ label: NEGATIVE, with score: 0.5309
 <frameworkcontent>
 <pt>
-🤗 Transformers 提供了一种简单统一的方式来加载预训练的实例. 这表示你可以像加载[`AutoTokenizer`]一样加载[`AutoModel`]. 唯一不同的地方是为你的任务选择正确的[`AutoModel`]. 对于文本 (或序列) 分类, 你应该加载[`AutoModelForSequenceClassification`]:
+🤗 Transformers 提供了一种简单统一的方式来加载预训练的实例. 这表示你可以像加载 [`AutoTokenizer`] 一样加载 [`AutoModel`]。唯一不同的地方是为你的任务选择正确的[`AutoModel`]。对于文本（或序列）分类，你应该加载[`AutoModelForSequenceClassification`]：
 ```py
 >>> from transformers import AutoModelForSequenceClassification
@@ -251,17 +251,17 @@ label: NEGATIVE, with score: 0.5309
 <Tip>
-通过[任务摘要](./task_summary)查找[`AutoModel`]支持的任务.
+通过 [任务摘要](./task_summary) 查找 [`AutoModel`] 支持的任务.
 </Tip>
-现在可以把预处理好的输入批次直接送进模型. 你只需要添加`**`来解包字典:
+现在可以把预处理好的输入批次直接送进模型。你只需要通过 `**` 来解包字典:
 ```py
 >>> pt_outputs = pt_model(**pt_batch)
 ```
-模型在`logits`属性输出最终的激活结果. 在 `logits`上应用softmax函数来查询概率:
+模型在 `logits` 属性输出最终的激活结果. 在 `logits` 上应用 softmax 函数来查询概率:
 ```py
 >>> from torch import nn
@@ -273,7 +273,7 @@ tensor([[0.0021, 0.0018, 0.0115, 0.2121, 0.7725],
 ```
 </pt>
 <tf>
-🤗 Transformers 提供了一种简单统一的方式来加载预训练的实例. 这表示你可以像加载[`AutoTokenizer`]一样加载[`TFAutoModel`]. 唯一不同的地方是为你的任务选择正确的[`TFAutoModel`], 对于文本 (或序列) 分类, 你应该加载[`TFAutoModelForSequenceClassification`]:
+🤗 Transformers 提供了一种简单统一的方式来加载预训练的实例。这表示你可以像加载 [`AutoTokenizer`] 一样加载 [`TFAutoModel`]。唯一不同的地方是为你的任务选择正确的 [`TFAutoModel`]，对于文本（或序列）分类，你应该加载 [`TFAutoModelForSequenceClassification`]：
 ```py
 >>> from transformers import TFAutoModelForSequenceClassification
@@ -284,17 +284,17 @@ tensor([[0.0021, 0.0018, 0.0115, 0.2121, 0.7725],
 <Tip>
-通过[任务摘要](./task_summary)查找[`AutoModel`]支持的任务.
+通过 [任务摘要](./task_summary) 查找 [`AutoModel`] 支持的任务.
 </Tip>
-现在通过直接将字典的键传给张量，将预处理的输入批次传给模型.
+现在通过直接将字典的键传给张量，将预处理的输入批次传给模型。
 ```py
 >>> tf_outputs = tf_model(tf_batch)
 ```
-模型在`logits`属性输出最终的激活结果. 在 `logits`上应用softmax函数来查询概率:
+模型在 `logits` 属性输出最终的激活结果。在 `logits` 上应用softmax函数来查询概率：
 ```py
 >>> import tensorflow as tf
@@ -307,8 +307,8 @@ tensor([[0.0021, 0.0018, 0.0115, 0.2121, 0.7725],
 <Tip>
-所有 🤗 Transformers 模型 (PyTorch 或 TensorFlow) 在最终的激活函数(比如softmax)*之前* 输出张量,
+所有 🤗 Transformers 模型（PyTorch 或 TensorFlow）在最终的激活函数（比如 softmax）*之前* 输出张量，
-因为最终的激活函数常常与loss融合. 模型的输出是特殊的数据类, 所以它们的属性可以在IDE中被自动补全. 模型的输出就像一个元组或字典 (你可以通过整数、切片或字符串来索引它), 在这种情况下, 为None的属性会被忽略.
+因为最终的激活函数常常与 loss 融合。模型的输出是特殊的数据类，所以它们的属性可以在 IDE 中被自动补全。模型的输出就像一个元组或字典（你可以通过整数、切片或字符串来索引它），在这种情况下，为 None 的属性会被忽略。
 </Tip>
@@ -316,7 +316,7 @@ tensor([[0.0021, 0.0018, 0.0115, 0.2121, 0.7725],
 <frameworkcontent>
 <pt>
-当你的模型微调完成, 你就可以使用[`PreTrainedModel.save_pretrained`]把它和它的分词器保存下来:
+当你的模型微调完成，你就可以使用 [`PreTrainedModel.save_pretrained`] 把它和它的分词器保存下来：
 ```py
 >>> pt_save_directory = "./pt_save_pretrained"
@@ -324,14 +324,14 @@ tensor([[0.0021, 0.0018, 0.0115, 0.2121, 0.7725],
 >>> pt_model.save_pretrained(pt_save_directory)
 ```
-当你准备再次使用这个模型时, 就可以使用[`PreTrainedModel.from_pretrained`]加载它了:
+当你准备再次使用这个模型时，就可以使用 [`PreTrainedModel.from_pretrained`] 加载它了：
 ```py
 >>> pt_model = AutoModelForSequenceClassification.from_pretrained("./pt_save_pretrained")
 ```
 </pt>
 <tf>
-当你的模型微调完成, 你就可以使用[`TFPreTrainedModel.save_pretrained`]把它和它的分词器保存下来:
+当你的模型微调完成，你就可以使用 [`TFPreTrainedModel.save_pretrained`] 把它和它的分词器保存下来：
 ```py
 >>> tf_save_directory = "./tf_save_pretrained"
@@ -339,7 +339,7 @@ tensor([[0.0021, 0.0018, 0.0115, 0.2121, 0.7725],
 >>> tf_model.save_pretrained(tf_save_directory)
 ```
-当你准备再次使用这个模型时, 就可以使用[`TFPreTrainedModel.from_pretrained`]加载它了:
+当你准备再次使用这个模型时，就可以使用 [`TFPreTrainedModel.from_pretrained`] 加载它了：
 ```py
 >>> tf_model = TFAutoModelForSequenceClassification.from_pretrained("./tf_save_pretrained")
@@ -347,7 +347,7 @@ tensor([[0.0021, 0.0018, 0.0115, 0.2121, 0.7725],
 </tf>
 </frameworkcontent>
-🤗 Transformers有一个特别酷的功能, 它能够保存一个模型, 并且将它加载为PyTorch或TensorFlow模型. `from_pt`或`from_tf`参数可以将模型从一个框架转换为另一个框架:
+🤗 Transformers 有一个特别酷的功能，它能够保存一个模型，并且将它加载为 PyTorch 或 TensorFlow 模型。`from_pt` 或 `from_tf` 参数可以将模型从一个框架转换为另一个框架：
 <frameworkcontent>
 <pt>
@@ -372,9 +372,9 @@ tensor([[0.0021, 0.0018, 0.0115, 0.2121, 0.7725],
 ## 自定义模型构建
-你可以修改模型的配置类来改变模型的构建方式. 配置指明了模型的属性, 比如隐藏层或者注意力头的数量. 当你从自定义的配置类初始化模型时, 你就开始自定义模型构建了. 模型属性是随机初始化的, 你需要先训练模型, 然后才能得到有意义的结果.
+你可以修改模型的配置类来改变模型的构建方式。配置指明了模型的属性，比如隐藏层或者注意力头的数量。当你从自定义的配置类初始化模型时，你就开始自定义模型构建了。模型属性是随机初始化的，你需要先训练模型，然后才能得到有意义的结果。
-通过导入[`AutoConfig`]来开始, 之后加载你想修改的预训练模型. 在[`AutoConfig.from_pretrained`]中, 你能够指定想要修改的属性, 比如注意力头的数量:
+通过导入 [`AutoConfig`] 来开始，之后加载你想修改的预训练模型。在 [`AutoConfig.from_pretrained`] 中，你能够指定想要修改的属性，比如注意力头的数量：
 ```py
 >>> from transformers import AutoConfig
@@ -384,7 +384,7 @@ tensor([[0.0021, 0.0018, 0.0115, 0.2121, 0.7725],
 <frameworkcontent>
 <pt>
-使用[`AutoModel.from_config`]根据你的自定义配置创建一个模型:
+使用 [`AutoModel.from_config`] 根据你的自定义配置创建一个模型：
 ```py
 >>> from transformers import AutoModel
@@ -393,7 +393,7 @@ tensor([[0.0021, 0.0018, 0.0115, 0.2121, 0.7725],
 ```
 </pt>
 <tf>
-使用[`TFAutoModel.from_config`]根据你的自定义配置创建一个模型:
+使用 [`TFAutoModel.from_config`] 根据你的自定义配置创建一个模型：
 ```py
 >>> from transformers import TFAutoModel
@@ -403,15 +403,15 @@ tensor([[0.0021, 0.0018, 0.0115, 0.2121, 0.7725],
 </tf>
 </frameworkcontent>
-查阅[创建一个自定义结构](./create_a_model)指南获取更多关于构建自定义配置的信息.
+查阅 [创建一个自定义结构](./create_a_model) 指南获取更多关于构建自定义配置的信息。
-## Trainer - PyTorch优化训练循环
+## Trainer - PyTorch 优化训练循环
-所有的模型都是标准的[`torch.nn.Module`](https://pytorch.org/docs/stable/nn.html#torch.nn.Module), 所以你可以在任何典型的训练模型中使用它们. 当你编写自己的训练循环时, 🤗 Transformers为PyTorch提供了一个[`Trainer`]类, 它包含了基础的训练循环并且为诸如分布式训练, 混合精度等特性增加了额外的功能.
+所有的模型都是标准的 [`torch.nn.Module`](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)，所以你可以在任何典型的训练模型中使用它们。当你编写自己的训练循环时，🤗 Transformers 为 PyTorch 提供了一个 [`Trainer`] 类，它包含了基础的训练循环并且为诸如分布式训练，混合精度等特性增加了额外的功能。
-取决于你的任务, 你通常可以传递以下的参数给[`Trainer`]:
+取决于你的任务, 你通常可以传递以下的参数给 [`Trainer`]：
-1. [`PreTrainedModel`]或者[`torch.nn.Module`](https://pytorch.org/docs/stable/nn.html#torch.nn.Module):
+1. [`PreTrainedModel`] 或者 [`torch.nn.Module`](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)：
   ```py
   >>> from transformers import AutoModelForSequenceClassification
@@ -419,7 +419,7 @@ tensor([[0.0021, 0.0018, 0.0115, 0.2121, 0.7725],
   >>> model = AutoModelForSequenceClassification.from_pretrained("distilbert-base-uncased")
   ```
-2. [`TrainingArguments`]含有你可以修改的模型超参数, 比如学习率, 批次大小和训练时的迭代次数. 如果你没有指定训练参数, 那么它会使用默认值:
+2. [`TrainingArguments`] 含有你可以修改的模型超参数，比如学习率，批次大小和训练时的迭代次数。如果你没有指定训练参数，那么它会使用默认值：
   ```py
   >>> from transformers import TrainingArguments
@@ -433,7 +433,7 @@ tensor([[0.0021, 0.0018, 0.0115, 0.2121, 0.7725],
   ... )
   ```
-3. 一个预处理类, 比如分词器, 特征提取器或者处理器:
+3. 一个预处理类，比如分词器，特征提取器或者处理器：
   ```py
   >>> from transformers import AutoTokenizer
@@ -441,7 +441,7 @@ tensor([[0.0021, 0.0018, 0.0115, 0.2121, 0.7725],
   >>> tokenizer = AutoTokenizer.from_pretrained("distilbert-base-uncased")
   ```
-4. 加载一个数据集:
+4. 加载一个数据集：
   ```py
   >>> from datasets import load_dataset
@@ -449,17 +449,16 @@ tensor([[0.0021, 0.0018, 0.0115, 0.2121, 0.7725],
   >>> dataset = load_dataset("rotten_tomatoes")  # doctest: +IGNORE_RESULT
   ```
-5. 创建一个给数据集分词的函数, 并且使用[`~datasets.Dataset.map`]应用到整个数据集:
+5. 创建一个给数据集分词的函数，并且使用 [`~datasets.Dataset.map`] 应用到整个数据集：
   ```py
   >>> def tokenize_dataset(dataset):
   ...     return tokenizer(dataset["text"])
   >>> dataset = dataset.map(tokenize_dataset, batched=True)
   ```
-6. 用来从数据集中创建批次的[`DataCollatorWithPadding`]:
+6. 用来从数据集中创建批次的 [`DataCollatorWithPadding`]：
   ```py
   >>> from transformers import DataCollatorWithPadding
@@ -467,7 +466,7 @@ tensor([[0.0021, 0.0018, 0.0115, 0.2121, 0.7725],
   >>> data_collator = DataCollatorWithPadding(tokenizer=tokenizer)
   ```
-现在把所有的类传给[`Trainer`]:
+现在把所有的类传给 [`Trainer`]：
 ```py
 >>> from transformers import Trainer
@@ -482,7 +481,7 @@ tensor([[0.0021, 0.0018, 0.0115, 0.2121, 0.7725],
 ... )  # doctest: +SKIP
 ```
-一切准备就绪后, 调用[`~Trainer.train`]进行训练:
+一切准备就绪后，调用 [`~Trainer.train`] 进行训练：
 ```py
 >>> trainer.train()  # doctest: +SKIP
@@ -490,19 +489,19 @@ tensor([[0.0021, 0.0018, 0.0115, 0.2121, 0.7725],
 <Tip>
-对于像翻译或摘要这些使用序列到序列模型的任务, 用[`Seq2SeqTrainer`]和[`Seq2SeqTrainingArguments`]来替代.
+对于像翻译或摘要这些使用序列到序列模型的任务，用 [`Seq2SeqTrainer`] 和 [`Seq2SeqTrainingArguments`] 来替代。
 </Tip>
-你可以通过子类化[`Trainer`]中的方法来自定义训练循环. 这样你就可以自定义像损失函数, 优化器和调度器这样的特性. 查阅[`Trainer`]参考手册了解哪些方法能够被子类化. 
+你可以通过子类化 [`Trainer`] 中的方法来自定义训练循环。这样你就可以自定义像损失函数，优化器和调度器这样的特性。查阅 [`Trainer`] 参考手册了解哪些方法能够被子类化。
-另一个自定义训练循环的方式是通过[回调](./main_classes/callbacks). 你可以使用回调来与其他库集成, 查看训练循环来报告进度或提前结束训练. 回调不会修改训练循环. 如果想自定义损失函数等, 就需要子类化[`Trainer`]了.
+另一个自定义训练循环的方式是通过[回调](./main_classes/callbacks)。你可以使用回调来与其他库集成，查看训练循环来报告进度或提前结束训练。回调不会修改训练循环。如果想自定义损失函数等，就需要子类化 [`Trainer`] 了。
-## 使用Tensorflow训练
+## 使用 Tensorflow 训练
-所有模型都是标准的[`tf.keras.Model`](https://www.tensorflow.org/api_docs/python/tf/keras/Model), 所以你可以通过[Keras](https://keras.io/) API实现在Tensorflow中训练. 🤗 Transformers提供了[`~TFPreTrainedModel.prepare_tf_dataset`]方法来轻松地将数据集加载为`tf.data.Dataset`, 这样你就可以使用Keras的[`compile`](https://keras.io/api/models/model_training_apis/#compile-method)和[`fit`](https://keras.io/api/models/model_training_apis/#fit-method)方法马上开始训练.
+所有模型都是标准的 [`tf.keras.Model`](https://www.tensorflow.org/api_docs/python/tf/keras/Model)，所以你可以通过 [Keras](https://keras.io/) API 实现在 Tensorflow 中训练。🤗 Transformers 提供了 [`~TFPreTrainedModel.prepare_tf_dataset`] 方法来轻松地将数据集加载为 `tf.data.Dataset`，这样你就可以使用 Keras 的 [`compile`](https://keras.io/api/models/model_training_apis/#compile-method) 和 [`fit`](https://keras.io/api/models/model_training_apis/#fit-method) 方法马上开始训练。
-1. 使用[`TFPreTrainedModel`]或者[`tf.keras.Model`](https://www.tensorflow.org/api_docs/python/tf/keras/Model)来开始:
+1. 使用 [`TFPreTrainedModel`] 或者 [`tf.keras.Model`](https://www.tensorflow.org/api_docs/python/tf/keras/Model) 来开始：
   ```py
   >>> from transformers import TFAutoModelForSequenceClassification
@@ -510,7 +509,7 @@ tensor([[0.0021, 0.0018, 0.0115, 0.2121, 0.7725],
   >>> model = TFAutoModelForSequenceClassification.from_pretrained("distilbert-base-uncased")
   ```
-2. 一个预处理类, 比如分词器, 特征提取器或者处理器:
+2. 一个预处理类，比如分词器，特征提取器或者处理器：
   ```py
   >>> from transformers import AutoTokenizer
@@ -525,7 +524,7 @@ tensor([[0.0021, 0.0018, 0.0115, 0.2121, 0.7725],
   ...     return tokenizer(dataset["text"])  # doctest: +SKIP
   ```
-4. 使用[`~datasets.Dataset.map`]将分词器应用到整个数据集, 之后将数据集和分词器传给[`~TFPreTrainedModel.prepare_tf_dataset`]. 如果你需要的话, 也可以在这里改变批次大小和是否打乱数据集:
+4. 使用 [`~datasets.Dataset.map`] 将分词器应用到整个数据集，之后将数据集和分词器传给 [`~TFPreTrainedModel.prepare_tf_dataset`]。如果你需要的话，也可以在这里改变批次大小和是否打乱数据集：
   ```py
   >>> dataset = dataset.map(tokenize_dataset)  # doctest: +SKIP
@@ -534,7 +533,7 @@ tensor([[0.0021, 0.0018, 0.0115, 0.2121, 0.7725],
   ... )  # doctest: +SKIP
   ```
-5. 一切准备就绪后, 调用`compile`和`fit`开始训练:
+5. 一切准备就绪后，调用 `compile` 和 `fit` 开始训练：
   ```py
   >>> from tensorflow.keras.optimizers import Adam
@@ -545,4 +544,4 @@ tensor([[0.0021, 0.0018, 0.0115, 0.2121, 0.7725],
 ## 接下来做什么?
-现在你已经完成了 🤗 Transformers 的快速上手教程, 来看看我们的指南并且学习如何做一些更具体的事情, 比如写一个自定义模型, 为某个任务微调一个模型以及如何使用脚本来训练模型. 如果你有兴趣了解更多 🤗 Transformers 的核心章节, 那就喝杯咖啡然后来看看我们的概念指南吧!
+现在你已经完成了 🤗 Transformers 的快速上手教程，来看看我们的指南并且学习如何做一些更具体的事情，比如写一个自定义模型，为某个任务微调一个模型以及如何使用脚本来训练模型。如果你有兴趣了解更多 🤗 Transformers 的核心章节，那就喝杯咖啡然后来看看我们的概念指南吧！