From 36aedd43c9d00800baf85a7b3064515fcfca8902 Mon Sep 17 00:00:00 2001
From: BrightLi <flashpf@qq.com>
Date: Tue, 25 Jun 2024 20:36:16 +0800
Subject: [PATCH 1/4] autoclass_tutorial.md

---
 docs/docs/transformers/autoclass_tutorial.md | 167 +++++++++++++++----
 1 file changed, 136 insertions(+), 31 deletions(-)

diff --git a/docs/docs/transformers/autoclass_tutorial.md b/docs/docs/transformers/autoclass_tutorial.md
index 9226ed9..6efca9c 100755
--- a/docs/docs/transformers/autoclass_tutorial.md
+++ b/docs/docs/transformers/autoclass_tutorial.md
@@ -1,53 +1,158 @@
-> 翻译任务
+# 使用AutoClass加载预训练实例
 
-* 目前该页面无人翻译，期待你的加入
-* 翻译奖励: <https://github.com/orgs/apachecn/discussions/243>
-* 任务认领: <https://github.com/apachecn/huggingface-doc-zh/discussions/1>
-
-请参考这个模版来写内容:
-
-
-# Hugging Face 某某页面
-
-> 译者：[片刻小哥哥](https://github.com/jiangzhonglian)
+> 译者：[BrightLi](https://github.com/brightli)
 >
 > 项目地址：<https://huggingface.apachecn.org/docs/transformers/autoclass_tutorial>
 >
 > 原始地址：<https://huggingface.co/docs/transformers/autoclass_tutorial>
 
-开始写原始页面的翻译内容
+鉴于存在众多不同的Transformer架构，为您的检查点创建一个可能颇具挑战。作为 🤗 Transformers 核心理念的一部分，旨在使库易于使用、简单且灵活，AutoClass 能够自动推断并从给定检查点加载正确的架构。from_pretrained() 方法允许你快速加载任何架构的预训练模型，因此你不必花费时间和资源从头开始训练模型。生成这种与检查点无关的代码意味着，如果你的代码适用于一个检查点，即使架构不同，它也将适用于另一个检查点——只要该检查点是针对类似任务训练的。
+
+> 请记住，架构是指模型的骨架，而检查点是给定架构的权重。例如，[BERT](https://huggingface.co/google-bert/bert-base-uncased) 是一个架构，而 google-bert/bert-base-uncased 是一个检查点。模型是一个通用术语，可以指代架构或检查点。
+
+在本教程中，学习如何：
+* 加载预训练的分词器。
+* 加载预训练的图像处理器。
+* 加载预训练的特征提取器。
+* 加载预训练的处理器。
+* 加载预训练的模型。
+* 将模型作为主干网络加载。
+
+```py
+>>> from transformers import AutoTokenizer
+
+>>> tokenizer = AutoTokenizer.from_pretrained("google-bert/bert-base-uncased")
+```
+
+然后按照下面的方式对你的输入进行分词：
+
+```py
+>>> sequence = "In a hole in the ground there lived a hobbit."
+>>> print(tokenizer(sequence))
+{'input_ids': [101, 1999, 1037, 4920, 1999, 1996, 2598, 2045, 2973, 1037, 7570, 10322, 4183, 1012, 102], 
+ 'token_type_ids': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 
+ 'attention_mask': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]}
+```
+
+**AutoImageProcessor**
 
+对于视觉任务，图像处理器将图像处理为正确的输入格式。
 
+```py
+>>> from transformers import AutoImageProcessor
+
+>>> image_processor = AutoImageProcessor.from_pretrained("google/vit-base-patch16-224")
+```
+
+**AutoBackbone**
+
+<img src='https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/Swin%20Stages.png' width=100% />
+
+一个具有多个阶段用于输出特征图的Swin骨架网络。
+
+[AutoBackbone](https://huggingface.co/docs/transformers/v4.41.3/en/main_classes/backbones#transformers.AutoBackbone)允许您使用预训练模型作为骨架网络，以从骨架的不同阶段获取特征图。您应该在[from_pretrained()](https://huggingface.co/docs/transformers/v4.41.3/en/main_classes/configuration#transformers.PretrainedConfig.from_pretrained)中指定以下参数之一：
+
+* out_indices 是您想要获取特征图的层的索引
+* out_features 是您想要获取特征图的层的名称
 
-注意事项: 
+这些参数可以互换使用，但如果您同时使用两者，请确保它们彼此一致！如果您不传递这些参数中的任何一个，骨架将返回最后一层的特征图。
+在机器学习或深度学习上下文中，这段文字描述的是如何使用一个预训练的模型（通常是一个神经网络的一部分，负责提取低级到中级的特征）来作为新模型的基础。通过调整out_indices或out_features参数，用户能够选择骨架网络中不同层输出的特征图。如果两个参数都未指定，模型默认输出最后一个层的特征图。这对于需要在模型的不同层次上进行特征提取的任务非常有用，如物体检测或语义分割等。
 
-1. 代码参考:
+<img src='https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/Swin%20Stage%201.png' width=100% />
+
+特征图来自骨架的第一个阶段。补丁分区指的是模型的主干。
+
+例如，在上图所示的图中，要从Swin骨架的第一级返回特征图，您可以设置 out_indices=(1,)：
 
 ```py
-import torch
+>>> from transformers import AutoImageProcessor, AutoBackbone
+>>> import torch
+>>> from PIL import Image
+>>> import requests
+>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
+>>> image = Image.open(requests.get(url, stream=True).raw)
+>>> processor = AutoImageProcessor.from_pretrained("microsoft/swin-tiny-patch4-window7-224")
+>>> model = AutoBackbone.from_pretrained("microsoft/>>> swin-tiny-patch4-window7-224", out_indices=(1,))
+
+>>> inputs = processor(image, return_tensors="pt")
+>>> outputs = model(**inputs)
+>>> feature_maps = outputs.feature_maps
+```
+
+现在，您可以从骨架的第一级访问 feature_maps 对象：
+复制
 
-x = torch.ones(5)  # input tensor
-y = torch.zeros(3)  # expected output
-w = torch.randn(5, 3, requires_grad=True)
-b = torch.randn(3, requires_grad=True)
-z = torch.matmul(x, w)+b
-loss = torch.nn.functional.binary_cross_entropy_with_logits(z, y)
+```py
+>>> list(feature_maps[0].shape)
+[1, 96, 56, 56]
 ```
 
-2. 公式参考:
+**AutoFeatureExtractor**
 
-1) 无需换行的写法: 
+对于音频任务，特征提取器以正确的输入格式处理音频信号。
+使用 [AutoFeatureExtractor.from_pretrained()](https://huggingface.co/docs/transformers/v4.41.3/en/model_doc/auto#transformers.AutoFeatureExtractor.from_pretrained) 加载特征提取器：
+复制
 
-$\sqrt{w^T*w}$
+```py
+>>> from transformers import AutoFeatureExtractor
 
-2) 需要换行的写法：
+>>> feature_extractor = AutoFeatureExtractor.from_pretrained(
+"ehcalabres/wav2vec2-lg-xlsr-en-speech-emotion-recognition"
+)
+```
 
-$$
-\sqrt{w^T*w}
-$$
+**AutoProcessor**
 
-3. 图片参考(用图片的实际地址就行):
+多模态任务需要一个处理器，该处理器结合了两种类型的预处理工具。例如，[LayoutLMV2](https://huggingface.co/docs/transformers/model_doc/layoutlmv2)模型需要一个图像处理器来处理图像和一个分词器来处理文本；一个处理器将两者结合起来。
+
+使用[AutoProcessor.from_pretrained()](https://huggingface.co/docs/transformers/v4.41.3/en/model_doc/auto#transformers.AutoProcessor.from_pretrained)加载处理器：
+
+```py
+>>> from transformers import AutoProcessor
+
+>>> processor = AutoProcessor.from_pretrained("microsoft/layoutlmv2-base-uncased")
+```
+
+**AutoModel**
+
+AutoModelFor 类允许您为给定任务加载预训练模型（[此处](https://huggingface.co/docs/transformers/model_doc/auto)查看可用任务的完整列表）。例如，使用 [AutoModelForSequenceClassification.from_pretrained()](https://huggingface.co/docs/transformers/v4.41.3/en/model_doc/auto#transformers.AutoModel.from_pretrained) 加载一个用于序列分类的模型：
+
+```py
+>>> from transformers import AutoModelForSequenceClassification
+
+>>> model = AutoModelForSequenceClassification.from_pretrained("distilbert/distilbert-base-uncased")
+```
+
+轻松重用相同的检查点来加载不同任务的架构：
+
+```py
+>>> from transformers import AutoModelForTokenClassification
+
+>>> model = AutoModelForTokenClassification.from_pretrained("distilbert/distilbert-base-uncased")
+```
+
+> 对于 PyTorch 模型，from_pretrained() 方法使用 torch.load()，后者在内部使用 pickle，已知这是不安全的。通常，永远不要加载可能来自不受信任的来源的模型，或可能已被篡改的模型。对于托管在 Hugging Face Hub 上的公共模型，这种安全风险在一定程度上得到了缓解，因为每次提交都会扫描恶意软件。有关最佳实践，如使用 GPG 进行签名提交验证，请参阅 Hub 文档。
+TensorFlow 和 Flax 检查点不受影响，并且可以使用 from_pretrained 方法的 from_tf 和 from_flax kwargs 在 PyTorch 架构内加载，以绕过此问题。
+
+通常，我们建议使用 AutoTokenizer 类和 AutoModelFor 类来加载模型的预训练实例。这将确保您每次加载正确的架构。在下一个[教程](https://huggingface.co/docs/transformers/preprocessing)中，学习如何使用您新加载的分词器、图像处理器、特征提取器和处理器来预处理数据集以进行微调。
+
+TensorFlow
+
+最后，TFAutoModelFor 类允许您为给定任务加载预训练模型（[此处](https://huggingface.co/docs/transformers/model_doc/auto)查看可用任务的完整列表）。例如，使用 [TFAutoModelForSequenceClassification.from_pretrained()](https://huggingface.co/docs/transformers/v4.41.3/en/model_doc/auto#transformers.AutoModel.from_pretrained) 加载一个用于序列分类的模型：
+
+```py
+>>> from transformers import TFAutoModelForSequenceClassification
+
+>>> model = TFAutoModelForSequenceClassification.from_pretrained("distilbert/distilbert-base-uncased")
+```
+
+轻松地重用相同的检查点来加载不同任务的架构：
+
+```py
+from transformers import TFAutoModelForTokenClassification
+
+model = TFAutoModelForTokenClassification.from_pretrained("distilbert/distilbert-base-uncased")
+```
 
-<img src='http://data.apachecn.org/img/logo/logo_green.png' width=20% />
+通常，我们建议使用AutoTokenizer类和TFAutoModelFor类来加载模型的预训练实例。这将确保您每次都能加载到正确的架构。在下一个[教程](https://huggingface.co/docs/transformers/preprocessing)中，学习如何使用新加载的分词器、图像处理器、特征提取器和处理器对数据集进行微调预处理。
 
-4. **翻译完后请删除上面所有模版内容就行**
\ No newline at end of file

From b7507f3f564b44f866a490ca68fa9382a2d0a978 Mon Sep 17 00:00:00 2001
From: BrightLi <flashpf@qq.com>
Date: Wed, 26 Jun 2024 18:56:22 +0800
Subject: [PATCH 2/4] preprocessing.md

---
 docs/docs/.DS_Store                          | Bin 0 -> 6148 bytes
 docs/docs/transformers/autoclass_tutorial.md |   1 +
 docs/docs/transformers/preprocessing.md      |  50 +++++--------------
 3 files changed, 14 insertions(+), 37 deletions(-)
 create mode 100644 docs/docs/.DS_Store

diff --git a/docs/docs/.DS_Store b/docs/docs/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..0f606b1179712ad43b17b6881d149996c9b7d30d
GIT binary patch
literal 6148
zcmeHK!Ab)$5S_HuZmB{K3OxqA7Obrb;$^Az2VBvEO5LSZ7q^?TyS0Z>*t7nSU*h*T
zlcZv)y?78QGcb9R$;^hlESUrVL}%PT0H^_ggGyMaVDp2}IO&oUtcOtOZ=~=53KAH?
zU@4j%|B(UOyDi9Y&wPmC`~D@629tCYL@L0T_h1x-Y1V9hh(fWnu~~M?PSv^dp47z4
z{A`?d{N#pumr6y!-1dX3a4_lBcFt6s`C&XrbVAr4V94!t828nrqsDPR)w!M-a4Jrv
zSF2B_N9|Taw%YAkLrzax&4xT|AJ1kLXLoP^^rH714P*6cNEP`1Y1y_ohc`4<uJ6T5
z;z-4h7&FhG=P@z^%m6d6&J5Ty&#A8SB6)4h05k9_2Izc{sD!S?+@L->u%YWCjh6^X
z(5ANpp|t2)%njlQiZH2&CRNxchA`>qmp0C|m>V?dAoR@m9XqqIFBG9?N59nJAY6mo
zG6T%OA_GO!tx^3yU;X}HOyV9hzznPv1ESRRx*c4St*uLoqgpFb?@>u8E;sm<f`%@|
f7)zzNj;aOyk_<%GVr~#UD0~snG;qTV{3!#Ubr(<2

literal 0
HcmV?d00001

diff --git a/docs/docs/transformers/autoclass_tutorial.md b/docs/docs/transformers/autoclass_tutorial.md
index 6efca9c..594c510 100755
--- a/docs/docs/transformers/autoclass_tutorial.md
+++ b/docs/docs/transformers/autoclass_tutorial.md
@@ -18,6 +18,7 @@
 * 加载预训练的模型。
 * 将模型作为主干网络加载。
 
+
 ```py
 >>> from transformers import AutoTokenizer
 
diff --git a/docs/docs/transformers/preprocessing.md b/docs/docs/transformers/preprocessing.md
index 9789518..28cff1e 100755
--- a/docs/docs/transformers/preprocessing.md
+++ b/docs/docs/transformers/preprocessing.md
@@ -1,53 +1,29 @@
-> 翻译任务
+# 预处理
 
-* 目前该页面无人翻译，期待你的加入
-* 翻译奖励: <https://github.com/orgs/apachecn/discussions/243>
-* 任务认领: <https://github.com/apachecn/huggingface-doc-zh/discussions/1>
-
-请参考这个模版来写内容:
-
-
-# Hugging Face 某某页面
-
-> 译者：[片刻小哥哥](https://github.com/jiangzhonglian)
+> 译者：[BrightLi](https://github.com/brightli)
 >
 > 项目地址：<https://huggingface.apachecn.org/docs/transformers/preprocessing>
 >
 > 原始地址：<https://huggingface.co/docs/transformers/preprocessing>
 
-开始写原始页面的翻译内容
+在你可以对数据集进行模型训练之前，数据需要预处理为模型所期望的输入格式。无论你的数据是文本、图像还是音频，它们都需要被转换并组装成张量的批次。🤗 Transformers 提供了一组预处理类来帮助准备你的数据用于模型。在本教程中，你将学习以下内容：
+
+* 对于文本，使用[Tokenizer](https://huggingface.co/docs/transformers/main_classes/tokenizer)将文本转换为一系列的标记，创建标记的数值表示，并将它们组装成张量。
+* 对于语音和音频，使用[Feature Extractor](https://huggingface.co/docs/transformers/main_classes/feature_extractor)从音频波形中提取序列特征并将其转换成张量。
+* 对于图像输入，使用[ImageProcessor](https://huggingface.co/docs/transformers/main_classes/image_processor)将图像转换成张量。
+* 对于多模态输入，使用[Processor](https://huggingface.co/docs/transformers/main_classes/processors)结合一个 tokenizer 和一个 feature extractor 或 image processor。
 
 
 
-注意事项: 
+> AutoProcessor 总是有效，并且会自动为你所使用的模型选择正确的类，无论你是使用 tokenizer、image processor、feature extractor 还是 processor。
 
-1. 代码参考:
+在开始之前，安装 🤗 Datasets 以便你可以加载一些数据集进行实验：
 
 ```py
-import torch
-
-x = torch.ones(5)  # input tensor
-y = torch.zeros(3)  # expected output
-w = torch.randn(5, 3, requires_grad=True)
-b = torch.randn(3, requires_grad=True)
-z = torch.matmul(x, w)+b
-loss = torch.nn.functional.binary_cross_entropy_with_logits(z, y)
+pip install datasets
 ```
 
-2. 公式参考:
-
-1) 无需换行的写法: 
-
-$\sqrt{w^T*w}$
-
-2) 需要换行的写法：
-
-$$
-\sqrt{w^T*w}
-$$
-
-3. 图片参考(用图片的实际地址就行):
+**自然语言处理**
 
-<img src='http://data.apachecn.org/img/logo/logo_green.png' width=20% />
+<iframe width="560" height="315" src="https://www.youtube.com/embed/Yffk5aydLzg?si=imtCeOHYnybF05pc" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>
 
-4. **翻译完后请删除上面所有模版内容就行**
\ No newline at end of file

From b71f6e33b35d2b47bdfd37ef86eb6255f22a092c Mon Sep 17 00:00:00 2001
From: BrightLi <flashpf@qq.com>
Date: Wed, 26 Jun 2024 19:17:26 +0800
Subject: [PATCH 3/4] preprocessing.md

---
 docs/docs/.DS_Store                     | Bin 6148 -> 6148 bytes
 docs/docs/transformers/preprocessing.md |   2 +-
 2 files changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/docs/.DS_Store b/docs/docs/.DS_Store
index 0f606b1179712ad43b17b6881d149996c9b7d30d..37e3838d32f0880e6f82b9f8cca9499f0cd311e6 100644
GIT binary patch
delta 21
ccmZoMXffEZf{DY#$V5lM$jE&22Br{E07u;h8UO$Q

delta 21
ccmZoMXffEZf{DY_*hojg$k=%E2Br{E07uUT7XSbN

diff --git a/docs/docs/transformers/preprocessing.md b/docs/docs/transformers/preprocessing.md
index 28cff1e..28fe9a8 100755
--- a/docs/docs/transformers/preprocessing.md
+++ b/docs/docs/transformers/preprocessing.md
@@ -25,5 +25,5 @@ pip install datasets
 
 **自然语言处理**
 
-<iframe width="560" height="315" src="https://www.youtube.com/embed/Yffk5aydLzg?si=imtCeOHYnybF05pc" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>
 
+<video src="https://youtu.be/Yffk5aydLzg" controls></video>

From 8481b951fc4b66e72b5d6a65fbdfaa12bfbf1c3e Mon Sep 17 00:00:00 2001
From: BrightLi <flashpf@qq.com>
Date: Mon, 1 Jul 2024 22:16:35 +0800
Subject: [PATCH 4/4] add docs

---
 docs/docs/.DS_Store                     | Bin 6148 -> 8196 bytes
 docs/docs/transformers/accelerate.md    |  49 +--
 docs/docs/transformers/preprocessing.md | 428 +++++++++++++++++++++++-
 docs/docs/transformers/run_scripts.md   | 314 +++++++++++++++--
 docs/docs/transformers/training.md      | 372 ++++++++++++++++++--
 5 files changed, 1058 insertions(+), 105 deletions(-)

diff --git a/docs/docs/.DS_Store b/docs/docs/.DS_Store
index 37e3838d32f0880e6f82b9f8cca9499f0cd311e6..ccb2495284848e5a079ce089af72aee236522c0a 100644
GIT binary patch
literal 8196
zcmeHMO>h)N6z*>lV1^82fFKL*6bpeus0Bh2P584me+mc$*o6ELSY~$yGBBA5JF^=g
zq)b_*2mUNiTK;>|l9Gc3N_p|1B6?J`3d{09spZcB4_;IbzL}n-OhP!J1?6;A_nUtG
zUU$FO@9WOnFviea(AO{)V~mMZeX3MYbDQFi`*lJQLQXkRkUnEBJHQ;4X9LWbARRFx
z4@4e_JP>&x@<8N)d%*+rX8T2)<lX0^Q5$(6^1%Pn1OEMxpz709NJlvht`2H~6o9Co
z0tAJ=DGvyA5+O~6bd=LTmFDEx1431VDF(PYjVF9@qN$LMa>~^ixH?0)GQtc6!Rn-!
z2*epuoJMWrfye_BJ>bJfW*+728negb?|J5Chup!e<zz|bQg+ZXU9YC*YY1iKQ>IQ6
zr->Ef-gLh+l=d{Q;5KXdJ$|plajb0VTg&b?jiHQE)#BKmX4*zRP%w3aMEbf+TX%+<
zor0~qfo_@)h>|E}l-TfaeQjMbQCr(El1vP*t*uEW>gygE8Ii=f)vMR<${e-^Z0965
z3E{QCW{flO)Sc|J++qv2uPj}%@0*f+()0>>hT7HL(<}F7l-Wfxq<zpc9oyY)<Xxf}
zrP3vXH|HFCN8a$qyK;_I7_i-pGApN9xq_v6Mw4Zw&Ep2~D&1V(v8)}AYx>jlbbH28
z&mWsG)ZObkd9NjyETbp|*VtvyTxQW|r5W9Bla}-qtHv1%>HN%j3zs~!vbJGEs%`VO
zomVTBS+nO<$#O4w*7nQ;rjhR)GIg)NM{{$At(*42uA=FhS<C3KwE<%ml9F__GB$s~
zgK<@zOtia@HIEcb@0e08ioqI*MXKDV)8@80y1$C9Toh>@T7BsvRo&x{wB!wH^-y8?
z3RUiK$p%FW1y`+><&MJ?5{m0@fmG}2Wwq1NvWBJT5?`lrt*mwxx&M_XLgvOQS?$g_
z0|R8D8}gc(Rdt`g>{iY7+6N7rwsa+2`!O2pb^Eov(LO{W8FIG}H#kz_`$}!P={dn5
zd1E_S(c@3or0anV3u5yt)wJ3vDqo0nM5bLd2?lhm91UW1>X|FS=~Smy@KdTT9ai9I
zsXA2?GDN1bTGq<8vi$_ZVRnYSz|OG?>=SmGeZ{_GKeHR`4**jkVLB>Mg#}oGBpyZs
z8nG75Xva?MLK=POhlxXQaTLcfj1zboCvh5Qa2C(w6}*Pm@dn<;ySRXhcn=@q3O>W<
z_!8IgJ$}HCxPd?M7j6nugn2?tm@h0AlEO-1mCztG3hRXR!giru=oU2Lkl+Y|eE&iT
zdV5O-hWukhC%sw-dg0X~oWDKv;*W3IyhYx6-$3u$Ob)iW56nv}U9q~pabwf1pyW|p
z3fzCfA;7>G<OCQ9Vq{$WUgfBi7nTq^9-f^99^<I!V_2ESr5DRfL;{a8g?E?9%SD2X
zGL?6e@l_%LRS|-&ye3{J5ge5=-c80EBvAqHtdloL1WcuzcU3thNeT-(@s@a-NZ?Y$
zyA}1<*md?3`;FbCsGo^Bh+!FODApgvCTyo@_hY>i`;dW#EOZRO#vqPR+@HV*p2R4g
z!YPXTvv?NI;YGZJm+>mz#9I{m=kN|i{`<Iu5AYE_#$|jOV&Gdsz%Tf9TvTrx8`b#z
zPElP<=WWZe50Xp?6=T)!sa_f1P0Y{#+a~}0|DM`&w3)~Qkq7Rs2T<OcZf&MHC%d!!
zTsuK^KUKf@a-*CED%1q&IME;-Cwl82hV-2vQC}w&(os%{L*+mJA>iNo(>r?qqxb(l
HdjJ0h;aQBM

delta 127
zcmZp1XfcprU|?W$DortDU=RQ@Ie-{MGjUEV6q~50$jG!YU^nAr0~wad4&suNH3XU%
zO(w4vh@BiMzHVbfAj@KQ4h}(Ppavii;06+|AiWz4zcWwfmvICc&cMjPzyhL~Af|)G
KHplbKVFm!+U=?Ek

diff --git a/docs/docs/transformers/accelerate.md b/docs/docs/transformers/accelerate.md
index d2c931c..58067ab 100755
--- a/docs/docs/transformers/accelerate.md
+++ b/docs/docs/transformers/accelerate.md
@@ -1,53 +1,18 @@
-> 翻译任务
+# 使用 🤗 Accelerate 进行分布式训练
 
-* 目前该页面无人翻译，期待你的加入
-* 翻译奖励: <https://github.com/orgs/apachecn/discussions/243>
-* 任务认领: <https://github.com/apachecn/huggingface-doc-zh/discussions/1>
-
-请参考这个模版来写内容:
-
-
-# Hugging Face 某某页面
-
-> 译者：[片刻小哥哥](https://github.com/jiangzhonglian)
+> 译者：[BrightLi](https://github.com/brightli)
 >
 > 项目地址：<https://huggingface.apachecn.org/docs/transformers/accelerate>
 >
 > 原始地址：<https://huggingface.co/docs/transformers/accelerate>
 
-开始写原始页面的翻译内容
-
-
-
-注意事项: 
+随着模型变得越来越大，并行计算已经成为一种在有限的硬件上训练更大模型和加速训练速度几个数量级的策略。在 Hugging Face，我们创建了 🤗 [Accelerate](https://huggingface.co/docs/accelerate)库来帮助用户轻松地在任何类型的分布式设置上训练一个 🤗 Transformers 模型，无论是一台机器上的多个 GPU 还是多台机器上的多个 GPU。在本教程中，了解如何自定义你的原生 PyTorch 训练循环以启用分布式环境的训练。
 
-1. 代码参考:
+**设置**
 
-```py
-import torch
+首先通过安装 🤗 Accelerate 开始：
 
-x = torch.ones(5)  # input tensor
-y = torch.zeros(3)  # expected output
-w = torch.randn(5, 3, requires_grad=True)
-b = torch.randn(3, requires_grad=True)
-z = torch.matmul(x, w)+b
-loss = torch.nn.functional.binary_cross_entropy_with_logits(z, y)
+```shell
+pip install accelerate
 ```
 
-2. 公式参考:
-
-1) 无需换行的写法: 
-
-$\sqrt{w^T*w}$
-
-2) 需要换行的写法：
-
-$$
-\sqrt{w^T*w}
-$$
-
-3. 图片参考(用图片的实际地址就行):
-
-<img src='http://data.apachecn.org/img/logo/logo_green.png' width=20% />
-
-4. **翻译完后请删除上面所有模版内容就行**
\ No newline at end of file
diff --git a/docs/docs/transformers/preprocessing.md b/docs/docs/transformers/preprocessing.md
index 28fe9a8..fe4b3bb 100755
--- a/docs/docs/transformers/preprocessing.md
+++ b/docs/docs/transformers/preprocessing.md
@@ -26,4 +26,430 @@ pip install datasets
 **自然语言处理**
 
 
-<video src="https://youtu.be/Yffk5aydLzg" controls></video>
+<iframe width="446" height="320" src="https://www.youtube.com/embed/Yffk5aydLzg" title="The tokenization pipeline" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>
+
+
+预处理文本数据的主要工具是[分词器](https://huggingface.co/docs/transformers/main_classes/tokenizer)。分词器根据一组规则将文本拆分为标记。这些标记被转换为数字，然后是张量，成为模型的输入。模型所需的任何额外输入都由分词器添加。
+
+
+> 如果您计划使用预训练模型，使用相关的预训练分词器很重要。这确保了文本按照与预训练语料库相同的方式拆分，并在预训练期间使用相同的对应标记到索引（通常称为词汇表）。
+
+
+通过使用[AutoTokenizer.from_pretrained()](https://huggingface.co/docs/transformers/v4.41.3/en/model_doc/auto#transformers.AutoTokenizer.from_pretrained)方法加载预训练分词器来开始。这将下载模型预训练时使用的词汇表：
+
+
+```py
+>>> from transformers import AutoTokenizer
+
+>>> tokenizer = AutoTokenizer.from_pretrained("google-bert/bert-base-cased")
+```
+
+将您的文本传递给分词器：
+
+```py
+>>> encoded_input = tokenizer("Do not meddle in the affairs of wizards, for they are subtle and quick to anger.")
+>>>> print(encoded_input)
+{'input_ids': [101, 2079, 2025, 19960, 10362, 1999, 1996, 3821, 1997, 16657, 1010, 2005, 2027, 2024, 11259, 1998, 4248, 2000, 4963, 1012, 102],
+ 'token_type_ids': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+ 'attention_mask': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]}
+```
+
+分词器返回一个包含三个重要项目的字典：
+
+* [input_ids](https://huggingface.co/docs/transformers/glossary#input-ids) 是句子中每个标记对应索引。
+
+* [attention_mask](https://huggingface.co/docs/transformers/glossary#attention-mask) 指示是否应该关注某个标记。
+
+* [token_type_ids](https://huggingface.co/docs/transformers/glossary#token-type-ids) 在有多个序列时，标识标记属于哪个序列。
+
+通过解码 input_ids 返回您的输入：
+
+```py
+tokenizer.decode(encoded_input["input_ids"])
+'[CLS] Do not meddle in the affairs of wizards, for they are subtle and quick to anger. [SEP]'
+```
+
+如您所见，分词器在句子中添加了两个特殊标记 - CLS 和 SEP（分类器和分隔符）。并非所有模型都需要特殊标记，但如果需要，分词器会自动为您添加它们。
+
+如果您想要预处理几个句子，将它们作为一个列表传递给分词器：
+
+```py
+batch_sentences = [
+    "But what about second breakfast?",
+    "Don't think he knows about second breakfast, Pip.",
+    "What about elevensies?",
+]
+encoded_inputs = tokenizer(batch_sentences)
+print(encoded_inputs)
+{'input_ids': [[101, 1252, 1184, 1164, 1248, 6462, 136, 102],
+               [101, 1790, 112, 189, 1341, 1119, 3520, 1164, 1248, 6462, 117, 21902, 1643, 119, 102],
+               [101, 1327, 1164, 5450, 23434, 136, 102]],
+ 'token_type_ids': [[0, 0, 0, 0, 0, 0, 0, 0],
+                    [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+                    [0, 0, 0, 0, 0, 0, 0]],
+ 'attention_mask': [[1, 1, 1, 1, 1, 1, 1, 1],
+                    [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+                    [1, 1, 1, 1, 1, 1, 1]]}
+```
+
+**填充**
+
+句子的长度并不总是相同的，这可能是一个问题，因为模型的输入张量需要具有统一的形状。填充是一种策略，通过向较短的句子添加特殊的填充标记来确保张量是矩形的。
+
+将填充参数设置为True，以在批次中对较短的序列进行填充，使其与最长的序列相匹配：
+
+```py
+batch_sentences = [
+    "But what about second breakfast?",
+    "Don't think he knows about second breakfast, Pip.",
+    "What about elevensies?",
+]
+encoded_input = tokenizer(batch_sentences, padding=True)
+print(encoded_input)
+{'input_ids': [[101, 1252, 1184, 1164, 1248, 6462, 136, 102, 0, 0, 0, 0, 0, 0, 0],
+               [101, 1790, 112, 189, 1341, 1119, 3520, 1164, 1248, 6462, 117, 21902, 1643, 119, 102],
+               [101, 1327, 1164, 5450, 23434, 136, 102, 0, 0, 0, 0, 0, 0, 0, 0]],
+ 'token_type_ids': [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+                    [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+                    [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]],
+ 'attention_mask': [[1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0],
+                    [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+                    [1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0]]}
+```
+
+第一句和第三句现在用0进行了填充，因为它们比较短。
+
+**截断**
+
+
+在另一种情况下，有时一个序列可能过长，模型无法处理。在这种情况下，你需要将序列截断为更短的长度。
+
+
+将截断参数设置为True，可将序列截断为模型可接受的最大长度：
+
+
+```py
+>>> batch_sentences = [
+    "But what about second breakfast?",
+    "Don't think he knows about second breakfast, Pip.",
+    "What about elevensies?",
+]
+>>> encoded_input = tokenizer(batch_sentences, padding=True, truncation=True)
+>>> print(encoded_input)
+{'input_ids': [[101, 1252, 1184, 1164, 1248, 6462, 136, 102, 0, 0, 0, 0, 0, 0, 0],
+               [101, 1790, 112, 189, 1341, 1119, 3520, 1164, 1248, 6462, 117, 21902, 1643, 119, 102],
+               [101, 1327, 1164, 5450, 23434, 136, 102, 0, 0, 0, 0, 0, 0, 0, 0]],
+ 'token_type_ids': [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+                    [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+                    [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]],
+ 'attention_mask': [[1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0],
+                    [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+                    [1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0]]}
+```
+
+
+> 查看[填充和截断](https://huggingface.co/docs/transformers/pad_truncation)概念指南，以了解更多不同的填充和截断参数。
+
+**构建张量**
+
+最后，你希望tokenizer返回实际输入到模型的张量。
+
+将return_tensors参数设置为pt（针对PyTorch）或tf（针对TensorFlow）：
+
+```py
+batch_sentences = [
+    "But what about second breakfast?",
+    "Don't think he knows about second breakfast, Pip.",
+    "What about elevensies?",
+]
+encoded_input = tokenizer(batch_sentences, padding=True, truncation=True, return_tensors="pt")
+print(encoded_input)
+{'input_ids': <tf.Tensor: shape=(2, 9), dtype=int32, numpy=
+array([[101, 1252, 1184, 1164, 1248, 6462, 136, 102, 0, 0, 0, 0, 0, 0, 0],
+       [101, 1790, 112, 189, 1341, 1119, 3520, 1164, 1248, 6462, 117, 21902, 1643, 119, 102],
+       [101, 1327, 1164, 5450, 23434, 136, 102, 0, 0, 0, 0, 0, 0, 0, 0]],
+      dtype=int32)>,
+ 'token_type_ids': <tf.Tensor: shape=(2, 9), dtype=int32, numpy=
+array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], dtype=int32)>,
+ 'attention_mask': <tf.Tensor: shape=(2, 9), dtype=int32, numpy=
+array([[1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0],
+       [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+       [1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0]], dtype=int32)>}
+```
+
+> 不同的管道在其__call__()方法中支持tokenizer参数的方式不同。“文本到文本生成”管道只支持（即传递）truncation参数。“文本生成”管道支持max_length、truncation、padding和add_special_tokens参数。在“填充掩码”管道中，可以通过tokenizer_kwargs参数（字典形式）传递tokenizer参数。
+
+**音频**
+
+对于音频任务，你需要一个[特征提取器](https://huggingface.co/docs/transformers/main_classes/feature_extractor)来准备模型所需的数据集。特征提取器旨在从原始音频数据中提取特征，并将它们转换为张量。
+
+加载[MInDS-14](https://huggingface.co/datasets/PolyAI/minds14)数据集（有关如何加载数据集的更多详细信息，请参阅 🤗 [Datasets教程](https://huggingface.co/docs/datasets/load_hub)），了解如何使用特征提取器处理音频数据集：
+
+访问音频列的第一个元素以查看输入。调用音频列会自动加载并重新采样音频文件：
+
+```py
+>>> dataset[0]["audio"]
+{'array': array([ 0.        ,  0.00024414, -0.00024414, ..., -0.00024414,
+         0.        ,  0.        ], dtype=float32),
+ 'path': '/root/.cache/huggingface/datasets/downloads/extracted/f14948e0e84be638dd7943ac36518a4cf3324e8b7aa331c5ab11541518e9368c/en-US~JOINT_ACCOUNT/602ba55abb1e6d0fbce92065.wav',
+ 'sampling_rate': 8000}
+```
+
+这将返回三个项目：
+
+* array 是将语音信号加载（并可能重新采样）为1D数组。
+  
+* path 指向音频文件的位置。
+  
+* sampling_rate 指的是每秒测量的语音信号中的数据点数。
+
+在本教程中，你将使用[Wav2Vec2](https://huggingface.co/facebook/wav2vec2-base)模型。查看模型卡片，你会了解到Wav2Vec2是在16kHz采样的语音音频上预训练的。确保你的音频数据的采样率与用于预训练模型的数据集的采样率相匹配是很重要的。如果你的数据的采样率不同，那么你需要对你的数据进行重新采样。
+
+1.使用🤗 Datasets的cast_column方法将采样率上采样到16kHz：
+
+```py
+>>> dataset = dataset.cast_column("audio", Audio(sampling_rate=16_000))
+```
+
+再次调用音频列以重新采样音频文件：
+
+```py
+>>> dataset[0]["audio"]
+{'array': array([ 2.3443763e-05,  2.1729663e-04,  2.2145823e-04, ...,
+         3.8356509e-05, -7.3497440e-06, -2.1754686e-05], dtype=float32),
+ 'path': '/root/.cache/huggingface/datasets/downloads/extracted/f14948e0e84be638dd7943ac36518a4cf3324e8b7aa331c5ab11541518e9368c/en-US~JOINT_ACCOUNT/602ba55abb1e6d0fbce92065.wav',
+ 'sampling_rate': 16000}
+```
+
+接下来，加载一个特征提取器来标准化和填充输入。在对文本数据进行填充时，对于较短的序列会添加0。同样的方法适用于音频数据。特征提取器会在数组中添加0 - 被解释为静音。
+
+使用[AutoFeatureExtractor.from_pretrained()](https://huggingface.co/docs/transformers/v4.41.3/en/model_doc/auto#transformers.AutoFeatureExtractor.from_pretrained)加载特征提取器：
+
+
+```py
+>>> from transformers import AutoFeatureExtractor
+
+>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/wav2vec2-base")
+```
+
+将音频数组传递给特征提取器。我们还建议在特征提取器中添加sampling_rate参数，以便更好地调试可能发生的任何静默错误。
+
+```py
+>>> audio_input = [dataset[0]["audio"]["array"]]
+>>> feature_extractor(audio_input, sampling_rate=16000)
+{'input_values': [array([ 3.8106556e-04,  2.7506407e-03,  2.8015103e-03, ...,
+        5.6335266e-04,  4.6588284e-06, -1.7142107e-04], dtype=float32)]}
+```
+
+就像tokenizer一样，你可以应用填充或截断来处理批次中的可变序列。看看这两个音频样本的序列长度：
+
+```py
+>>> dataset[0]["audio"]["array"].shape
+(173398,)
+>>> dataset[1]["audio"]["array"].shape
+(106496,)
+```
+
+创建一个函数来预处理数据集，使音频样本具有相同的长度。指定一个最大样本长度，特征提取器将填充或截断序列以匹配它：
+
+```py
+def preprocess_function(examples):
+    audio_arrays = [x["array"] for x in examples["audio"]]
+    inputs = feature_extractor(
+        audio_arrays,
+        sampling_rate=16000,
+        padding=True,
+        max_length=100000,
+        truncation=True,
+    )
+    return inputs
+```
+
+将preprocess_function应用于数据集中的前几个示例：
+
+```py
+>>> processed_dataset = preprocess_function(dataset[:5])
+```
+
+样本长度现在相同，并且与指定的最大长度匹配。你现在可以将处理过的数据集传递给模型了！
+
+```py
+>>> processed_dataset["input_values"][0].shape
+(100000,)
+>>> processed_dataset["input_values"][1].shape
+(100000,)
+```
+
+**计算机视觉**
+
+对于计算机视觉任务，你需要一个[图像处理器](https://huggingface.co/docs/transformers/main_classes/image_processor)来准备模型所需的数据集。图像预处理包括几个步骤，这些步骤将图像转换为模型所期望的输入。这些步骤包括但不限于调整大小、归一化、颜色通道校正和将图像转换为张量。
+
+> 图像预处理通常伴随着某种形式的图像增强。图像预处理和图像增强都会转换图像数据，但它们服务于不同的目的：
+图像增强以可以帮助防止过拟合和提高模型的鲁棒性的方式改变图像。你可以在增强数据时发挥创意 - 调整亮度和颜色、裁剪、旋转、调整大小、缩放等。然而，要注意不要通过你的增强改变图像的意义。
+图像预处理保证图像与模型期望的输入格式相匹配。在微调计算机视觉模型时，必须像模型最初训练时那样精确地进行图像预处理。
+你可以使用你喜欢的任何库进行图像增强。对于图像预处理，使用与模型相关的ImageProcessor。
+
+加载[food101](https://huggingface.co/datasets/food101)数据集（有关如何加载数据集的更多详细信息，请参阅 🤗 [Datasets教程](https://huggingface.co/docs/datasets/load_hub)），了解如何使用图像处理器处理计算机视觉数据集：
+
+> 使用🤗 Datasets的split参数仅从训练拆分中加载一个小样本，因为这个数据集相当大！
+
+```py
+>>> from datasets import load_dataset
+
+>>> dataset = load_dataset("food101", split="train[:100]")
+```
+
+接下来，使用🤗 Datasets的[Image](https://huggingface.co/docs/datasets/package_reference/main_classes?highlight=image#datasets.Image)特性查看图像：
+
+```py
+dataset[0]["image"]
+```
+
+<p style="text-align: center;">
+<img src='https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/vision-preprocess-tutorial.png' width=50% />
+</p>
+
+使用[AutoImageProcessor.from_pretrained()](https://huggingface.co/docs/transformers/v4.41.3/en/model_doc/auto#transformers.AutoImageProcessor.from_pretrained)加载图像处理器：
+
+```py
+>>> from transformers import AutoImageProcessor
+
+>>> image_processor = AutoImageProcessor.from_pretrained("google/vit-base-patch16-224")
+```
+
+首先，让我们添加一些图像增强。你可以使用你喜欢的任何库，但在本教程中，我们将使用torchvision的[transforms](https://pytorch.org/vision/stable/transforms.html)模块。如果你对使用另一个数据增强库感兴趣，可以在[Albumentations](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/image_classification_albumentations.ipynb)或[Kornia笔记本](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/image_classification_kornia.ipynb)中学习如何使用。
+
+1.在这里，我们使用[Compose](https://pytorch.org/vision/master/generated/torchvision.transforms.Compose.html)将几个转换链接在一起 - [RandomResizedCrop](https://pytorch.org/vision/main/generated/torchvision.transforms.RandomResizedCrop.html)和[ColorJitter](https://pytorch.org/vision/main/generated/torchvision.transforms.ColorJitter.html)。请注意，对于调整大小，我们可以从image_processor获取图像大小要求。对于一些模型，需要确切的高度和宽度，而对于其他模型，只定义了最短边。
+
+```py
+>>> from torchvision.transforms import RandomResizedCrop, ColorJitter, Compose
+
+>>> size = (
+    image_processor.size["shortest_edge"]
+    if "shortest_edge" in image_processor.size
+    else (image_processor.size["height"], image_processor.size["width"])
+)
+
+>>> _transforms = Compose([RandomResizedCrop(size), ColorJitter(brightness=0.5, hue=0.5)])
+```
+
+2.模型接受[pixel_values](https://huggingface.co/docs/transformers/model_doc/vision-encoder-decoder#transformers.VisionEncoderDecoderModel.forward.pixel_values)作为其输入。ImageProcessor可以负责对图像进行归一化，并生成适当的张量。创建一个函数，将图像增强和图像预处理结合起来，为一批图像生成pixel_values：
+
+```py
+def transforms(examples):
+    images = [_transforms(img.convert("RGB")) for img in examples["image"]]
+    examples["pixel_values"] = image_processor(images, do_resize=False, return_tensors="pt")["pixel_values"]
+    return examples
+```
+
+> 在上面的示例中，我们将do_resize设置为False，因为我们已经在图像增强转换中调整了图像的大小，并利用了适当的image_processor的size属性。如果在图像增强过程中不调整图像大小，可以省略此参数。默认情况下，ImageProcessor会处理调整大小。
+如果希望将图像归一化作为增强转换的一部分，使用image_processor.image_mean和image_processor.image_std值。
+
+3.然后使用🤗 Datasets的set_transform方法实时应用转换：
+
+```py
+>>> dataset.set_transform(transforms)
+```
+
+4.现在当你访问图像时，你会注意到图像处理器已经添加了pixel_values。现在你可以将处理过的数据集传递给模型了！
+
+```py
+>>> dataset[0].keys()
+```
+
+以下是应用转换后图像的样子。图像已被随机裁剪，其颜色属性也有所不同。
+
+```py
+>>> import numpy as np
+>>> import matplotlib.pyplot as plt
+
+>>> img = dataset[0]["pixel_values"]
+>>> plt.imshow(img.permute(1, 2, 0))
+```
+
+<p style="text-align: center;">
+<img src='https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/preprocessed_image.png' width=40% />
+</p>
+
+> 对于像目标检测、语义分割、实例分割和全景分割这样的任务，ImageProcessor提供了后处理方法。这些方法将模型的原始输出转换为有意义的预测，如边界框或分割图。
+
+**填充**
+
+在某些情况下，例如在微调[DETR](https://huggingface.co/docs/transformers/model_doc/detr)时，模型会在训练时应用尺度增强。这可能会导致批处理中的图像大小不同。您可以使用[DetrImageProcessor](https://huggingface.co/docs/transformers/v4.41.3/en/model_doc/detr#transformers.DetrImageProcessor)的DetrImageProcessor.pad()方法并定义一个自定义的collate_fn来将图像组合在一起。
+
+```py
+def collate_fn(batch):
+    pixel_values = [item["pixel_values"] for item in batch]
+    encoding = image_processor.pad(pixel_values, return_tensors="pt")
+    labels = [item["labels"] for item in batch]
+    batch = {}
+    batch["pixel_values"] = encoding["pixel_values"]
+    batch["pixel_mask"] = encoding["pixel_mask"]
+    batch["labels"] = labels
+    return batch
+```
+
+**多模态**
+
+对于涉及多模态输入的任务，您需要一个[处理器](https://huggingface.co/docs/transformers/main_classes/processors)来为模型准备数据集。一个处理器将两个处理对象（如tokenizer和feature extractor）结合在一起。
+
+加载[LJ Speech](https://huggingface.co/datasets/lj_speech)数据集（有关如何加载数据集的更多详细信息，请参阅🤗 [Datasets教程](https://huggingface.co/docs/datasets/load_hub)），了解如何使用处理器进行自动语音识别（ASR）：
+
+```py
+>>> from datasets import load_dataset
+
+>>> lj_speech = load_dataset("lj_speech", split="train")
+```
+
+对于ASR，您主要关注音频和文本，因此可以删除其他列：
+
+```py
+lj_speech = lj_speech.map(remove_columns=["file", "id", "normalized_text"])
+```
+
+现在查看音频和文本列：
+
+```py
+>>> lj_speech[0]["audio"]
+{'array': array([-7.3242188e-04, -7.6293945e-04, -6.4086914e-04, ...,
+         7.3242188e-04,  2.1362305e-04,  6.1035156e-05], dtype=float32),
+ 'path': '/root/.cache/huggingface/datasets/downloads/extracted/917ece08c95cf0c4115e45294e3cd0dee724a1165b7fc11798369308a465bd26/LJSpeech-1.1/wavs/LJ001-0001.wav',
+ 'sampling_rate': 22050}
+>>> lj_speech[0]["text"]
+'Printing, in the only sense with which we are at present concerned, differs from most if not from all the arts and crafts represented in the Exhibition'
+```
+
+请记住，您应该始终[重新采样](https://huggingface.co/docs/transformers/preprocessing#audio)音频数据集的采样率，以匹配用于预训练模型的数据集的采样率！
+
+```py
+>>> lj_speech = lj_speech.cast_column("audio", Audio(sampling_rate=16_000))
+```
+
+使用[AutoProcessor.from_pretrained()](https://huggingface.co/docs/transformers/v4.41.3/en/model_doc/auto#transformers.AutoProcessor.from_pretrained)加载处理器：
+
+```py
+from transformers import AutoProcessor
+
+processor = AutoProcessor.from_pretrained("facebook/wav2vec2-base-960h")
+```
+
+1.创建一个函数，将包含在数组中的音频数据转换为input_values，并将文本标记化为labels。这些是模型的输入：
+
+```py
+>>> def prepare_dataset(example):
+    audio = example["audio"]
+
+    example.update(processor(audio=audio["array"], text=example["text"], sampling_rate=16000))
+
+    return example
+```
+
+2.将prepare_dataset函数应用于一个样本：
+
+```py
+>>> prepare_dataset(lj_speech[0])
+```
+
+现在，处理器已经添加了input_values和labels，并且采样率也被正确地降低到了16kHz。现在你可以将处理过的数据集传递给模型了！
\ No newline at end of file
diff --git a/docs/docs/transformers/run_scripts.md b/docs/docs/transformers/run_scripts.md
index 23fb4ca..0f4363f 100755
--- a/docs/docs/transformers/run_scripts.md
+++ b/docs/docs/transformers/run_scripts.md
@@ -1,53 +1,305 @@
-> 翻译任务
+# 使用脚本训练
 
-* 目前该页面无人翻译，期待你的加入
-* 翻译奖励: <https://github.com/orgs/apachecn/discussions/243>
-* 任务认领: <https://github.com/apachecn/huggingface-doc-zh/discussions/1>
+> 译者：[BrightLi](https://github.com/brightli)
+>
+> 项目地址：<https://huggingface.apachecn.org/docs/transformers/run_scripts>
+>
+> 原始地址：<https://huggingface.co/docs/transformers/run_scripts>
 
-请参考这个模版来写内容:
+使用脚本训练
+除了 🤗 Transformers [笔记本](https://huggingface.co/docs/transformers/notebooks)之外，还有示例脚本演示了如何使用 [PyTorch](https://github.com/huggingface/transformers/tree/main/examples/pytorch)、[TensorFlow](https://github.com/huggingface/transformers/tree/main/examples/tensorflow)或[JAX/Flax](https://github.com/huggingface/transformers/tree/main/examples/flax)为任务训练模型。
 
+你还会发现我们在我们的[研究项目](https://github.com/huggingface/transformers/tree/main/examples/research_projects)中使用的脚本和主要是社区贡献的[遗留示例](https://github.com/huggingface/transformers/tree/main/examples/legacy)。这些脚本不是积极维护的，并且需要 🤗 Transformers 的特定版本，这很可能与库的最新版本不兼容。
 
-# Hugging Face 某某页面
+示例脚本并不期望在每个问题上都能即插即用，你可能需要根据你要解决的问题来调整脚本。为了帮助你做到这一点，大多数脚本都完全展示了数据是如何预处理的，允许你根据用例需要进行编辑。
 
-> 译者：[片刻小哥哥](https://github.com/jiangzhonglian)
->
-> 项目地址：<https://huggingface.apachecn.org/docs/transformers/run_scripts>
+对于你想在示例脚本中实现的任何功能，请在提交 Pull Request 之前在[论坛](https://discuss.huggingface.co/)上或在[问题](https://github.com/huggingface/transformers/issues)中讨论。虽然我们欢迎修复错误，但我们不太可能合并添加更多功能但牺牲可读性的 Pull Request。
+
+本指南将展示如何在[PyTorch](https://github.com/huggingface/transformers/tree/main/examples/pytorch/summarization)和[TensorFlow](https://github.com/huggingface/transformers/tree/main/examples/tensorflow/summarization)中运行一个示例摘要训练脚本。除非另有说明，所有示例都应该可以在两个框架上运行。
+
+设置
+
+为了成功运行最新版本的示例脚本，你必须在一个新的虚拟环境中从源代码**安装 🤗 Transformers**
+
+```shell
+git clone https://github.com/huggingface/transformers
+cd transformers
+pip install .
+```
+
+对于旧版本的示例脚本，点击下面的切换按钮：
+旧版本 🤗 Transformers 的示例
+然后，将你当前的 🤗 Transformers 克隆切换到特定版本，例如 v3.5.1：
+
+```shell
+git checkout tags/v3.5.1
+```
+
+在设置了正确的库版本后，导航到你选择的示例文件夹并安装示例特定的要求：
+
+```shell
+pip install -r requirements.txt
+```
+
+**运行脚本**
+
+Pytorch
+
+示例脚本从 🤗 [Datasets](https://huggingface.co/docs/datasets/)库下载并预处理一个数据集。然后，脚本使用[Trainer](https://huggingface.co/docs/transformers/main_classes/trainer)在一个支持摘要的架构上微调数据集。以下示例展示了如何在 [CNN/DailyMail](https://huggingface.co/datasets/cnn_dailymail)数据集上微调[T5-small](https://huggingface.co/google-t5/t5-small)。由于 T5 的训练方式，T5 模型需要额外的 source_prefix 参数。这个提示让 T5 知道这是一个摘要任务。
+
+```shell
+python examples/pytorch/summarization/run_summarization.py \
+    --model_name_or_path google-t5/t5-small \
+    --do_train \
+    --do_eval \
+    --dataset_name cnn_dailymail \
+    --dataset_config "3.0.0" \
+    --source_prefix "summarize: " \
+    --output_dir /tmp/tst-summarization \
+    --per_device_train_batch_size=4 \
+    --per_device_eval_batch_size=4 \
+    --overwrite_output_dir \
+    --predict_with_generate
+```
+
+TensorFlow
+
+示例脚本从 🤗[Datasets](https://huggingface.co/docs/datasets/)库下载并预处理一个数据集。然后，脚本使用 Keras 在一个支持摘要的架构上微调数据集。以下示例展示了如何在[CNN/DailyMail](https://huggingface.co/datasets/cnn_dailymail)数据集上微调[T5-small](https://huggingface.co/google-t5/t5-small)。由于 T5 的训练方式，T5 模型需要额外的 source_prefix 参数。这个提示让 T5 知道这是一个摘要任务。
+
+```shell
+python examples/tensorflow/summarization/run_summarization.py  \
+    --model_name_or_path google-t5/t5-small \
+    --dataset_name cnn_dailymail \
+    --dataset_config "3.0.0" \
+    --output_dir /tmp/tst-summarization  \
+    --per_device_train_batch_size 8 \
+    --per_device_eval_batch_size 16 \
+    --num_train_epochs 3 \
+    --do_train \
+    --do_eval
+```
+
+**分布式训练和混合精度**
+
+Trainer 支持分布式训练和混合精度，这意味着你也可以在脚本中使用它。要启用这两个功能：
+
+* 添加 fp16 参数以启用混合精度。
+* 使用 nproc_per_node 参数设置要使用的 GPU 数量。
+
+```shell
+torchrun \
+    --nproc_per_node 8 pytorch/summarization/run_summarization.py \
+    --fp16 \
+    --model_name_or_path google-t5/t5-small \
+    --do_train \
+    --do_eval \
+    --dataset_name cnn_dailymail \
+    --dataset_config "3.0.0" \
+    --source_prefix "summarize: " \
+    --output_dir /tmp/tst-summarization \
+    --per_device_train_batch_size=4 \
+    --per_device_eval_batch_size=4 \
+    --overwrite_output_dir \
+    --predict_with_generate
+```
+
+TensorFlow 脚本利用[MirroredStrategy](https://www.tensorflow.org/guide/distributed_training#mirroredstrategy)进行分布式训练，你不需要向训练脚本添加任何额外的参数。如果多个 GPU 可用，TensorFlow 脚本将默认使用它们。
+
+**在 TPU 上运行脚本**
+
+Pytorch
+
+张量处理单元 (TPUs) 是专门为加速性能而设计的。PyTorch 通过[XLA](https://www.tensorflow.org/xla)深度学习编译器支持 TPU（在[这里](https://github.com/pytorch/xla/blob/master/README.md)查看更多详细信息）。要使用 TPU，启动 xla_spawn.py 脚本并使用 num_cores 参数设置你想使用的 TPU 核心数。
+
+```shell
+python xla_spawn.py --num_cores 8 \
+    summarization/run_summarization.py \
+    --model_name_or_path google-t5/t5-small \
+    --do_train \
+    --do_eval \
+    --dataset_name cnn_dailymail \
+    --dataset_config "3.0.0" \
+    --source_prefix "summarize: " \
+    --output_dir /tmp/tst-summarization \
+    --per_device_train_batch_size=4 \
+    --per_device_eval_batch_size=4 \
+    --overwrite_output_dir \
+    --predict_with_generate
+```
+
+TensorFlow
+
+张量处理单元 (TPUs) 是专门为加速性能而设计的。TensorFlow 脚本利用 [TPUStrategy](https://www.tensorflow.org/guide/distributed_training#tpustrategy)在 TPU 上进行训练。要使用 TPU，将 TPU 资源的名称传递给 tpu 参数。
+
+```shell
+python run_summarization.py  \
+    --tpu name_of_tpu_resource \
+    --model_name_or_path google-t5/t5-small \
+    --dataset_name cnn_dailymail \
+    --dataset_config "3.0.0" \
+    --output_dir /tmp/tst-summarization  \
+    --per_device_train_batch_size 8 \
+    --per_device_eval_batch_size 16 \
+    --num_train_epochs 3 \
+    --do_train \
+    --do_eval
+```
+
+**使用 🤗 Accelerate 运行脚本**
+
+🤗 [Accelerate](https://huggingface.co/docs/accelerate)是一个仅限 PyTorch 的库，它提供了一种统一的方法来在几种类型的设置上训练模型（仅限 CPU、多个 GPU、TPU），同时保持对 PyTorch 训练循环的完全可见性。如果你还没有安装 🤗 Accelerate，请确保安装了它：
+
+>注意：由于 Accelerate 正在快速发展，必须安装加速的 git 版本才能运行脚本
 >
-> 原始地址：<https://huggingface.co/docs/transformers/run_scripts>
+>```shell
+>pip install git+https://github.com/huggingface/accelerate
+>```
+
+你需要使用 run_summarization_no_trainer.py 脚本，而不是 run_summarization.py 脚本。支持 🤗 Accelerate 的脚本会在文件夹中有一个 task_no_trainer.py 文件。首先运行以下命令来创建并保存配置文件：
+
+```shell
+accelerate config
+```
+
+测试你的设置以确保其配置正确：
 
-开始写原始页面的翻译内容
+```shell
+accelerate test
+```
+
+现在你已经准备好启动训练了：
+
+```shell
+accelerate launch run_summarization_no_trainer.py \
+    --model_name_or_path google-t5/t5-small \
+    --dataset_name cnn_dailymail \
+    --dataset_config "3.0.0" \
+    --source_prefix "summarize: " \
+    --output_dir ~/tmp/tst-summarization
+```
+
+**使用自定义数据集**
+
+只要数据集是 CSV 或 JSON Line 文件，摘要脚本就支持自定义数据集。当你使用自己的数据集时，你需要指定几个额外的参数：
+
+* train_file 和 validation_file 指定你的训练和验证文件的路径。
+* text_column 是要总结的输入文本。
+* summary_column 是要输出的目标文本。
+
+使用自定义数据集的摘要脚本将如下所示：
 
+```shell
+python examples/pytorch/summarization/run_summarization.py \
+    --model_name_or_path google-t5/t5-small \
+    --do_train \
+    --do_eval \
+    --train_file path_to_csv_or_jsonlines_file \
+    --validation_file path_to_csv_or_jsonlines_file \
+    --text_column text_column_name \
+    --summary_column summary_column_name \
+    --source_prefix "summarize: " \
+    --output_dir /tmp/tst-summarization \
+    --overwrite_output_dir \
+    --per_device_train_batch_size=4 \
+    --per_device_eval_batch_size=4 \
+    --predict_with_generate
+```
+
+**测试脚本**
 
+在提交可能需要数小时才能完成的整个数据集之前，通常最好在较少的数据集示例上运行你的脚本以确保一切按预期工作。使用以下参数将数据集截断到最大样本数：
 
-注意事项: 
+* max_train_samples
+* max_eval_samples
+* max_predict_samples
 
-1. 代码参考:
+```shell
+python examples/pytorch/summarization/run_summarization.py \
+    --model_name_or_path google-t5/t5-small \
+    --max_train_samples 50 \
+    --max_eval_samples 50 \
+    --max_predict_samples 50 \
+    --do_train \
+    --do_eval \
+    --dataset_name cnn_dailymail \
+    --dataset_config "3.0.0" \
+    --source_prefix "summarize: " \
+    --output_dir /tmp/tst-summarization \
+    --per_device_train_batch_size=4 \
+    --per_device_eval_batch_size=4 \
+    --overwrite_output_dir \
+    --predict_with_generate
+```
 
-```py
-import torch
+并非所有示例脚本都支持 max_predict_samples 参数。如果你不确定你的脚本是否支持此参数，添加 -h 参数以检查：
 
-x = torch.ones(5)  # input tensor
-y = torch.zeros(3)  # expected output
-w = torch.randn(5, 3, requires_grad=True)
-b = torch.randn(3, requires_grad=True)
-z = torch.matmul(x, w)+b
-loss = torch.nn.functional.binary_cross_entropy_with_logits(z, y)
+```shell
+examples/pytorch/summarization/run_summarization.py -h
 ```
 
-2. 公式参考:
+**从检查点恢复训练**
+
+另一个有用的选项是能够从前一个检查点恢复训练。这将确保如果你的训练被中断，你可以从中断的地方继续，而不必重新开始。有两种方法可以从检查点恢复训练。
+第一种方法是使用 output_dir previous_output_dir 参数从前一个检查点恢复训练，该检查点存储在 output_dir 中。在这种情况下，你应该移除 overwrite_output_dir：
 
-1) 无需换行的写法: 
+```shell
+python examples/pytorch/summarization/run_summarization.py
+    --model_name_or_path google-t5/t5-small \
+    --do_train \
+    --do_eval \
+    --dataset_name cnn_dailymail \
+    --dataset_config "3.0.0" \
+    --source_prefix "summarize: " \
+    --output_dir /tmp/tst-summarization \
+    --per_device_train_batch_size=4 \
+    --per_device_eval_batch_size=4 \
+    --output_dir previous_output_dir \
+    --predict_with_generate
+```
+
+第二种方法是使用 resume_from_checkpoint path_to_specific_checkpoint 参数从特定检查点文件夹恢复训练。
 
-$\sqrt{w^T*w}$
+```shell
+python examples/pytorch/summarization/run_summarization.py
+    --model_name_or_path google-t5/t5-small \
+    --do_train \
+    --do_eval \
+    --dataset_name cnn_dailymail \
+    --dataset_config "3.0.0" \
+    --source_prefix "summarize: " \
+    --output_dir /tmp/tst-summarization \
+    --per_device_train_batch_size=4 \
+    --per_device_eval_batch_size=4 \
+    --overwrite_output_dir \
+    --resume_from_checkpoint path_to_specific_checkpoint \
+    --predict_with_generate
+```
 
-2) 需要换行的写法：
+**分享你的模型**
 
-$$
-\sqrt{w^T*w}
-$$
+所有脚本都可以将你的最终模型上传到[Model Hub](https://huggingface.co/models)。在开始之前，请确保你已经登录 Hugging Face：
 
-3. 图片参考(用图片的实际地址就行):
+```shell
+huggingface-cli login
+```
 
-<img src='http://data.apachecn.org/img/logo/logo_green.png' width=20% />
+然后在脚本中添加 push_to_hub 参数。此参数将使用你的 Hugging Face 用户名和 output_dir 中指定的文件夹名称创建一个仓库。
+要为你的仓库指定一个具体名称，请使用 push_to_hub_model_id 参数添加它。该仓库将自动列在你的命名空间下。
+以下示例展示了如何上传具有特定仓库名称的模型：
 
-4. **翻译完后请删除上面所有模版内容就行**
\ No newline at end of file
+```shell
+python examples/pytorch/summarization/run_summarization.py
+    --model_name_or_path google-t5/t5-small \
+    --do_train \
+    --do_eval \
+    --dataset_name cnn_dailymail \
+    --dataset_config "3.0.0" \
+    --source_prefix "summarize: " \
+    --push_to_hub \
+    --push_to_hub_model_id finetuned-t5-cnn_dailymail \
+    --output_dir /tmp/tst-summarization \
+    --per_device_train_batch_size=4 \
+    --per_device_eval_batch_size=4 \
+    --overwrite_output_dir \
+    --predict_with_generate
+```
\ No newline at end of file
diff --git a/docs/docs/transformers/training.md b/docs/docs/transformers/training.md
index b1f76b0..7aadab6 100755
--- a/docs/docs/transformers/training.md
+++ b/docs/docs/transformers/training.md
@@ -1,53 +1,363 @@
-> 翻译任务
+# 微调预训练模型
 
-* 目前该页面无人翻译，期待你的加入
-* 翻译奖励: <https://github.com/orgs/apachecn/discussions/243>
-* 任务认领: <https://github.com/apachecn/huggingface-doc-zh/discussions/1>
-
-请参考这个模版来写内容:
-
-
-# Hugging Face 某某页面
-
-> 译者：[片刻小哥哥](https://github.com/jiangzhonglian)
+> 译者：[BrightLi](https://github.com/brightli)
 >
 > 项目地址：<https://huggingface.apachecn.org/docs/transformers/training>
 >
 > 原始地址：<https://huggingface.co/docs/transformers/training>
 
-开始写原始页面的翻译内容
+使用预训练模型有显著的好处。它可以降低计算成本、减少碳足迹，并允许您在无需从头开始训练的情况下使用最先进的模型。🤗 Transformers 提供了数千个针对广泛任务的预训练模型。当您使用预训练模型时，您会针对特定于您的任务的数据集对其进行训练。这被称为微调，是一种极其强大的训练技术。在本教程中，您将使用您选择的深度学习框架微调一个预训练模型：
+
+* 使用 🤗 Transformers Trainer 微调预训练模型。
+* 在 TensorFlow 中使用 Keras 微调预训练模型。
+* 在原生 PyTorch 中微调预训练模型。
+
+**准备数据集**
+
+<iframe width="509" height="320" src="https://www.youtube.com/embed/_BZearw7f0w" title="Hugging Face Datasets overview (Pytorch)" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>
+
+在您能够微调预训练模型之前，需要下载一个数据集并为其训练做好准备。之前的教程向您展示了如何处理训练数据，现在您有机会将这些技能付诸实践！
+首先，加载[Yelp Reviews](https://huggingface.co/datasets/yelp_review_full)数据集：
+
+```py
+>>> from datasets import load_dataset
+
+>>> dataset = load_dataset("yelp_review_full")
+>>> dataset["train"][100]
+{'label': 0,
+ 'text': 'My expectations for McDonalds are t rarely high. But for one to still fail so spectacularly...that takes something special!\\nThe cashier took my friends\'s order, then promptly ignored me. I had to force myself in front of a cashier who opened his register to wait on the person BEHIND me. I waited over five minutes for a gigantic order that included precisely one kid\'s meal. After watching two people who ordered after me be handed their food, I asked where mine was. The manager started yelling at the cashiers for \\"serving off their orders\\" when they didn\'t have their food. But neither cashier was anywhere near those controls, and the manager was the one serving food to customers and clearing the boards.\\nThe manager was rude when giving me my order. She didn\'t make sure that I had everything ON MY RECEIPT, and never even had the decency to apologize that I felt I was getting poor service.\\nI\'ve eaten at various McDonalds restaurants for over 30 years. I\'ve worked at more than one location. I expect bad days, bad moods, and the occasional mistake. But I have yet to have a decent experience at this store. It will remain a place I avoid unless someone in my party needs to avoid illness from low blood sugar. Perhaps I should go back to the racially biased service of Steak n Shake instead!'}
+```
+
+正如您现在所知，您需要一个分词器来处理文本，并包括一个填充和截断策略来处理任何可变序列长度。要一步处理您的数据集，请使用 🤗 Datasets 的[map](https://huggingface.co/docs/datasets/process#map)方法在整个数据集上应用预处理函数：
+
+```py
+>>> from transformers import AutoTokenizer
+
+>>> tokenizer = AutoTokenizer.from_pretrained("google-bert/bert-base-cased")
+
+
+>>> def tokenize_function(examples):
+    return tokenizer(examples["text"], padding="max_length", truncation=True)
+
+
+>>> tokenized_datasets = dataset.map(tokenize_function, batched=True)
+```
+
+如果您愿意，可以创建一个完整数据集的较小子集来进行微调，以减少所需时间：
+
+```py
+>>> small_train_dataset = tokenized_datasets["train"].shuffle(seed=42).select(range(1000))
+>>> small_eval_dataset = tokenized_datasets["test"].shuffle(seed=42).select(range(1000))
+```
+
+**训练**
+
+此时，您应该遵循与您想要使用的框架相对应的部分。您可以使用右侧边栏中的链接跳转到您想要的部分 - 如果您想隐藏给定框架的所有内容，只需使用该框架块右上角的按钮！
+
+<iframe width="475" height="320" src="https://www.youtube.com/embed/nvBXf7s7vTI" title="The Trainer API" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>
+
+**用 PyTorch Trainer 训练**
+
+🤗 Transformers 提供了一个针对训练 🤗 Transformers 模型进行优化的[Trainer](https://huggingface.co/docs/transformers/v4.41.3/en/main_classes/trainer#transformers.Trainer)类，使得开始训练变得更加容易，无需手动编写自己的训练循环[Trainer](https://huggingface.co/docs/transformers/v4.41.3/en/main_classes/trainer#transformers.Trainer)API支持广泛的训练选项和功能，如日志记录、梯度累积和混合精度。
+
+首先，加载您的模型并指定预期标签的数量。从 Yelp Review[数据集卡片](https://huggingface.co/datasets/yelp_review_full#data-fields)中，您知道有五个标签：
+
+```py
+>>> from transformers import AutoModelForSequenceClassification
+
+>>> model = AutoModelForSequenceClassification.from_pretrained("google-bert/bert-base-cased", num_labels=5)
+```
+
+> 您会看到一个关于一些预训练权重未被使用和一些权重被随机初始化的警告。别担心，这完全正常！BERT模型的预训练头部被丢弃，并替换为一个随机初始化的分类头部。您将在序列分类任务上微调这个新模型头部，将预训练模型的知识转移到它上面。
+
+**训练超参数**
+
+接下来，创建一个[TrainingArguments](https://huggingface.co/docs/transformers/v4.41.3/en/main_classes/trainer#transformers.TrainingArguments)类，其中包含您可以调整的所有超参数以及激活不同训练选项的标志。在本教程中，您可以从默认的训练[超参数](https://huggingface.co/docs/transformers/main_classes/trainer#transformers.TrainingArguments)开始，但可以自由尝试这些参数以找到您的最佳设置。
+
+指定保存训练期间检查点的位置：
+
+```py
+>>> from transformers import TrainingArguments
+
+>>> training_args = TrainingArguments(output_dir="test_trainer")
+```
+
+**评估**
+
+在训练过程中，[Trainer](https://huggingface.co/docs/transformers/v4.41.3/en/main_classes/trainer#transformers.Trainer)不会自动评估模型性能。你需要向[Trainer](https://huggingface.co/docs/transformers/v4.41.3/en/main_classes/trainer#transformers.Trainer) 传递一个函数来计算和报告指标。🤗 [Evaluate](https://huggingface.co/docs/evaluate/index) 库提供了一个简单的准确性函数，你可以使用 evaluate.load（更多信息请参见此[快速教程](https://huggingface.co/docs/evaluate/a_quick_tour)）函数加载：
+
+```py
+>>> import numpy as np
+>>> import evaluate
+
+>>> metric = evaluate.load("accuracy")
+```
+
+在你的预测上调用 compute 来计算准确性。在将你的预测传递给 compute 之前，你需要将 logits 转换为预测（记住所有 🤗 Transformers 模型都返回 logits）：
+
+```py
+>>> def compute_metrics(eval_pred):
+    logits, labels = eval_pred
+    predictions = np.argmax(logits, axis=-1)
+    return metric.compute(predictions=predictions, references=labels)
+```
+
+如果你想在微调过程中监控你的评估指标，请在训练参数中指定 eval_strategy 参数，以便在每个epoch结束时报告评估指标：
+
+```py
+>>> from transformers import TrainingArguments, Trainer
+
+>>> training_args = TrainingArguments(output_dir="test_trainer", eval_strategy="epoch")
+```
+
+**训练器**
+
+使用你的模型、训练参数、训练和测试数据集以及评估函数创建一个[Trainer](https://huggingface.co/docs/transformers/v4.41.3/en/main_classes/trainer#transformers.Trainer)对象：
+
+```py
+>>> trainer = Trainer(
+    model=model,
+    args=training_args,
+    train_dataset=small_train_dataset,
+    eval_dataset=small_eval_dataset,
+    compute_metrics=compute_metrics,
+)
+```
 
+然后通过调用[train()](https://huggingface.co/docs/transformers/v4.41.3/en/main_classes/trainer#transformers.Trainer.train)来微调你的模型：
 
+```py
+>>> trainer.train()
+```
+
+<iframe width="381" height="320" src="https://www.youtube.com/embed/rnTGBy2ax1c" title="Keras introduction" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>
+
+**用Keras训练TensorFlow模型**
+
+你还可以使用Keras API在TensorFlow中训练 🤗 Transformers 模型！
+
+**为Keras加载数据**
 
-注意事项: 
+当你想用Keras API训练一个 🤗 Transformers 模型时，你需要将你的数据集转换为Keras能理解的格式。如果你的数据集很小，你可以将其全部转换为NumPy数组并传递给Keras。在我们进行更复杂的操作之前，先尝试一下这个方法。
 
-1. 代码参考:
+首先，加载一个数据集。我们将使用来自[GLUE基准测试](https://huggingface.co/datasets/glue)的CoLA数据集，因为它是一个简单二元文本分类任务，现在只采用训练划分。
 
 ```py
-import torch
+from datasets import load_dataset
 
-x = torch.ones(5)  # input tensor
-y = torch.zeros(3)  # expected output
-w = torch.randn(5, 3, requires_grad=True)
-b = torch.randn(3, requires_grad=True)
-z = torch.matmul(x, w)+b
-loss = torch.nn.functional.binary_cross_entropy_with_logits(z, y)
+dataset = load_dataset("glue", "cola")
+dataset = dataset["train"]  # Just take the training split for now
 ```
 
-2. 公式参考:
+接下来，加载一个分词器并将数据分词化为 NumPy 数组。注意，标签已经是0和1的列表，所以我们可以直接将其转换为 NumPy 数组，无需分词！
+
+```py
+from transformers import AutoTokenizer
+import numpy as np
+
+tokenizer = AutoTokenizer.from_pretrained("google-bert/bert-base-cased")
+tokenized_data = tokenizer(dataset["sentence"], return_tensors="np", padding=True)
+# Tokenizer returns a BatchEncoding, but we convert that to a dict for Keras
+tokenized_data = dict(tokenized_data)
+
+labels = np.array(dataset["label"])  # Label is already an array of 0 and 1
+```
+
+最后，加载、[编译](https://keras.io/api/models/model_training_apis/#compile-method)并拟合模型。注意，Transformers 模型都有一个默认的任务相关损失函数，所以你不需要指定一个，除非你想这么做：
+
+```py
+from transformers import TFAutoModelForSequenceClassification
+from tensorflow.keras.optimizers import Adam
+
+# Load and compile our model
+model = TFAutoModelForSequenceClassification.from_pretrained("google-bert/bert-base-cased")
+# Lower learning rates are often better for fine-tuning transformers
+model.compile(optimizer=Adam(3e-5))  # No loss argument!
+
+model.fit(tokenized_data, labels)
+```
+
+> 当你编译模型时，不必向模型传递 loss 参数！如果这个参数留空，Hugging Face 模型会自动选择一个适合其任务和模型架构的损失函数。如果你想的话，你可以通过指定一个损失函数来覆盖这个设置！
+
+这种方法对于较小的数据集效果很好，但对于较大的数据集，你可能会发现它开始成为一个问题。为什么？因为分词数组和标签必须完全加载到内存中，而且由于 NumPy 不处理“锯齿”数组，所以每个分词样本都必须填充到整个数据集中最长样本的长度。这将使你的数组变得更大，而这些填充标记也会减慢训练速度！
+
+**将数据加载为 tf.data.Dataset**
+
+如果你想避免减慢训练速度，你可以将你的数据加载为 tf.data.Dataset。尽管如果你愿意，你可以编写自己的 tf.data 管道，但我们有两个方便的方法来做到这一点：
 
-1) 无需换行的写法: 
+[prepare_tf_dataset()](https://huggingface.co/docs/transformers/v4.41.3/en/main_classes/model#transformers.TFPreTrainedModel.prepare_tf_dataset)：这是我们在大多数情况下推荐的方法。因为它是你模型上的一个方法，它可以检查模型以自动找出哪些列可以用作模型输入，并丢弃其他列以创建更简单、性能更高的数据集。
 
-$\sqrt{w^T*w}$
+to_tf_dataset：这个方法更底层，当你想精确控制如何创建数据集时很有用，通过指定要包含的确切列和标签列。
 
-2) 需要换行的写法：
+在使用[prepare_tf_dataset()](https://huggingface.co/docs/transformers/v4.41.3/en/main_classes/model#transformers.TFPreTrainedModel.prepare_tf_dataset)之前，你需要将分词器的输出作为列添加到你的数据集中，如下所示代码示例：
+
+```py
+def tokenize_dataset(data):
+    # Keys of the returned dictionary will be added to the dataset as columns
+    return tokenizer(data["text"])
+
+
+dataset = dataset.map(tokenize_dataset)
+```
+
+请记住，Hugging Face 数据集默认情况下存储在磁盘上，所以这不会占用你的内存！一旦添加了列，你可以从数据集中流式传输批次，并为每个批次添加填充，与为整个数据集添加填充相比，这极大地减少了填充标记的数量。
+
+```py
+>>> tf_dataset = model.prepare_tf_dataset(dataset["train"], batch_size=16, shuffle=True, tokenizer=tokenizer)
+```
+
+请注意，在上面的代码示例中，你需要将分词器传递给 prepare_tf_dataset，以便它可以在加载时正确地填充批次。如果你的数据集中的样本长度都相同且不需要填充，你可以跳过这个参数。如果你需要做一些比简单的样本填充更复杂的事情（例如为掩码语言建模损坏标记），你可以使用 collate_fn 参数来传递一个函数，该函数将被调用以将样本列表转换为批次并应用任何你想要的预处理。请参阅我们的[示例](https://github.com/huggingface/transformers/tree/main/examples)或[笔记本](https://huggingface.co/docs/transformers/notebooks)以查看此方法的实际运行情况。
+
+一旦你创建了一个 tf.data.Dataset，你就可以像之前一样编译和拟合模型：
+
+```py
+model.compile(optimizer=Adam(3e-5))  # No loss argument!
+
+model.fit(tf_dataset)
+```
+
+**在原生PyTorch中训练**
+
+<iframe width="381" height="320" src="https://www.youtube.com/embed/Dh9CL8fyG80" title="Write your training loop in PyTorch" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>
+
+[Trainer](https://huggingface.co/docs/transformers/v4.41.3/en/main_classes/trainer#transformers.Trainer)负责处理训练循环，并允许你用一行代码微调模型。对于喜欢编写自己的训练循环的用户，你也可以在原生 PyTorch 中微调一个 🤗 Transformers 模型。
+此时，你可能需要重新启动你的笔记本或执行以下代码以释放一些内存：
+
+```py
+del model
+del trainer
+torch.cuda.empty_cache()
+```
+
+接下来，手动对 tokenized_dataset 进行后处理以准备训练。
+
+1.删除文本列，因为模型不接受原始文本作为输入：
+
+```py
+>>> tokenized_datasets = tokenized_datasets.remove_columns(["text"])
+```
+
+2.将标签列重命名为 labels，因为模型期望参数名为 labels：
+
+```py
+>>> tokenized_datasets = tokenized_datasets.rename_column("label", "labels")
+```
+
+3.将数据集的格式设置为返回 PyTorch 张量而不是列表：
+
+```py
+>>> tokenized_datasets.set_format("torch")
+```
+
+然后，如前所示创建一个数据集的较小子集，以加快微调速度：
+
+```py
+>>> small_train_dataset = tokenized_datasets["train"].shuffle(seed=42).select(range(1000))
+>>> small_eval_dataset = tokenized_datasets["test"].shuffle(seed=42).select(range(1000))
+```
+
+**DataLoader**
+
+为你的训练和测试数据集创建一个 DataLoader，以便你可以迭代数据批次：
+
+```py
+>>> from torch.utils.data import DataLoader
+
+>>> train_dataloader = DataLoader(small_train_dataset, shuffle=True, batch_size=8)
+>>> eval_dataloader = DataLoader(small_eval_dataset, batch_size=8)
+```
+
+使用预期标签的数量加载你的模型：
+
+```py
+>>> from transformers import AutoModelForSequenceClassification
+
+>>> model = AutoModelForSequenceClassification.from_pretrained("google-bert/bert-base-cased", num_labels=5)
+```
+
+**优化器和学习率调度器**
+
+创建一个优化器和学习率调度器来微调模型。让我们使用 PyTorch 的[AdamW](https://pytorch.org/docs/stable/generated/torch.optim.AdamW.html)优化器：
+
+```py
+>>> from torch.optim import AdamW
+
+>>> optimizer = AdamW(model.parameters(), lr=5e-5)
+```
+
+创建 Trainer 中的默认学习率调度器：
+
+```py
+>>> from transformers import get_scheduler
+
+>>> num_epochs = 3
+>>> num_training_steps = num_epochs * len(train_dataloader)
+>>> lr_scheduler = get_scheduler(
+    name="linear", optimizer=optimizer, num_warmup_steps=0, num_training_steps=num_training_steps
+)
+```
+
+最后，指定设备以使用 GPU（如果你有访问权限）。否则，在 CPU 上训练可能需要几个小时，而不是几分钟。
+
+```py
+>>> import torch
+
+>>> device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
+>>> model.to(device)
+```
+
+>如果你没有 GPU，可以通过像[Colaboratory](https://colab.research.google.com/)或[SageMaker StudioLab](https://studiolab.sagemaker.aws/)这样的托管笔记本免费获得云 GPU。
+
+太好了，现在你准备好训练了！🥳
+
+**训练循环**
+
+为了跟踪你的训练进度，使用[tqdm](https://tqdm.github.io/)库在训练步骤数上添加一个进度条：
+
+```py
+from tqdm.auto import tqdm
+
+progress_bar = tqdm(range(num_training_steps))
+
+model.train()
+for epoch in range(num_epochs):
+    for batch in train_dataloader:
+        batch = {k: v.to(device) for k, v in batch.items()}
+        outputs = model(**batch)
+        loss = outputs.loss
+        loss.backward()
+
+        optimizer.step()
+        lr_scheduler.step()
+        optimizer.zero_grad()
+        progress_bar.update(1)
+```
+
+**评估**
+
+就像你为[Trainer](https://huggingface.co/docs/transformers/v4.41.3/en/main_classes/trainer#transformers.Trainer)添加了一个评估函数一样，当你编写自己的训练循环时也需要做同样的事情。但是这次不是在每个epoch结束时计算和报告度量，而是使用 add_batch 累积所有批次，并在最后计算度量。
+
+```py
+>>> import evaluate
+
+>>> metric = evaluate.load("accuracy")
+>>> model.eval()
+>>> for batch in eval_dataloader:
+    batch = {k: v.to(device) for k, v in batch.items()}
+    with torch.no_grad():
+        outputs = model(**batch)
+
+    logits = outputs.logits
+    predictions = torch.argmax(logits, dim=-1)
+    metric.add_batch(predictions=predictions, references=batch["labels"])
+
+>>> metric.compute()
+```
 
-$$
-\sqrt{w^T*w}
-$$
+**附加资源**
 
-3. 图片参考(用图片的实际地址就行):
+有关更多微调示例，请参阅：
 
-<img src='http://data.apachecn.org/img/logo/logo_green.png' width=20% />
+🤗 [Transformers Examples](https://github.com/huggingface/transformers/tree/main/examples)包括在 PyTorch 和 TensorFlow 中训练常见 NLP 任务的脚本。
 
-4. **翻译完后请删除上面所有模版内容就行**
\ No newline at end of file
+🤗 [Transformers Notebooks](https://huggingface.co/docs/transformers/notebooks)包含各种笔记本，介绍如何在 PyTorch 和 TensorFlow 中为特定任务微调模型。
\ No newline at end of file