GPT-J-6B: A 6 Billion Parameter Autoregressive Language Model
" -examples = [ - ["The tower is 324 metres (1,063 ft) tall,"], - ["The Moon's orbit around Earth has"], - ["The smooth Borealis basin in the Northern Hemisphere covers 40%"], -] + gr.Interface.load( "huggingface/EleutherAI/gpt-j-6B", inputs=gr.Textbox(lines=5, label="Input Text"), title=title, description=description, article=article, - examples=examples, - enable_queue=True, ).launch() ``` diff --git a/chapters/en/chapter9/7.mdx b/chapters/en/chapter9/7.mdx index 3c74d8452..fce4f80fb 100644 --- a/chapters/en/chapter9/7.mdx +++ b/chapters/en/chapter9/7.mdx @@ -231,6 +231,6 @@ with gr.Blocks() as block: block.launch() ``` - + We just explored all the core concepts of `Blocks`! Just like with `Interfaces`, you can create cool demos that can be shared by using `share=True` in the `launch()` method or deployed on [Hugging Face Spaces](https://huggingface.co/spaces). \ No newline at end of file diff --git a/chapters/en/events/3.mdx b/chapters/en/events/3.mdx index b0770d38d..d74b9c206 100644 --- a/chapters/en/events/3.mdx +++ b/chapters/en/events/3.mdx @@ -6,4 +6,4 @@ You can find all the demos that the community created under the [`Gradio-Blocks` **Natural language to SQL** - + diff --git a/chapters/it/chapter2/2.mdx b/chapters/it/chapter2/2.mdx index 5260f62c4..1471eb014 100644 --- a/chapters/it/chapter2/2.mdx +++ b/chapters/it/chapter2/2.mdx @@ -257,7 +257,7 @@ outputs = model(inputs) ``` {/if} -Ora, se osserviamo la forma dei nostri input, la dimensionalità sarà molto più bassa: la model head prende in input i vettori ad alta dimensionalità che abbiamo visto prima e produce vettori contenenti due valori (uno per etichetta): +Ora, se osserviamo la forma dei nostri output, la dimensionalità sarà molto più bassa: la model head prende in input i vettori ad alta dimensionalità che abbiamo visto prima e produce vettori contenenti due valori (uno per etichetta): ```python print(outputs.logits.shape) diff --git a/chapters/ko/chapter2/8.mdx b/chapters/ko/chapter2/8.mdx index ddc6f4558..49a23d412 100644 --- a/chapters/ko/chapter2/8.mdx +++ b/chapters/ko/chapter2/8.mdx @@ -88,16 +88,16 @@
+
+Обратите внимание, что на форуме также доступен список [идей для проектов](https://discuss.huggingface.co/c/course/course-event/25), если вы хотите применить полученные знания на практике после прохождения курса.
+
+- **Где я могу посмотреть на код, используемый в этом курсе?**
+Внутри каждого раздела наверху страницы есть баннер, который позволит запустить код в Google Colab или Amazon SageMaker Studio Lab:
+
+
+
+Блокноты Jupyter со всем кодом, используемом в материалах курса, доступны в репозитории [`huggingface/notebooks`](https://github.com/huggingface/notebooks). Если вы хотите сгенерировать их на своем компьютере, вы можете найти инструкцию в репозитории [`course`](https://github.com/huggingface/course#-jupyter-notebooks) на GitHub.
+
+- **Как я могу внести свой вклад в развитие курса?**
+Существует множество способов внести свой вклад в наш курс! Если вы найдете опечатку или баг, пожалуйста, откройте вопрос (issue) в репозитории [`course`](https://github.com/huggingface/course). Если вы хотите помочь с переводом на ваш родной язык, вы можете найти инструкцию [здесь](https://github.com/huggingface/course#translating-the-course-into-your-language).
+
+- **Какие стандарты использовались при переводе?**
+Каждый перевод содержит глоссарий и файл `TRANSLATING.txt`, в которых описаны стандарты, используемые для перевода терминов и т.д. Вы можете посмотреть на пример для немецкого языка [здесь](https://github.com/huggingface/course/blob/main/chapters/de/TRANSLATING.txt).
+
+- **Могу ли я использовать этот курс в своих целях?**
+Конечно! Этот курс распространяется по либеральной лицензии [Apache 2 license](https://www.apache.org/licenses/LICENSE-2.0.html). Это означает, что вы должны упомянуть создателей этого курса, предоставить ссылку на лицензию и обозначить все изменения. Все это может быть сделано любым приемлемым способов, который, однако, не подразумевает, что правообладатель поддерживает вас или ваши действия по отношению этого курса. Если вы хотите процитировать этот курс, пожалуйста, используйте следующий BibTex:
+
+```
+@misc{huggingfacecourse,
+ author = {Hugging Face},
+ title = {The Hugging Face Course, 2022},
+ howpublished = "\url{https://huggingface.co/course}",
+ year = {2022},
+ note = "[Online; accessed text-generation.",
+ },
+ {
+ text: "Пайплайн вернет слова, обозначающие персон, организаций или географических локаций.",
+ explain: "Кроме того, с аргументом grouped_entities=True, пайплайн сгруппирует слова, принадлежащие одной и той же сущности, например, \"Hugging Face\".",
+ correct: true
+ }
+ ]}
+/>
+
+### 3. Чем нужно заменить ... в данном коде?
+
+```py
+from transformers import pipeline
+
+filler = pipeline("fill-mask", model="bert-base-cased")
+result = filler("...")
+```
+
+bert-base-cased и попробуйте найти, где вы ошиблись."
+ },
+ {
+ text: "This [MASK] has been waiting for you.",
+ explain: "Верно! Токен-маска для этой модели - [MASK].",
+ correct: true
+ },
+ {
+ text: "This man has been waiting for you.",
+ explain: "Неверно. Этот пайплайн предсказывает замаскированный токен, а для этого нужно предоставить токен-маску."
+ }
+ ]}
+/>
+
+### 4. Почему этот код выдаст ошибку?
+
+```py
+from transformers import pipeline
+
+classifier = pipeline("zero-shot-classification")
+result = classifier("This is a course about the Transformers library")
+```
+
+
@@ -52,7 +52,7 @@
-Другой пример - *максированная языковая модель*, которая предсказывает замаскированное слово в предложении.
+Другой пример - *маскированная языковая модель (англ. masked language modeling)*, которая предсказывает замаскированное слово в предложении.
@@ -76,17 +76,19 @@
@@ -95,22 +97,22 @@
Предобучение обычно происходит на огромных наборах данных, сам процесс может занять несколько недель.
-*Fine-tuning*, с другой стороны, это обучение, проведенной *после* того, как модель была предобучена. Для проведения fine-tuning вы сначала должны выбрать предобученную языковую модель, а после провести обучение на данных собственной задачи. Стойте -- почему не обучить модель сразу же на данных конкретной задачи? Этому есть несколько причин:
+*Дообучение (англ. fine-tuning)*, с другой стороны, это обучение *после* того, как модель была предобучена. Для дообучения вы сначала должны выбрать предобученную языковую модель, а после продолжить ее обучение ее на данных собственной задачи. Стойте -- почему не обучить модель сразу же на данных конкретной задачи? Этому есть несколько причин:
-* Предобученная модель уже обучена на датасете, который имеет много сходств с датасетом для fine-tuning. Процесс тонкой настройки может использовать знания, которые были получены моделью в процессе предобучения (например, в задачах NLP предварительно обученная модель будет иметь представление о статистических закономерностях языка, который вы используете в своей задаче).
+* Предобученная модель уже обучена на датасете, который имеет много сходств с датасетом для дообучения. Процесс дообучения может использовать знания, которые были получены моделью в процессе предобучения (например, в задачах NLP предварительно обученная модель будет иметь представление о статистических закономерностях языка, который вы используете в своей задаче).
-* Так как предобученная модель уже "видела" много данных, процесс тонкой настройки требует меньшего количества данных для получения приемлемых результатов.
+* Так как предобученная модель уже "видела" много данных, процесс дообучения требует меньшего количества данных для получения приемлемых результатов.
* По этой же причине требуется и намного меньше времени для получения хороших результатов.
-Например, можно использовать предварительно обученную на английском языке модель, а затем провести ее fine-tuning на корпусе arXiv, в результате чего получится научно-исследовательская модель. Для тонкой настройки потребуется лишь ограниченный объем данных: знания, которые приобрела предварительно обученная модель, «передаются» (осуществляют трансфер), отсюда и термин «трансферное обучение».
+Например, можно использовать предварительно обученную на английском языке модель, а затем дообучить ее на корпусе arXiv, в результате чего получится научно-исследовательская модель. Для дообучения потребуется лишь ограниченный объем данных: знания, которые приобрела предварительно обученная модель, «передаются» (осуществляют трансфер), отсюда и термин «трансферное обучение».
@@ -134,45 +136,45 @@
Каждая из этих частей может быть использована отдельно, это зависит от задачи:
-* **Encoder-модели**: полезны для задач, требющих понимания входных данных, таких как классификация предложений и распознавание именованных сущностей.
-* **Decoder-модели**: полезны для генеративных задач, таких как генерация текста.
-* **Encoder-decoder модели** или **seq2seq-модели**: полезны в генеративных задачах, требущих входных данных. Например: перевод или саммаризация текста.
+* **Модели-кодировщики**: полезны для задач, требующих понимания входных данных, таких как классификация предложений и распознавание именованных сущностей.
+* **Модели-декодировщики**: полезны для генеративных задач, таких как генерация текста.
+* **Модели типа "кодировщик-декодировщик"** или **seq2seq-модели**: полезны в генеративных задачах, требующих входных данных. Например: перевод или автоматическое реферирование текста.
-Мы изучим эти архитектуры глубже в следующих разделах.
+Мы изучим эти архитектуры подробнее в следующих разделах.
-## Слой внимания или attention
+## Слой внимания
-Ключевой особенностью трансформеров является наличие в архитектуре специального слоя, называемого слоем внимания или attention'ом. Статья, в которой была описана архитектура трансформера, называлась["Attention Is All You Need"](https://arxiv.org/abs/1706.03762) ("Внимание - все, что вам нужно")! Мы изучим детали этого слоя позже. На текущий момент мы сформулируем механизм его работы так: attention-слой помогает модели "обращать внимание" на одни слова в поданном на вход предложении, а другие слова в той или иной степени игнорировать. И это происходит в процессе анализа каждого слова.
+Ключевой особенностью трансформеров является наличие в архитектуре специального слоя, называемого *слоем внимания (англ. attention layer)*. Статья, в которой была впервые представлена архитектура трансформера, называется ["Attention Is All You Need"](https://arxiv.org/abs/1706.03762) ("Внимание - все, что вам нужно")! Мы изучим детали этого слоя позже. На текущий момент мы сформулируем механизм его работы так: слой внимания помогает модели "обращать внимание" на одни слова в поданном на вход предложении, а другие слова в той или иной степени игнорировать. И это происходит в процессе анализа каждого слова.
Чтобы поместить это в контекст, рассмотрим задачу перевода текста с английского на французский язык. Для предложения "You like this course", модель должна будет также учитывать соседнее слово "You", чтобы получить правильный перевод слова "like", потому что во французском языке глагол "like" спрягается по-разному в зависимости от подлежащего. Однако остальная часть предложения бесполезна для перевода этого слова. В том же духе при переводе "like" также необходимо будет обратить внимание на слово "course", потому что "this" переводится по-разному в зависимости от того, стоит ли ассоциированное существительное в мужском или женском роде. Опять же, другие слова в предложении не будут иметь значения для перевода "this". С более сложными предложениями (и более сложными грамматическими правилами) модели потребуется уделять особое внимание словам, которые могут оказаться дальше в предложении, чтобы правильно перевести каждое слово.
-Такая же концепция применима к любой задаче, связанной с обработкой естесственного языка: слово само по себе имеет некоторое значение, однако значение очень часто зависит от контекста, которым может являться слово (или слова), стоящие вокруг искомого слова.
+Такая же концепция применима к любой задаче, связанной с обработкой естественного языка: слово само по себе имеет некоторое значение, однако значение очень часто зависит от контекста, которым может являться слово (или слова), стоящие вокруг искомого слова.
-Теперь, когда вы знакомы с идеей attention в целом, посмотрим поближе на архитектуру всего трансформера.
+Теперь, когда вы знакомы с идеей внимания в целом, посмотрим поближе на архитектуру всего трансформера.
## Первоначальная архитектура
-Архитектура трансформера изначально была разработана для перевода. Во время обучения энкодер получает входные данные (предложения) на определенном языке, а декодер получает те же предложения на желаемом целевом языке. В энкодере слои внимания могут использовать все слова в предложении (поскольку, как мы только что видели, перевод данного слова может зависеть от того, что в предложении находится после и перед ним). Декодер, в свою очерель, работает последовательно и может обращать внимание только на слова в предложении, которые он уже перевел (то есть только на слова перед генерируемым в данный момент словом). Например, когда мы предсказали первые три слова переведенной цели, мы передаем их декодеру, который затем использует все входные данные энкодера, чтобы попытаться предсказать четвертое слово.
+Архитектура трансформера изначально была разработана для перевода. Во время обучения кодировщик получает входные данные (предложения) на определенном языке, а декодировщик получает те же предложения на желаемом целевом языке. В кодировщике слои внимания могут использовать все слова в предложении (поскольку, как мы только что видели, перевод данного слова может зависеть от того, что в предложении находится после и перед ним). Декодировщик, в свою очередь, работает последовательно и может обращать внимание только на слова в предложении, которые он уже перевел (то есть только на слова перед генерируемым в данный момент словом). Например, когда мы предсказали первые три слова переведенной цели, мы передаем их декодировщику, который затем использует все входные данные кодировщика, чтобы попытаться предсказать четвертое слово.
-Чтобы ускорить процесс во время обучения (когда модель имеет доступ к целевым предложениям), декодер получает целевое предложение полностью, но ему не разрешается использовать будущие слова (если он имел доступ к слову в позиции 2 при попытке предсказать слово на позиции 2, задача не будет сложной!). Например, при попытке предсказать четвертое слово уровень внимания будет иметь доступ только к словам в позициях с 1 по 3.
+Чтобы ускорить процесс во время обучения (когда модель имеет доступ к целевым предложениям), декодировщик получает целевое предложение полностью, но ему не разрешается использовать будущие слова (если он имел доступ к слову в позиции 2 при попытке предсказать слово на позиции 2, задача не будет сложной!). Например, при попытке предсказать четвертое слово слой внимания будет иметь доступ только к словам в позициях с 1 по 3.
-Первоначальная архитектура Transformer выглядела так: энкодер слева и декодер справа:
+Первоначальная архитектура Transformer выглядела так: кодировщик слева и декодировщик справа:
+
+请注意，如果您想在完成课程后进行更多练习，论坛上还提供了[项目灵感](https://discuss.huggingface.co/c/course/course-event/25) 列表。
+
+- **我在哪里可以获得课程的代码？**
+对于每个部分，单击页面顶部的横幅可以在 Google Colab 或 Amazon SageMaker Studio Lab 中运行代码：
+
+
+
+包含课程所有代码的 Jupyter 笔记本托管在 [`huggingface/notebooks`](https://github.com/huggingface/notebooks) 仓库中。 如果您希望在本地生成它们，请查看 GitHub 上 [`course`](https://github.com/huggingface/course#-jupyter-notebooks) 仓库中的说明。
+
+
+- **我如何为课程做出贡献？**
+有很多方法可以为课程做出贡献！ 如果您发现拼写错误或错误，请在 [`course`](https://github.com/huggingface/course) 仓库中提出问题。 如果您想帮助将课程翻译成您的母语，请在[此处](https://github.com/huggingface/course#translating-the-course-into-your-language) 查看说明。
+
+- ** 每个翻译的选择是什么？**
+每个翻译都有一个词汇表和“TRANSLATING.txt”文件，其中详细说明了为机器学习术语等所做的选择。您可以在 [此处](https://github.com/huggingface/course/blob/main/chapters/de/TRANSLATING.txt)。
+
+
+- **我可以使用这门课程再次进行创作吗？**
+当然！ 该课程是根据宽松的 [Apache 2 许可证](https://www.apache.org/licenses/LICENSE-2.0.html) 发布的。 这意味着您必须按照诚信的原则，提供许可证的链接，并指出是否进行了更改。您可以以任何合理的方式这样做，但不能以任何表明许可方认可您或您的使用的方式。 如果您想引用该课程，请使用以下 BibTeX：
+
+```
+@misc{huggingfacecourse,
+ author = {Hugging Face},
+ title = {The Hugging Face Course, 2022},
+ howpublished = "\url{https://huggingface.co/course}",
+ year = {2022},
+ note = "[Online; accessed 
-
-
-
-从这里，任何人都可以通过简单地提供来下载数据集 **load_dataset()** 以存储库 ID 作为 **path** 争论：
+之后，任何人都可以通过便捷地提供带有存储库 ID 作为 path 参数的 load_dataset() 来下载数据集：
```py
remote_dataset = load_dataset("lewtun/github-issues", split="train")
@@ -427,7 +364,7 @@ Dataset({
-## 创建数据集卡片
+## 创建数据集卡片 [[创建数据集卡片]]
有据可查的数据集更有可能对其他人（包括你未来的自己！）有用，因为它们提供了上下文，使用户能够决定数据集是否与他们的任务相关，并评估任何潜在的偏见或与使用相关的风险。在 Hugging Face Hub 上，此信息存储在每个数据集存储库的自述文件文件。在创建此文件之前，您应该执行两个主要步骤：
diff --git a/chapters/zh-CN/chapter5/6.mdx b/chapters/zh-CN/chapter5/6.mdx
index 429881676..8de5fb335 100644
--- a/chapters/zh-CN/chapter5/6.mdx
+++ b/chapters/zh-CN/chapter5/6.mdx
@@ -1,6 +1,6 @@
-
@@ -42,7 +41,7 @@
您可以[在这里](https://huggingface.co/huggingface-course/bert-finetuned-ner?text=My+name+is+Sylvain+and+I+work+at+Hugging+Face+in+Brooklyn).找到我们将训练并上传到 Hub的模型，可以尝试输入一些句子看看模型的预测结果。
-## 准备数据
+## 准备数据 [[准备数据]]
首先，我们需要一个适合标记分类的数据集。在本节中，我们将使用[CoNLL-2003 数据集](https://huggingface.co/datasets/conll2003), 其中包含来自路透社的新闻报道。
@@ -52,7 +51,7 @@
-### CoNLL-2003 数据集
+### CoNLL-2003 数据集 [[CoNLL-2003 数据集]]
要加载 CoNLL-2003 数据集，我们使用 来自 🤗 Datasets 库的**load_dataset()** 方法：
@@ -174,7 +173,7 @@ print(line2)
-### 处理数据
+### 处理数据 [[处理数据]]
@@ -45,16 +44,16 @@
与前面的部分一样，您可以使用以下代码找到我们将训练并上传到 Hub 的实际模型，并[在这里](https://huggingface.co/huggingface-course/marian-finetuned-kde4-en-to-fr?text=This+plugin+allows+you+to+automatically+translate+web+pages+between+several+languages.)查看模型输出的结果
-## 准备数据
+## 准备数据 [[准备数据]]
为了从头开始微调或训练翻译模型，我们需要一个适合该任务的数据集。如前所述，我们将使用[KDE4 数据集](https://huggingface.co/datasets/kde4)在本节中，但您可以很容易地调整代码以使用您自己的数据，只要您有要互译的两种语言的句子对。如果您需要复习如何将自定义数据加载到 **Dataset** 可以复习一下[第五章](/course/chapter5).
-### KDE4 数据集
+### KDE4 数据集 [[KDE4 数据集]]
像往常一样，我们使用 **load_dataset()** 函数：
```py
-from datasets import load_dataset, load_metric
+from datasets import load_dataset
raw_datasets = load_dataset("kde4", lang1="en", lang2="fr")
```
@@ -162,7 +161,7 @@ translator(
-### 处理数据
+### 处理数据 [[处理数据]]
@@ -52,7 +52,7 @@ gr.Interface(
-### 使用临时链接分享您的演示
+### 使用临时链接分享您的演示 [[使用临时链接分享您的演示]]
现在我们已经有了机器学习模型的工作演示，让我们学习如何轻松共享指向我们界面的链接。
通过在 `launch()` 方法中设置 `share=True` 可以轻松地公开共享接口：
@@ -64,7 +64,7 @@ gr.Interface(classify_image, "image", "label").launch(share=True)
但是请记住，这些链接是可公开访问的，这意味着任何人都可以使用您的模型进行预测！ 因此，请确保不要通过您编写的函数公开任何敏感信息，或允许在您的设备上发生任何关键更改。 如果设置 `share=False`（默认值），则仅创建本地链接。
-### 在 Hugging Face Spaces 上托管您的演示
+### 在 Hugging Face Spaces 上托管您的演示 [[在 Hugging Face Spaces 上托管您的演示]]
可以传递给同事的共享链接很酷，但是如何永久托管您的演示并让它存在于互联网上自己的“空间”中？
@@ -74,7 +74,7 @@ Hugging Face Spaces 提供了在互联网上永久托管 Gradio 模型的基础
-這會安裝一個非常輕量的🤗 Transformers。裡面沒有安裝任何像是PyTorch或TensorFlow等的機器學習框架。因為我們會用到很多函式庫裡的不同功能，所以我們建議安裝包含了大部分使用情境所需資源的開發用版本：
+這會安裝一個非常輕量的 🤗 Transformers。裡面沒有安裝任何像是 PyTorch 或 TensorFlow 等的機器學習框架。因為我們會用到很多函式庫裡的不同功能，所以我們建議安裝包含了大部分使用情境所需資源的開發用版本：
```
@@ -50,16 +50,16 @@ import transformers
## 使用Python虛擬環境
-如果你比較想用Python虛擬環境的話，第一步就是安裝Python。我們建議跟著[這篇教學](https://realpython.com/installing-python/)做為起手式。
+如果你比較想用 Python 虛擬環境的話，第一步就是安裝 Python。我們建議跟著[這篇教學](https://realpython.com/installing-python/)做為起手式。
-當你安裝好Python後，你應該就能從終端機執行Python指令了。在進行下一步之前你可以先執行以下指令來確認Python有沒有安裝好：`python --version` 這條指令會讓終端機顯示你所安裝的Python版本。
+當你安裝好 Python 後，你應該就能從終端機執行 Python 指令了。在進行下一步之前你可以先執行以下指令來確認 Python 有沒有安裝好：`python --version` 這條指令會讓終端機顯示你所安裝的 Python 版本。
-在終端機執行像是`python --version`的Python指令時，你應該把你的指令想成是用你系統上主要的Python版本來執行。我們建議不要在這個版本上安裝任何資源包，讓每個專案在各自獨立的環境裡運行就可以了。這樣每個專案都可以有各自的相依性跟資源包，你也不用擔心不同專案之間使用同一個環境時潛在的相容性問題。
+在終端機執行像是`python --version`的 Python 指令時，你應該把你的指令想成是用你系統上主要的 Python 版本來執行。我們建議不要在這個版本上安裝任何資源包，讓每個專案在各自獨立的環境裡運行就可以了。這樣每個專案都可以有各自的相依性跟資源包，你也不用擔心不同專案之間使用同一個環境時潛在的相容性問題。
-在Python我們可以用[*虛擬環境*](https://docs.python.org/3/tutorial/venv.html)來做這件事。虛擬環境是一個獨立包裝的樹狀目錄，每一個目錄下都有安裝特定版本的Python跟它需要的所有資源包。創建這樣的虛擬環境可以用很多不同的工具，不過我們會用一個叫做[`venv`](https://docs.python.org/3/library/venv.html#module-venv)的Python官方資源包。
+在 Python 我們可以用[*虛擬環境*](https://docs.python.org/3/tutorial/venv.html)來做這件事。虛擬環境是一個獨立包裝的樹狀目錄，每一個目錄下都有安裝特定版本的Python跟它需要的所有資源包。創建這樣的虛擬環境可以用很多不同的工具，不過我們會用一個叫做[`venv`](https://docs.python.org/3/library/venv.html#module-venv)的Python官方資源包。
首先，創建你希望你的程式執行時所在的目錄 - 舉例來說，你可能想要在你的家目錄下新增一個叫*transformers-course*的目錄：
@@ -103,7 +103,7 @@ which python
### 安裝相依性資源包
-在之前的段落中提到的使用Google Colab的情況裡，你會需要安裝相依性資源包才能繼續。你可以用 `pip` 這個資源管理工具來安裝開發版的🤗 Transformers：
+在之前的段落中提到的使用 Google Colab 的情況裡，你會需要安裝相依性資源包才能繼續。你可以用 `pip` 這個資源管理工具來安裝開發版的🤗 Transformers：
```
pip install "transformers[sentencepiece]"
diff --git a/chapters/zh-TW/chapter1/1.mdx b/chapters/zh-TW/chapter1/1.mdx
new file mode 100644
index 000000000..f779a48d0
--- /dev/null
+++ b/chapters/zh-TW/chapter1/1.mdx
@@ -0,0 +1,57 @@
+# 本章簡介
+
+
+
+
+
+
+- 第 1 章到第 4 章介紹了 🤗 Transformers 庫的主要概念。在本課程的這一部分結束時，您將熟悉 Transformer 模型的工作原理，並將瞭解如何使用 [Hugging Face Hub](https://huggingface.co/models) 中的模型，在數據集上對其進行微調，並在 Hub 上分享您的結果。
+- 第 5 章到第 8 章在深入研究經典 NLP 任務之前，教授 🤗 Datasets和 🤗 Tokenizers的基礎知識。在本部分結束時，您將能夠自己解決最常見的 NLP 問題。
+- 第 9 章到第 12 章更加深入，探討瞭如何使用 Transformer 模型處理語音處理和計算機視覺中的任務。在此過程中，您將學習如何構建和分享模型，並針對生產環境對其進行優化。在這部分結束時，您將準備好將🤗 Transformers 應用於（幾乎）任何機器學習問題！
+
+這個課程：
+
+* 需要良好的 Python 知識
+* 最好先學習深度學習入門課程，例如[DeepLearning.AI](https://www.deeplearning.ai/) 提供的 [fast.ai實用深度學習教程](https://course.fast.ai/)
+* 不需要事先具備 [PyTorch](https://pytorch.org/) 或 [TensorFlow](https://www.tensorflow.org/) 知識，雖然熟悉其中任何一個都會對huggingface的學習有所幫助
+
+完成本課程後，我們建議您查看 [DeepLearning.AI的自然語言處理系列課程](https://www.coursera.org/specializations/natural-language-processing?utm_source=deeplearning-ai&utm_medium=institutions&utm_campaign=20211011-nlp-2-hugging_face-page-nlp-refresh)，其中涵蓋了廣泛的傳統 NLP 模型，如樸素貝葉斯和 LSTM，這些模型非常值得瞭解！
+
+## 我們是誰？
+
+關於作者：
+
+**Matthew Carrigan** 是 Hugging Face 的機器學習工程師。他住在愛爾蘭都柏林，之前在 Parse.ly 擔任機器學習工程師，在此之前，他在Trinity College Dublin擔任博士後研究員。他不相信我們會通過擴展現有架構來實現 AGI，但無論如何都對機器人充滿希望。
+
+**Lysandre Debut** 是 Hugging Face 的機器學習工程師，從早期的開發階段就一直致力於 🤗 Transformers 庫。他的目標是通過使用非常簡單的 API 開發工具，讓每個人都可以使用 NLP。
+
+**Sylvain Gugger** 是 Hugging Face 的一名研究工程師，也是 🤗Transformers庫的核心維護者之一。此前，他是 fast.ai 的一名研究科學家，他與Jeremy Howard 共同編寫了[Deep Learning for Coders with fastai and Py Torch](https://learning.oreilly.com/library/view/deep-learning-for/9781492045519/)。他的主要研究重點是通過設計和改進允許模型在有限資源上快速訓練的技術，使深度學習更容易普及。
+
+**Merve Noyan** 是 Hugging Face 的開發者倡導者，致力於開發工具並圍繞它們構建內容，以使每個人的機器學習平民化。
+
+**Lucile Saulnier** 是 Hugging Face 的機器學習工程師，負責開發和支持開源工具的使用。她還積極參與了自然語言處理領域的許多研究項目，例如協作訓練和 BigScience。
+
+**Lewis Tunstall** 是 Hugging Face 的機器學習工程師，專注於開發開源工具並使更廣泛的社區可以使用它們。他也是即將出版的一本書[O’Reilly book on Transformers](https://www.oreilly.com/library/view/natural-language-processing/9781098136789/)的作者之一。
+
+**Leandro von Werra** 是 Hugging Face 開源團隊的機器學習工程師，也是即將出版的一本書[O’Reilly book on Transformers](https://www.oreilly.com/library/view/natural-language-processing/9781098136789/)的作者之一。他擁有多年的行業經驗，通過在整個機器學習堆棧中工作，將 NLP 項目投入生產。
+
+你準備好了嗎？在本章中，您將學習：
+* 如何使用 `pipeline()` 函數解決文本生成、分類等NLP任務
+* 關於 Transformer 架構
+* 如何區分編碼器、解碼器和編碼器-解碼器架構和用例
diff --git a/chapters/zh-TW/chapter1/10.mdx b/chapters/zh-TW/chapter1/10.mdx
new file mode 100644
index 000000000..cea2082cd
--- /dev/null
+++ b/chapters/zh-TW/chapter1/10.mdx
@@ -0,0 +1,258 @@
+
+
+# 章末小測試
+
+
+
+text-generation pipeline將會返回這些.",
+ },
+ {
+ text: "它將返回代表人員、組織或位置的單詞。",
+ explain: "此外，使用 grouped_entities=True，它會將屬於同一實體的單詞組合在一起，例如“Hugging Face”。",
+ correct: true
+ }
+ ]}
+/>
+
+### 3. 在此代碼示例中...的地方應該填寫什麼？
+
+```py
+from transformers import pipeline
+
+filler = pipeline("fill-mask", model="bert-base-cased")
+result = filler("...")
+```
+
+bert-base-cased 模型卡片,然後再嘗試找找錯在哪裏。"
+ },
+ {
+ text: "This [MASK] has been waiting for you.",
+ explain: "正解! 這個模型的mask的掩碼是[MASK].",
+ correct: true
+ },
+ {
+ text: "This man has been waiting for you.",
+ explain: "這個選項是不對的。 這個pipeline的作用是填充經過mask的文字，因此它需要在輸入的文本中存在mask的token。"
+ }
+ ]}
+/>
+
+### 4. 爲什麼這段代碼會無法運行？
+
+```py
+from transformers import pipeline
+
+classifier = pipeline("zero-shot-classification")
+result = classifier("This is a course about the Transformers library")
+```
+
+
+
+
+
+
+[Transformer 架構](https://arxiv.org/abs/1706.03762) 於 2017 年 6 月推出。原本研究的重點是翻譯任務。隨後推出了幾個有影響力的模型，包括
+
+- **2018 年 6 月**: [GPT](https://cdn.openai.com/research-covers/language-unsupervised/language_understanding_paper.pdf), 第一個預訓練的 Transformer 模型，用於各種 NLP 任務並獲得極好的結果
+
+- **2018 年 10 月**: [BERT](https://arxiv.org/abs/1810.04805), 另一個大型預訓練模型，該模型旨在生成更好的句子摘要（下一章將詳細介紹！）
+
+- **2019 年 2 月**: [GPT-2](https://cdn.openai.com/better-language-models/language_models_are_unsupervised_multitask_learners.pdf), GPT 的改進（並且更大）版本，由於道德問題沒有立即公開發布
+
+- **2019 年 10 月**: [DistilBERT](https://arxiv.org/abs/1910.01108), BERT 的提煉版本，速度提高 60%，內存減輕 40%，但仍保留 BERT 97% 的性能
+
+- **2019 年 10 月**: [BART](https://arxiv.org/abs/1910.13461) 和 [T5](https://arxiv.org/abs/1910.10683), 兩個使用與原始 Transformer 模型相同架構的大型預訓練模型（第一個這樣做）
+
+- **2020 年 5 月**, [GPT-3](https://arxiv.org/abs/2005.14165), GPT-2 的更大版本，無需微調即可在各種任務上表現良好（稱爲零樣本學習）
+
+這個列表並不全面，只是爲了突出一些不同類型的 Transformer 模型。大體上，它們可以分爲三類：
+
+- GPT-like (也被稱作自迴歸Transformer模型)
+- BERT-like (也被稱作自動編碼Transformer模型)
+- BART/T5-like (也被稱作序列到序列的 Transformer模型)
+
+稍後我們將更深入地探討這些分類。
+
+## Transformers是語言模型
+
+上面提到的所有 Transformer 模型（GPT、BERT、BART、T5 等）都被訓練爲語言模型。這意味着他們已經以無監督學習的方式接受了大量原始文本的訓練。無監督學習是一種訓練類型，其中目標是根據模型的輸入自動計算的。這意味着不需要人工來標記數據！
+
+這種類型的模型可以對其訓練過的語言進行統計理解，但對於特定的實際任務並不是很有用。因此，一般的預訓練模型會經歷一個稱爲*遷移學習*的過程。在此過程中，模型在給定任務上以監督方式（即使用人工註釋標籤）進行微調。
+
+任務的一個例子是閱讀 *n* 個單詞的句子，預測下一個單詞。這被稱爲因果語言建模，因爲輸出取決於過去和現在的輸入。
+
+
+
+
+
+
+
+
+另一個例子是*遮罩語言建模*，該模型預測句子中的遮住的詞。
+
+
+
+
+
+
+
+
+## Transformer是大模型
+
+除了一些特例（如 DistilBERT）外，實現更好性能的一般策略是增加模型的大小以及預訓練的數據量。
+
+
+
+
+
+
+
+不幸的是，訓練模型，尤其是大型模型，需要大量的數據，時間和計算資源。它甚至會對環境產生影響，如下圖所示。
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+這種預訓練通常是在非常大量的數據上進行的。因此，它需要大量的數據，而且訓練可能需要幾周的時間。
+
+另一方面，*微調*是在模型經過預訓練後完成的訓練。要執行微調，首先需要獲取一個經過預訓練的語言模型，然後使用特定於任務的數據集執行額外的訓練。等等，爲什麼不直接爲最後的任務而訓練呢？有幾個原因：
+
+* 預訓練模型已經在與微調數據集有一些相似之處的數據集上進行了訓練。因此，微調過程能夠利用模型在預訓練期間獲得的知識（例如，對於NLP問題，預訓練模型將對您在任務中使用的語言有某種統計規律上的理解）。
+* 由於預訓練模型已經在大量數據上進行了訓練，因此微調需要更少的數據來獲得不錯的結果。
+* 出於同樣的原因，獲得好結果所需的時間和資源要少得多
+
+例如，可以利用英語的預訓練過的模型，然後在arXiv語料庫上對其進行微調，從而形成一個基於科學/研究的模型。微調只需要有限的數據量：預訓練模型獲得的知識可以“遷移”到目標任務上，因此被稱爲*遷移學習*。
+
+
+
+
+
+
+
+
+因此，微調模型具有較低的時間、數據、財務和環境成本。迭代不同的微調方案也更快、更容易，因爲與完整的預訓練相比，訓練的約束更少。
+
+這個過程也會比從頭開始的訓練（除非你有很多數據）取得更好的效果，這就是爲什麼你應該總是嘗試利用一個預訓練的模型--一個儘可能接近你手頭的任務的模型--並對其進行微調。
+
+## 一般的體系結構
+在這一部分，我們將介紹Transformer模型的一般架構。如果你不理解其中的一些概念，不要擔心；下文將詳細介紹每個組件。
+
+
+
+
+
+
+
+
+這些部件中的每一個都可以獨立使用，具體取決於任務：
+
+* **Encoder-only models**: 適用於需要理解輸入的任務，如句子分類和命名實體識別。
+* **Decoder-only models**: 適用於生成任務，如文本生成。
+* **Encoder-decoder models** 或者 **sequence-to-sequence models**: 適用於需要根據輸入進行生成的任務，如翻譯或摘要。
+
+在後面的部分中，我們將單獨地深入研究這些體系結構。
+
+## 注意力層
+
+Transformer模型的一個關鍵特性是*注意力層*。事實上，介紹Transformer架構的文章的標題是[“注意力就是你所需要的”](https://arxiv.org/abs/1706.03762)! 我們將在課程的後面更加深入地探索注意力層；現在，您需要知道的是，這一層將告訴模型在處理每個單詞的表示時，要特別重視您傳遞給它的句子中的某些單詞（並且或多或少地忽略其他單詞）。
+
+把它放在語境中，考慮將文本從英語翻譯成法語的任務。在輸入“You like this course”的情況下，翻譯模型還需要注意相鄰的單詞“You”，以獲得單詞“like”的正確翻譯，因爲在法語中，動詞“like”的變化取決於主題。然而，句子的其餘部分對於該詞的翻譯沒有用處。同樣，在翻譯“this”時，模型也需要注意“course”一詞，因爲“this”的翻譯不同，取決於相關名詞是單數還是複數。同樣，句子中的其他單詞對於“this”的翻譯也不重要。對於更復雜的句子（以及更復雜的語法規則），模型需要特別注意可能出現在句子中更遠位置的單詞，以便正確地翻譯每個單詞。
+
+同樣的概念也適用於與自然語言相關的任何任務：一個詞本身有一個含義，但這個含義受語境的影響很大，語境可以是研究該詞之前或之後的任何其他詞（或多個詞）。
+
+現在您已經瞭解了注意力層的含義，讓我們更仔細地瞭解Transformer架構。
+
+## 原始的結構
+
+Transformer架構最初是爲翻譯而設計的。在訓練期間，編碼器接收特定語言的輸入（句子），而解碼器需要輸出對應語言的翻譯。在編碼器中，注意力層可以使用一個句子中的所有單詞（正如我們剛纔看到的，給定單詞的翻譯可以取決於它在句子中的其他單詞）。然而，解碼器是按順序工作的，並且只能注意它已經翻譯過的句子中的單詞。例如，當我們預測了翻譯目標的前三個單詞時，我們將它們提供給解碼器，然後解碼器使用編碼器的所有輸入來嘗試預測第四個單詞。
+
+爲了在訓練過程中加快速度（當模型可以訪問目標句子時），解碼器會被輸入整個目標，但不允許獲取到要翻譯的單詞（如果它在嘗試預測位置2的單詞時可以訪問位置2的單詞，解碼器就會偷懶，直接輸出那個單詞，從而無法學習到正確的語言關係！）。例如，當試圖預測第4個單詞時，注意力層只能獲取位置1到3的單詞。
+
+最初的Transformer架構如下所示，編碼器位於左側，解碼器位於右側：
+
+
+
+
+
+
+
+
+注意，解碼器塊中的第一個注意力層關聯到解碼器的所有（過去的）輸入，但是第二注意力層使用編碼器的輸出。因此，它可以訪問整個輸入句子，以最好地預測當前單詞。這是非常有用的，因爲不同的語言可以有語法規則將單詞按不同的順序排列，或者句子後面提供的一些上下文可能有助於確定給定單詞的最佳翻譯。
+
+也可以在編碼器/解碼器中使用*注意力遮罩層*，以防止模型注意某些特殊單詞。例如，在批處理句子時，填充特殊詞使所有句子的長度一致。
+
+## 架構與參數
+
+在本課程中，當我們深入探討Transformers模型時，您將看到
+架構、參數和模型
+。 這些術語的含義略有不同：
+
+* **架構**: 這是模型的骨架 -- 每個層的定義以及模型中發生的每個操作。
+* **Checkpoints**: 這些是將在給架構中結構中加載的權重。
+* **模型**: 這是一個籠統的術語，沒有“架構”或“參數”那麼精確：它可以指兩者。爲了避免歧義，本課程使用將使用架構和參數。
+
+例如，BERT是一個架構，而 `bert-base-cased`， 這是谷歌團隊爲BERT的第一個版本訓練的一組權重參數，是一個參數。我們可以說“BERT模型”和"`bert-base-cased`模型."
diff --git a/chapters/zh-TW/chapter1/5.mdx b/chapters/zh-TW/chapter1/5.mdx
new file mode 100644
index 000000000..acd28f78c
--- /dev/null
+++ b/chapters/zh-TW/chapter1/5.mdx
@@ -0,0 +1,22 @@
+# “編碼器”模型
+
+
+
+
+
+
+
+
+讓我們快速瀏覽一下這些內容。
+
+## 使用分詞器進行預處理
+
+與其他神經網絡一樣，Transformer 模型無法直接處理原始文本， 因此我們管道的第一步是將文本輸入轉換為模型能夠理解的數字。 為此，我們使用*tokenizer*(標記器)，負責：
+
+- 將輸入拆分為單詞、子單詞或符號（如標點符號），稱為標記(*token*)
+- 將每個標記(token)映射到一個整數
+- 添加可能對模型有用的其他輸入
+
+所有這些預處理都需要以與模型預訓練時完全相同的方式完成，因此我們首先需要從[Model Hub](https://huggingface.co/models)中下載這些信息。為此，我們使用`AutoTokenizer`類及其`from_pretrained()`方法。使用我們模型的檢查點名稱，它將自動獲取與模型的標記器相關聯的數據，並對其進行緩存（因此只有在您第一次運行下面的代碼時才會下載）。
+
+因為`sentiment-analysis`（情緒分析）管道的默認檢查點是`distilbert-base-uncased-finetuned-sst-2-english`（你可以看到它的模型卡[here](https://huggingface.co/distilbert-base-uncased-finetuned-sst-2-english))，我們運行以下程序：
+
+```python
+from transformers import AutoTokenizer
+
+checkpoint = "distilbert-base-uncased-finetuned-sst-2-english"
+tokenizer = AutoTokenizer.from_pretrained(checkpoint)
+```
+
+一旦我們有了標記器，我們就可以直接將我們的句子傳遞給它，然後我們就會得到一本字典，它可以提供給我們的模型！剩下要做的唯一一件事就是將輸入ID列表轉換為張量。
+
+您可以使用🤗 Transformers，而不必擔心哪個 ML 框架被用作後端；它可能是 PyTorch 或 TensorFlow，或 Flax。但是，Transformers型號只接受*張量*作為輸入。如果這是你第一次聽說張量，你可以把它們想象成NumPy數組。NumPy數組可以是標量（0D）、向量（1D）、矩陣（2D）或具有更多維度。它實際上是張量；其他 ML 框架的張量行為類似，通常與 NumPy 數組一樣易於實例化。
+
+要指定要返回的張量類型（PyTorch、TensorFlow 或 plain NumPy），我們使用`return_tensors`參數：
+
+{#if fw === 'pt'}
+```python
+raw_inputs = [
+ "I've been waiting for a HuggingFace course my whole life.",
+ "I hate this so much!",
+]
+inputs = tokenizer(raw_inputs, padding=True, truncation=True, return_tensors="pt")
+print(inputs)
+```
+{:else}
+```python
+raw_inputs = [
+ "I've been waiting for a HuggingFace course my whole life.",
+ "I hate this so much!",
+]
+inputs = tokenizer(raw_inputs, padding=True, truncation=True, return_tensors="tf")
+print(inputs)
+```
+{/if}
+
+現在不要擔心填充和截斷；我們稍後會解釋這些。這裡要記住的主要事情是，您可以傳遞一個句子或一組句子，還可以指定要返回的張量類型（如果沒有傳遞類型，您將得到一組列表）。
+
+{#if fw === 'pt'}
+
+以下是PyTorch張量的結果：
+
+```python out
+{
+ 'input_ids': tensor([
+ [ 101, 1045, 1005, 2310, 2042, 3403, 2005, 1037, 17662, 12172, 2607, 2026, 2878, 2166, 1012, 102],
+ [ 101, 1045, 5223, 2023, 2061, 2172, 999, 102, 0, 0, 0, 0, 0, 0, 0, 0]
+ ]),
+ 'attention_mask': tensor([
+ [1, 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]
+ ])
+}
+```
+{:else}
+
+以下是 TensorFlow 張量的結果：
+
+```python out
+{
+ 'input_ids':
+
+
+
+
+
+
+Transformers 模型的輸出直接發送到模型頭進行處理。
+
+在此圖中，模型由其嵌入層和後續層表示。嵌入層將標記化輸入中的每個輸入ID轉換為表示關聯標記(token)的向量。後續層使用注意機制操縱這些向量，以生成句子的最終表示。
+
+
+🤗 Transformers中有許多不同的體系結構，每種體系結構都是圍繞處理特定任務而設計的。以下是一個非詳盡的列表：
+
+- `*Model` (retrieve the hidden states)
+- `*ForCausalLM`
+- `*ForMaskedLM`
+- `*ForMultipleChoice`
+- `*ForQuestionAnswering`
+- `*ForSequenceClassification`
+- `*ForTokenClassification`
+- 以及其他 🤗
+
+{#if fw === 'pt'}
+對於我們的示例，我們需要一個帶有序列分類頭的模型（能夠將句子分類為肯定或否定）。因此，我們實際上不會使用`AutoModel`類，而是使用`AutoModelForSequenceClassification`：
+
+```python
+from transformers import AutoModelForSequenceClassification
+
+checkpoint = "distilbert-base-uncased-finetuned-sst-2-english"
+model = AutoModelForSequenceClassification.from_pretrained(checkpoint)
+outputs = model(**inputs)
+```
+{:else}
+For our example, we will need a model with a sequence classification head (to be able to classify the sentences as positive or negative). So, we won't actually use the `TFAutoModel` class, but `TFAutoModelForSequenceClassification`:
+
+```python
+from transformers import TFAutoModelForSequenceClassification
+
+checkpoint = "distilbert-base-uncased-finetuned-sst-2-english"
+model = TFAutoModelForSequenceClassification.from_pretrained(checkpoint)
+outputs = model(inputs)
+```
+{/if}
+
+現在，如果我們觀察輸入的形狀，維度將低得多：模型頭將我們之前看到的高維向量作為輸入，並輸出包含兩個值的向量（每個標籤一個）：
+
+```python
+print(outputs.logits.shape)
+```
+
+{#if fw === 'pt'}
+
+```python out
+torch.Size([2, 2])
+```
+
+{:else}
+
+```python out
+(2, 2)
+```
+
+{/if}
+
+因為我們只有兩個句子和兩個標籤，所以我們從模型中得到的結果是2 x 2的形狀。
+
+## 對輸出進行後處理
+
+我們從模型中得到的輸出值本身並不一定有意義。我們來看看,
+
+```python
+print(outputs.logits)
+```
+
+{#if fw === 'pt'}
+```python out
+tensor([[-1.5607, 1.6123],
+ [ 4.1692, -3.3464]], grad_fn=
+
+
+ 
+ 
+
+
+有多種方法可以拆分文本。例如，我們可以通過應用Python的`split()`函數，使用空格將文本標記為單詞：
+
+```py
+tokenized_text = "Jim Henson was a puppeteer".split()
+print(tokenized_text)
+```
+
+```python out
+['Jim', 'Henson', 'was', 'a', 'puppeteer']
+```
+
+還有一些單詞標記器的變體，它們具有額外的標點符號規則。使用這種標記器，我們最終可以得到一些非常大的“詞彙表”，其中詞彙表由我們在語料庫中擁有的獨立標記的總數定義。
+
+每個單詞都分配了一個 ID，從 0 開始一直到詞彙表的大小。該模型使用這些 ID 來識別每個單詞。
+
+如果我們想用基於單詞的標記器(tokenizer)完全覆蓋一種語言，我們需要為語言中的每個單詞都有一個標識符，這將生成大量的標記。例如，英語中有超過 500,000 個單詞，因此要構建從每個單詞到輸入 ID 的映射，我們需要跟蹤這麼多 ID。此外，像“dog”這樣的詞與“dogs”這樣的詞的表示方式不同，模型最初無法知道“dog”和“dogs”是相似的：它會將這兩個詞識別為不相關。這同樣適用於其他相似的詞，例如“run”和“running”，模型最初不會認為它們是相似的。
+
+最後，我們需要一個自定義標記(token)來表示不在我們詞彙表中的單詞。這被稱為“未知”標記(token)，通常表示為“[UNK]”或"<unk>"。如果你看到標記器產生了很多這樣的標記，這通常是一個不好的跡象，因為它無法檢索到一個詞的合理表示，並且你會在這個過程中丟失信息。製作詞彙表時的目標是以這樣一種方式進行，即標記器將盡可能少的單詞標記為未知標記。
+
+減少未知標記數量的一種方法是使用更深一層的標記器(tokenizer)，即基於字符的(_character-based_)標記器(tokenizer)。
+
+## 基於字符(Character-based)
+
+
+
+
+ 
+ 
+
+
+這種方法也不是完美的。由於現在表示是基於字符而不是單詞，因此人們可能會爭辯說，從直覺上講，它的意義不大：每個字符本身並沒有多大意義，而單詞就是這種情況。然而，這又因語言而異；例如，在中文中，每個字符比拉丁語言中的字符包含更多的信息。
+
+另一件要考慮的事情是，我們的模型最終會處理大量的詞符(token)：雖然使用基於單詞的標記器(tokenizer)，單詞只會是單個標記，但當轉換為字符時，它很容易變成 10 個或更多的詞符(token)。
+
+為了兩全其美，我們可以使用結合這兩種方法的第三種技術：*子詞標記化(subword tokenization)*。
+
+## 子詞標記化
+
+
+
+
+ 
+ 
+
+
+這些子詞最終提供了很多語義含義：例如，在上面的示例中，“tokenization”被拆分為“token”和“ization”，這兩個具有語義意義同時節省空間的詞符(token)（只需要兩個標記(token)代表一個長詞）。這使我們能夠對較小的詞彙表進行相對較好的覆蓋，並且幾乎沒有未知的標記
+
+這種方法在土耳其語等粘著型語言(agglutinative languages)中特別有用，您可以通過將子詞串在一起來形成（幾乎）任意長的複雜詞。
+
+### 還有更多！
+
+不出所料，還有更多的技術。僅舉幾例：
+
+- Byte-level BPE, 用於 GPT-2
+- WordPiece, 用於 BERT
+- SentencePiece or Unigram, 用於多個多語言模型
+
+您現在應該對標記器(tokenizers)的工作原理有足夠的瞭解，以便開始使用 API。
+
+## 加載和保存
+
+加載和保存標記器(tokenizer)就像使用模型一樣簡單。實際上，它基於相同的兩種方法： `from_pretrained()` 和 `save_pretrained()` 。這些方法將加載或保存標記器(tokenizer)使用的算法（有點像*建築學(architecture)*的模型）以及它的詞彙（有點像*權重(weights)*模型）。
+
+加載使用與 BERT 相同的檢查點訓練的 BERT 標記器(tokenizer)與加載模型的方式相同，除了我們使用 `BertTokenizer` 類：
+
+```py
+from transformers import BertTokenizer
+
+tokenizer = BertTokenizer.from_pretrained("bert-base-cased")
+```
+
+{#if fw === 'pt'}
+如同 `AutoModel`，`AutoTokenizer` 類將根據檢查點名稱在庫中獲取正確的標記器(tokenizer)類，並且可以直接與任何檢查點一起使用：
+
+{:else}
+如同 `TFAutoModel`， `AutoTokenizer` 類將根據檢查點名稱在庫中獲取正確的標記器(tokenizer)類，並且可以直接與任何檢查點一起使用：
+
+{/if}
+
+```py
+from transformers import AutoTokenizer
+
+tokenizer = AutoTokenizer.from_pretrained("bert-base-cased")
+```
+
+我們現在可以使用標記器(tokenizer)，如上一節所示：
+
+```python
+tokenizer("Using a Transformer network is simple")
+```
+
+```python out
+{'input_ids': [101, 7993, 170, 11303, 1200, 2443, 1110, 3014, 102],
+ 'token_type_ids': [0, 0, 0, 0, 0, 0, 0, 0, 0],
+ 'attention_mask': [1, 1, 1, 1, 1, 1, 1, 1, 1]}
+```
+
+保存標記器(tokenizer)與保存模型相同:
+
+```py
+tokenizer.save_pretrained("directory_on_my_computer")
+```
+
+我們在[Chapter 3](/Couse/chapter3)中將更多地談論`token_type_ids`，稍後我們將解釋 `attention_mask` 鍵。首先，讓我們看看 `input_ids` 如何生成。為此，我們需要查看標記器(tokenizer)的中間方法。
+
+## 編碼
+
+
+
+AutoModel只需要知道初始化的Checkpoint(檢查點)就可以返回正確的體系結構。",
+ correct: true
+ },
+ {
+ text: "一種可以自動檢測輸入語言來加載正確權重的模型",
+ explain: "不正確; 雖然有些Checkpoint(檢查點)和模型能夠處理多種語言，但是沒有內置的工具可以根據語言自動選擇Checkpoint(檢查點)。您應該前往 Model Hub 尋找完成所需任務的最佳Checkpoint(檢查點)！"
+ }
+ ]}
+/>
+
+{:else}
+### 5.什麼是 TFAutoModel？
+TFAutoModel只需要知道初始化的Checkpoint(檢查點)就可以返回正確的體系結構。",
+ correct: true
+ },
+ {
+ text: "一種可以自動檢測輸入語言來加載正確權重的模型",
+ explain: "不正確; 雖然有些Checkpoint(檢查點)和模型能夠處理多種語言，但是沒有內置的工具可以根據語言自動選擇Checkpoint(檢查點)。您應該前往 Model Hub 尋找完成所需任務的最佳Checkpoint(檢查點)！"
+ }
+ ]}
+/>
+
+{/if}
+
+### 6.當將不同長度的序列批處理在一起時，需要進行哪些處理？
+編碼 方法確實存在於標記器中，但是它不存在於模型中。"
+ },
+ {
+ text: "直接調用標記器(Tokenizer)對象。",
+ explain: "完全正確！標記化器(Tokenizer) 的 __call__方法是一個非常強大的方法，可以處理幾乎任何事情。它也是從模型中獲取預測的方法。",
+ correct: true
+ },
+ {
+ text: "pad(填充)",
+ explain: "錯! pad(填充)非常有用，但它只是標記器(Tokenizer) API的一部分。"
+ },
+ {
+ text: "tokenize(標記)",
+ explain: "可以說，tokenize(標記)方法是最有用的方法之一，但它不是標記器(Tokenizer) API的核心方法。"
+ }
+ ]}
+/>
+
+### 9.這個代碼示例中的`result`變量包含什麼？
+```py
+from transformers import AutoTokenizer
+
+tokenizer = AutoTokenizer.from_pretrained("bert-base-cased")
+result = tokenizer.tokenize("Hello!")
+```
+
+convert_tokens_to_ids方法的作用！"
+ },
+ {
+ text: "包含所有標記(Token)的字符串",
+ explain: "這將是次優的，因為Tokenizer會將字符串拆分為多個標記的列表。"
+ }
+ ]}
+/>
+
+{#if fw === 'pt'}
+### 10.下面的代碼有什麼錯誤嗎？
+```py
+from transformers import AutoTokenizer, AutoModel
+
+tokenizer = AutoTokenizer.from_pretrained("bert-base-cased")
+model = AutoModel.from_pretrained("gpt2")
+
+encoded = tokenizer("Hey!", return_tensors="pt")
+result = model(**encoded)
+```
+
+DataLoader. We used the DataCollatorWithPadding function, which pads all items in a batch so they have the same length.",
+ correct: true
+ },
+ {
+ text: "它預處理整個數據集。",
+ explain: "這將是一個預處理函數，而不是校對函數。"
+ },
+ {
+ text: "它截斷數據集中的序列。",
+ explain: "校對函數用於處理單個批處理，而不是整個數據集。如果您對截斷感興趣，可以使用 < code > tokenizer 的 < truncate 參數。"
+ }
+ ]}
+/>
+
+### 7.當你用一個預先訓練過的語言模型(例如‘ bert-base-uncased’)實例化一個‘ AutoModelForXxx’類，這個類對應於一個不同於它所被訓練的任務時會發生什麼？
+evaluation_strategy as well, so this impacts evaluation. 再試一次！"
+ }
+ ]}
+/>
+
+### 9.為什麼要使用 Accelerate 庫？
+
+
+
+
+我們選擇 **camembert-base** 檢查點來嘗試一下。我們需要做的僅僅是輸入 `camembert-base`標識符！正如您在前幾章中看到的，我們可以使用 **pipeline()** 功能：
+
+```py
+from transformers import pipeline
+
+camembert_fill_mask = pipeline("fill-mask", model="camembert-base")
+results = camembert_fill_mask("Le camembert est
+
+
+
+
+您還可以直接使用模型架構實例化檢查點：
+
+{#if fw === 'pt'}
+```py
+from transformers import CamembertTokenizer, CamembertForMaskedLM
+
+tokenizer = CamembertTokenizer.from_pretrained("camembert-base")
+model = CamembertForMaskedLM.from_pretrained("camembert-base")
+```
+
+然而，我們建議使用[Auto* 類](https://huggingface.co/transformers/model_doc/auto.html?highlight=auto#auto-classes)，因為Auto* 類設計與架構無關。前面的代碼示例將只能在 CamemBERT 架構中加載可用的檢查點，但使用 **Auto*** 類使切換檢查點變得簡單：
+
+```py
+from transformers import AutoTokenizer, AutoModelForMaskedLM
+
+tokenizer = AutoTokenizer.from_pretrained("camembert-base")
+model = AutoModelForMaskedLM.from_pretrained("camembert-base")
+```
+{:else}
+```py
+from transformers import CamembertTokenizer, TFCamembertForMaskedLM
+
+tokenizer = CamembertTokenizer.from_pretrained("camembert-base")
+model = TFCamembertForMaskedLM.from_pretrained("camembert-base")
+```
+
+However, we recommend using the [`TFAuto*` classes](https://huggingface.co/transformers/model_doc/auto.html?highlight=auto#auto-classes) instead, as these are by design architecture-agnostic. While the previous code sample limits users to checkpoints loadable in the CamemBERT architecture, using the `TFAuto*` classes makes switching checkpoints simple:
+然而，我們建議使用[`TFAuto*` 類](https://huggingface.co/transformers/model_doc/auto.html?highlight=auto#auto-classes)，因為`TFAuto*`類設計與架構無關。前面的代碼示例將只能在 CamemBERT 架構中加載可用的檢查點，但使用 `TFAuto*` 類使切換檢查點變得簡單：
+
+```py
+from transformers import AutoTokenizer, TFAutoModelForMaskedLM
+
+tokenizer = AutoTokenizer.from_pretrained("camembert-base")
+model = TFAutoModelForMaskedLM.from_pretrained("camembert-base")
+```
+{/if}
+
+
+
+ 
+
+
+
+{:else}
+
+
+如果您使用Keras來訓練您的模型，則將其上傳到Hub的最簡單方法是在調用 **model.fit()** 時傳遞**PushToHubCallback**：
+
+```py
+from transformers import PushToHubCallback
+
+callback = PushToHubCallback(
+ "bert-finetuned-mrpc", save_strategy="epoch", tokenizer=tokenizer
+)
+```
+
+然後，您應該在對**model.fit()**的調用中添加**callbacks=[callback]**。然後，每次將模型保存在命名空間的存儲庫中（此處為每個 epoch）時，回調都會將模型上傳到 Hub。該存儲庫的名稱將類似於您選擇的輸出目錄（此處為**bert-finetuned-mrpc**），但您可以選擇另一個名稱，名稱為**hub_model_id = a_different_name**。
+
+要將您的模型上傳到您所屬的組織，只需將其傳遞給 **hub_model_id = my_organization/my_repo_name** 。
+
+{/if}
+
+在較低級別，可以通過模型、標記器和配置對象直接訪問模型中心 **push_to_hub()** 方法。此方法負責創建存儲庫並將模型和標記器文件直接推送到存儲庫。與我們將在下面看到的 API 不同，不需要手動處理。
+
+為了瞭解它是如何工作的，讓我們首先初始化一個模型和一個標記器：
+
+{#if fw === 'pt'}
+
+```py
+from transformers import AutoModelForMaskedLM, AutoTokenizer
+
+checkpoint = "camembert-base"
+
+model = AutoModelForMaskedLM.from_pretrained(checkpoint)
+tokenizer = AutoTokenizer.from_pretrained(checkpoint)
+```
+
+{:else}
+
+```py
+from transformers import TFAutoModelForMaskedLM, AutoTokenizer
+
+checkpoint = "camembert-base"
+
+model = TFAutoModelForMaskedLM.from_pretrained(checkpoint)
+tokenizer = AutoTokenizer.from_pretrained(checkpoint)
+```
+
+{/if}
+
+你可以自由地用這些做任何你想做的事情——向標記器添加標記，訓練模型，微調它。一旦您對生成的模型、權重和標記器感到滿意，您就可以利用 **push_to_hub()** 方法直接在 **model** 中：
+
+```py
+model.push_to_hub("dummy-model")
+```
+
+這將創建新的存儲庫 **dummy-model** 在您的個人資料中，並用您的模型文件填充它。
+對標記器執行相同的操作，以便所有文件現在都可以在此存儲庫中使用：
+
+```py
+tokenizer.push_to_hub("dummy-model")
+```
+
+如果您屬於一個組織，只需指定 **organization** 上傳到該組織的命名空間的參數：
+
+```py
+tokenizer.push_to_hub("dummy-model", organization="huggingface")
+```
+
+如果您希望使用特定的 Hugging Face 令牌，您可以自由地將其指定給 **push_to_hub()** 方法也是：
+
+```py
+tokenizer.push_to_hub("dummy-model", organization="huggingface", use_auth_token="
+
+
+
+{:else}
+
+
+
+
+{/if}
+
+
+
+
+
+
+首先，指定存儲庫的所有者：這可以是您或您所屬的任何組織。如果您選擇一個組織，該模型將出現在該組織的頁面上，並且該組織的每個成員都可以為存儲庫做出貢獻。
+
+接下來，輸入您的模型名稱。這也將是存儲庫的名稱。最後，您可以指定您的模型是公開的還是私有的。私人模特要求您擁有付費 Hugging Face 帳戶，並允許您將模特隱藏在公眾視野之外。
+
+創建模型存儲庫後，您應該看到如下頁面：
+
+
+
+
+
+
+這是您的模型將被託管的地方。要開始填充它，您可以直接從 Web 界面添加 README 文件。
+
+
+
+
+
+
+README 文件在 Markdown 中 - 隨意使用它！本章的第三部分致力於構建模型卡。這些對於為您的模型帶來價值至關重要，因為它們是您告訴其他人它可以做什麼的地方。
+
+如果您查看“文件和版本”選項卡，您會發現那裡還沒有很多文件——只有自述文件你剛剛創建和.git 屬性跟蹤大文件的文件。
+
+
+
+
+
+
+接下來我們將看看如何添加一些新文件。
+
+## 上傳模型文件
+
+Hugging Face Hub 上的文件管理系統基於用於常規文件的 git 和 git-lfs（代表[Git Large File Storage](https://git-lfs.github.com/)) 對於較大的文件。
+
+在下一節中，我們將介紹將文件上傳到 Hub 的三種不同方式：通過 **huggingface_hub** 並通過 git 命令。
+
+### The `upload_file` approach
+
+使用 **upload_file** 不需要在您的系統上安裝 git 和 git-lfs。它使用 HTTP POST 請求將文件直接推送到 🤗 Hub。這種方法的一個限制是它不能處理大於 5GB 的文件。
+如果您的文件大於 5GB，請按照下面詳述的另外兩種方法進行操作。API 可以按如下方式使用：
+
+```py
+from huggingface_hub import upload_file
+
+upload_file(
+ "
+
+
+
+
+UI 允許您瀏覽模型文件和提交，並查看每個提交引入的差異：
+
+
+
+
+
+
+{:else}
+
+如果我們在完成後查看模型存儲庫，我們可以看到所有最近添加的文件：
+
+
+
+
+
+
+UI 允許您瀏覽模型文件和提交，並查看每個提交引入的差異：
+
+
+
+
+
+{/if}
diff --git a/chapters/zh-TW/chapter4/4.mdx b/chapters/zh-TW/chapter4/4.mdx
new file mode 100644
index 000000000..b5eecf1a8
--- /dev/null
+++ b/chapters/zh-TW/chapter4/4.mdx
@@ -0,0 +1,87 @@
+# 構建模型卡片
+
+
+| + | patient_id | +drugName | +condition | +review | +rating | +date | +usefulCount | +review_length | +
|---|---|---|---|---|---|---|---|---|
| 0 | +95260 | +Guanfacine | +adhd | +"My son is halfway through his fourth week of Intuniv..." | +8.0 | +April 27, 2010 | +192 | +141 | +
| 1 | +92703 | +Lybrel | +birth control | +"I used to take another oral contraceptive, which had 21 pill cycle, and was very happy- very light periods, max 5 days, no other side effects..." | +5.0 | +December 14, 2009 | +17 | +134 | +
| 2 | +138000 | +Ortho Evra | +birth control | +"This is my first time using any form of birth control..." | +8.0 | +November 3, 2015 | +10 | +89 | +
| + | condition | +frequency | +
|---|---|---|
| 0 | +birth control | +27655 | +
| 1 | +depression | +8023 | +
| 2 | +acne | +5209 | +
| 3 | +anxiety | +4991 | +
| 4 | +pain | +4744 | +
+
+
+
+如果您單擊其中一個issue，您會發現它包含一個標題、一個描述和一組表徵該issue的標籤。下面的屏幕截圖顯示了一個示例.
+
+
+
+
+
+
+要下載所有存儲庫的issue，我們將使用[GitHub REST API](https://docs.github.com/en/rest)投票[Issues endpoint](https://docs.github.com/en/rest/reference/issues#list-repository-issues).此節點返回一個 JSON 對象列表，每個對象包含大量字段，其中包括標題和描述以及有關issue狀態的元數據等。
+
+下載issue的一種便捷方式是通過 **requests** 庫，這是用 Python 中發出 HTTP 請求的標準方式。您可以通過運行以下的代碼來安裝庫：
+
+```python
+!pip install requests
+```
+
+安裝庫後，您通過調用 **requests.get()** 功能來獲取**Issues**節點。例如，您可以運行以下命令來獲取第一頁上的第一個Issues：
+
+```py
+import requests
+
+url = "https://api.github.com/repos/huggingface/datasets/issues?page=1&per_page=1"
+response = requests.get(url)
+```
+
+這 **response** 對象包含很多關於請求的有用信息，包括 HTTP 狀態碼：
+
+```py
+response.status_code
+```
+
+```python out
+200
+```
+
+其中一個狀態碼 **200** 表示請求成功（您可以[在這裡](https://en.wikipedia.org/wiki/List_of_HTTP_status_codes)找到可能的 HTTP 狀態代碼列表）。然而，我們真正感興趣的是有效的信息，由於我們知道我們的issues是 JSON 格式，讓我們按如下方式查看所有的信息：
+
+```py
+response.json()
+```
+
+```python out
+[{'url': 'https://api.github.com/repos/huggingface/datasets/issues/2792',
+ 'repository_url': 'https://api.github.com/repos/huggingface/datasets',
+ 'labels_url': 'https://api.github.com/repos/huggingface/datasets/issues/2792/labels{/name}',
+ 'comments_url': 'https://api.github.com/repos/huggingface/datasets/issues/2792/comments',
+ 'events_url': 'https://api.github.com/repos/huggingface/datasets/issues/2792/events',
+ 'html_url': 'https://github.com/huggingface/datasets/pull/2792',
+ 'id': 968650274,
+ 'node_id': 'MDExOlB1bGxSZXF1ZXN0NzEwNzUyMjc0',
+ 'number': 2792,
+ 'title': 'Update GooAQ',
+ 'user': {'login': 'bhavitvyamalik',
+ 'id': 19718818,
+ 'node_id': 'MDQ6VXNlcjE5NzE4ODE4',
+ 'avatar_url': 'https://avatars.githubusercontent.com/u/19718818?v=4',
+ 'gravatar_id': '',
+ 'url': 'https://api.github.com/users/bhavitvyamalik',
+ 'html_url': 'https://github.com/bhavitvyamalik',
+ 'followers_url': 'https://api.github.com/users/bhavitvyamalik/followers',
+ 'following_url': 'https://api.github.com/users/bhavitvyamalik/following{/other_user}',
+ 'gists_url': 'https://api.github.com/users/bhavitvyamalik/gists{/gist_id}',
+ 'starred_url': 'https://api.github.com/users/bhavitvyamalik/starred{/owner}{/repo}',
+ 'subscriptions_url': 'https://api.github.com/users/bhavitvyamalik/subscriptions',
+ 'organizations_url': 'https://api.github.com/users/bhavitvyamalik/orgs',
+ 'repos_url': 'https://api.github.com/users/bhavitvyamalik/repos',
+ 'events_url': 'https://api.github.com/users/bhavitvyamalik/events{/privacy}',
+ 'received_events_url': 'https://api.github.com/users/bhavitvyamalik/received_events',
+ 'type': 'User',
+ 'site_admin': False},
+ 'labels': [],
+ 'state': 'open',
+ 'locked': False,
+ 'assignee': None,
+ 'assignees': [],
+ 'milestone': None,
+ 'comments': 1,
+ 'created_at': '2021-08-12T11:40:18Z',
+ 'updated_at': '2021-08-12T12:31:17Z',
+ 'closed_at': None,
+ 'author_association': 'CONTRIBUTOR',
+ 'active_lock_reason': None,
+ 'pull_request': {'url': 'https://api.github.com/repos/huggingface/datasets/pulls/2792',
+ 'html_url': 'https://github.com/huggingface/datasets/pull/2792',
+ 'diff_url': 'https://github.com/huggingface/datasets/pull/2792.diff',
+ 'patch_url': 'https://github.com/huggingface/datasets/pull/2792.patch'},
+ 'body': '[GooAQ](https://github.com/allenai/gooaq) dataset was recently updated after splits were added for the same. This PR contains new updated GooAQ with train/val/test splits and updated README as well.',
+ 'performed_via_github_app': None}]
+```
+
+哇，這是很多信息！我們可以看到有用的字段，例如 **標題** , **內容** ， **參與的成員**， **issue的描述信息**，以及打開issue的GitHub 用戶的信息。
+
+
+
+
+
+
+GitHub REST API 提供了一個 [評論節點](https://docs.github.com/en/rest/reference/issues#list-issue-comments) 返回與issue編號相關的所有評論。讓我們測試節點以查看它返回的內容：
+
+```py
+issue_number = 2792
+url = f"https://api.github.com/repos/huggingface/datasets/issues/{issue_number}/comments"
+response = requests.get(url, headers=headers)
+response.json()
+```
+
+```python out
+[{'url': 'https://api.github.com/repos/huggingface/datasets/issues/comments/897594128',
+ 'html_url': 'https://github.com/huggingface/datasets/pull/2792#issuecomment-897594128',
+ 'issue_url': 'https://api.github.com/repos/huggingface/datasets/issues/2792',
+ 'id': 897594128,
+ 'node_id': 'IC_kwDODunzps41gDMQ',
+ 'user': {'login': 'bhavitvyamalik',
+ 'id': 19718818,
+ 'node_id': 'MDQ6VXNlcjE5NzE4ODE4',
+ 'avatar_url': 'https://avatars.githubusercontent.com/u/19718818?v=4',
+ 'gravatar_id': '',
+ 'url': 'https://api.github.com/users/bhavitvyamalik',
+ 'html_url': 'https://github.com/bhavitvyamalik',
+ 'followers_url': 'https://api.github.com/users/bhavitvyamalik/followers',
+ 'following_url': 'https://api.github.com/users/bhavitvyamalik/following{/other_user}',
+ 'gists_url': 'https://api.github.com/users/bhavitvyamalik/gists{/gist_id}',
+ 'starred_url': 'https://api.github.com/users/bhavitvyamalik/starred{/owner}{/repo}',
+ 'subscriptions_url': 'https://api.github.com/users/bhavitvyamalik/subscriptions',
+ 'organizations_url': 'https://api.github.com/users/bhavitvyamalik/orgs',
+ 'repos_url': 'https://api.github.com/users/bhavitvyamalik/repos',
+ 'events_url': 'https://api.github.com/users/bhavitvyamalik/events{/privacy}',
+ 'received_events_url': 'https://api.github.com/users/bhavitvyamalik/received_events',
+ 'type': 'User',
+ 'site_admin': False},
+ 'created_at': '2021-08-12T12:21:52Z',
+ 'updated_at': '2021-08-12T12:31:17Z',
+ 'author_association': 'CONTRIBUTOR',
+ 'body': "@albertvillanova my tests are failing here:\r\n```\r\ndataset_name = 'gooaq'\r\n\r\n def test_load_dataset(self, dataset_name):\r\n configs = self.dataset_tester.load_all_configs(dataset_name, is_local=True)[:1]\r\n> self.dataset_tester.check_load_dataset(dataset_name, configs, is_local=True, use_local_dummy_data=True)\r\n\r\ntests/test_dataset_common.py:234: \r\n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \r\ntests/test_dataset_common.py:187: in check_load_dataset\r\n self.parent.assertTrue(len(dataset[split]) > 0)\r\nE AssertionError: False is not true\r\n```\r\nWhen I try loading dataset on local machine it works fine. Any suggestions on how can I avoid this error?",
+ 'performed_via_github_app': None}]
+```
+
+我們可以看到註釋存儲在body字段中，所以讓我們編寫一個簡單的函數，通過在response.json()中為每個元素挑選body內容來返回與某個issue相關的所有評論：
+
+```py
+def get_comments(issue_number):
+ url = f"https://api.github.com/repos/huggingface/datasets/issues/{issue_number}/comments"
+ response = requests.get(url, headers=headers)
+ return [r["body"] for r in response.json()]
+
+
+# Test our function works as expected
+get_comments(2792)
+```
+
+```python out
+["@albertvillanova my tests are failing here:\r\n```\r\ndataset_name = 'gooaq'\r\n\r\n def test_load_dataset(self, dataset_name):\r\n configs = self.dataset_tester.load_all_configs(dataset_name, is_local=True)[:1]\r\n> self.dataset_tester.check_load_dataset(dataset_name, configs, is_local=True, use_local_dummy_data=True)\r\n\r\ntests/test_dataset_common.py:234: \r\n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ \r\ntests/test_dataset_common.py:187: in check_load_dataset\r\n self.parent.assertTrue(len(dataset[split]) > 0)\r\nE AssertionError: False is not true\r\n```\r\nWhen I try loading dataset on local machine it works fine. Any suggestions on how can I avoid this error?"]
+```
+
+這看起來不錯，所以讓我們使用 **Dataset.map()** 方法在我們數據集中每個issue的添加一個**comments**列：
+
+```py
+# Depending on your internet connection, this can take a few minutes...
+issues_with_comments_dataset = issues_dataset.map(
+ lambda x: {"comments": get_comments(x["number"])}
+)
+```
+
+最後一步是將增強數據集與原始數據保存在一起，以便我們可以將它們都推送到 Hub：
+
+```py
+issues_with_comments_dataset.to_json("issues-datasets-with-comments.jsonl")
+```
+
+## 將數據集上傳到 Hugging Face Hub
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+我們來看看數據集：
+
+```py
+raw_datasets
+```
+
+```python out
+DatasetDict({
+ train: Dataset({
+ features: ['id', 'translation'],
+ num_rows: 210173
+ })
+})
+```
+
+我們有 210,173 對句子，但在一次訓練過程中，我們需要創建自己的驗證集。正如我們在[第五章](/course/chapter5)學的的那樣, **Dataset** 有一個 **train_test_split()** 方法,可以幫我們拆分數據集。我們將設定固定的隨機數種子：
+
+```py
+split_datasets = raw_datasets["train"].train_test_split(train_size=0.9, seed=20)
+split_datasets
+```
+
+```python out
+DatasetDict({
+ train: Dataset({
+ features: ['id', 'translation'],
+ num_rows: 189155
+ })
+ test: Dataset({
+ features: ['id', 'translation'],
+ num_rows: 21018
+ })
+})
+```
+
+我們可以將 **test** 的鍵重命名為 **validation** 像這樣：
+
+```py
+split_datasets["validation"] = split_datasets.pop("test")
+```
+
+現在讓我們看一下數據集的一個元素：
+
+```py
+split_datasets["train"][1]["translation"]
+```
+
+```python out
+{'en': 'Default to expanded threads',
+ 'fr': 'Par défaut, développer les fils de discussion'}
+```
+
+我們得到一個字典，其中包含我們請求的兩種語言的兩個句子。這個充滿技術計算機科學術語的數據集的一個特殊之處在於它們都完全用法語翻譯。然而，法國工程師通常很懶惰，在交談時，大多數計算機科學專用詞彙都用英語表述。例如，“threads”這個詞很可能出現在法語句子中，尤其是在技術對話中；但在這個數據集中，它被翻譯成更正確的“fils de Discussion”。我們使用的預訓練模型已經在一個更大的法語和英語句子語料庫上進行了預訓練，採用了更簡單的選擇，即保留單詞的原樣:
+
+```py
+from transformers import pipeline
+
+model_checkpoint = "Helsinki-NLP/opus-mt-en-fr"
+translator = pipeline("translation", model=model_checkpoint)
+translator("Default to expanded threads")
+```
+
+```python out
+[{'translation_text': 'Par défaut pour les threads élargis'}]
+```
+
+這種情況的另一個例子是“plugin”這個詞，它不是正式的法語詞，但大多數母語人士都能理解，也不會費心去翻譯。
+在 KDE4 數據集中，這個詞在法語中被翻譯成更正式的“module d’extension”：
+```py
+split_datasets["train"][172]["translation"]
+```
+
+```python out
+{'en': 'Unable to import %1 using the OFX importer plugin. This file is not the correct format.',
+ 'fr': "Impossible d'importer %1 en utilisant le module d'extension d'importation OFX. Ce fichier n'a pas un format correct."}
+```
+
+然而，我們的預訓練模型堅持使用簡練而熟悉的英文單詞：
+
+```py
+translator(
+ "Unable to import %1 using the OFX importer plugin. This file is not the correct format."
+)
+```
+
+```python out
+[{'translation_text': "Impossible d'importer %1 en utilisant le plugin d'importateur OFX. Ce fichier n'est pas le bon format."}]
+```
+
+看看我們的微調模型是否能識別數據集的這些特殊性。（劇透警告：它會）。
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+"""
+
+article = "Check out [the original Rick and Morty Bot](https://huggingface.co/spaces/kingabzpro/Rick_and_Morty_Bot) that this demo is based off of."
+
+gr.Interface(
+ fn=predict,
+ inputs="textbox",
+ outputs="text",
+ title=title,
+ description=description,
+ article=article,
+ examples=[["What are you doing?"], ["Where should we time travel to?"]],
+).launch()
+```
+
+使用上面的選項，我們最終得到了一個更完整的界面。 試試下面的界面：
+
+
+
+### 使用臨時鏈接分享您的演示
+現在我們已經有了機器學習模型的工作演示，讓我們學習如何輕鬆共享指向我們界面的鏈接。
+通過在 `launch()` 方法中設置 `share=True` 可以輕鬆地公開共享接口：
+
+```python
+gr.Interface(classify_image, "image", "label").launch(share=True)
+```
+
+這會生成一個公開的、可共享的鏈接，您可以將其發送給任何人！ 當您發送此鏈接時，另一方的用戶可以在瀏覽器中試用該模型長達 72 小時。 因為處理發生在您的設備上（只要您的設備保持開啟！），您不必擔心打包任何依賴項。 如果您使用 Google Colab 筆記本工作，則始終會自動創建共享鏈接。 它通常看起來像這樣：**XXXXX.gradio.app**。 雖然鏈接是通過 Gradio 鏈接提供的，但我們只是您本地服務器的代理，不會存儲通過接口發送的任何數據。
+
+但是請記住，這些鏈接是可公開訪問的，這意味著任何人都可以使用您的模型進行預測！ 因此，請確保不要通過您編寫的函數公開任何敏感信息，或允許在您的設備上發生任何關鍵更改。 如果設置 `share=False`（默認值），則僅創建本地鏈接。
+
+### 在 Hugging Face Spaces 上託管您的演示
+
+可以傳遞給同事的共享鏈接很酷，但是如何永久託管您的演示並讓它存在於互聯網上自己的“空間”中？
+
+Hugging Face Spaces 提供了在互聯網上永久託管 Gradio 模型的基礎設施，**免費**！ Spaces 允許您創建並推送到（公共或私人）存儲庫，
+你的 Gradio 在哪裡
+接口代碼將存在於 `app.py` 文件中。 [閱讀分步教程](https://huggingface.co/blog/gradio-spaces) 開始使用，或觀看下面的示例視頻。
+
+
+
+
+
+
+
+
+
+
+