Bump release

.github/workflows/build_documentation.yml

@@ -16,4 +16,4 @@ jobs:
       additional_args: --not_python_module
       languages: ar bn de en es fa fr gj he hi id it ja ko pt ru th tr vi zh-CN zh-TW
     secrets:
-      token: ${{ secrets.HUGGINGFACE_PUSH }}
+      hf_token: ${{ secrets.HF_DOC_BUILD_PUSH }}

.github/workflows/build_pr_documentation.yml

@@ -17,4 +17,3 @@ jobs:
       path_to_docs: course/chapters/
       additional_args: --not_python_module
       languages: ar bn de en es fa fr gj he hi id it ja ko pt ru th tr vi zh-CN zh-TW
-      hub_base_path: https://moon-ci-docs.huggingface.co

.github/workflows/upload_pr_documentation.yml

@@ -0,0 +1,17 @@
+name: Upload PR Documentation
+
+on:
+  workflow_run:
+    workflows: ["Build PR Documentation"]
+    types:
+      - completed
+
+jobs:
+  build:
+    uses: huggingface/doc-builder/.github/workflows/upload_pr_documentation.yml@main
+    with:
+      package_name: course
+      hub_base_path: https://moon-ci-docs.huggingface.co
+    secrets:
+      hf_token: ${{ secrets.HF_DOC_BUILD_PUSH }}
+      comment_bot_token: ${{ secrets.COMMENT_BOT_TOKEN }}

chapters/de/chapter3/2.mdx

@@ -84,7 +84,7 @@ In diesem Abschnitt verwenden wir den MRPC-Datensatz (Microsoft Research Paraphr
 <Youtube id="W_gMJF0xomE"/>
 {/if}
 
-Das Hub enthält nicht nur Modelle; Es hat auch mehrere Datensätze in vielen verschiedenen Sprachen. Du kannst die Datensätze [hier](https://huggingface.co/datasets) durchsuchen, und wir empfehlen, einen weiteren Datensatz zu laden und zu verarbeiten, sobald Sie diesen Abschnitt abgeschlossen haben (die Dokumentation befindet sich [hier](https: //huggingface.co/docs/datasets/loading_datasets.html#from-the-huggingface-hub)). Aber jetzt konzentrieren wir uns auf den MRPC-Datensatz! Dies ist einer der 10 Datensätze, aus denen sich das [GLUE-Benchmark](https://gluebenchmark.com/) zusammensetzt. Dies ist ein akademisches Benchmark, das verwendet wird, um die Performance von ML-Modellen in 10 verschiedenen Textklassifizierungsaufgaben zu messen.
+Das Hub enthält nicht nur Modelle; Es hat auch mehrere Datensätze in vielen verschiedenen Sprachen. Du kannst die Datensätze [hier](https://huggingface.co/datasets) durchsuchen, und wir empfehlen, einen weiteren Datensatz zu laden und zu verarbeiten, sobald Sie diesen Abschnitt abgeschlossen haben (die Dokumentation befindet sich [hier](https://huggingface.co/docs/datasets/loading)). Aber jetzt konzentrieren wir uns auf den MRPC-Datensatz! Dies ist einer der 10 Datensätze, aus denen sich das [GLUE-Benchmark](https://gluebenchmark.com/) zusammensetzt. Dies ist ein akademisches Benchmark, das verwendet wird, um die Performance von ML-Modellen in 10 verschiedenen Textklassifizierungsaufgaben zu messen.
 
 Die Bibliothek 🤗 Datasets bietet einen leichten Befehl zum Herunterladen und Caching eines Datensatzes aus dem Hub. Wir können den MRPC-Datensatz wie folgt herunterladen:
 

chapters/en/chapter1/10.mdx

@@ -241,7 +241,7 @@ result = classifier("This is a course about the Transformers library")
 	choices={[
 		{
 			text: "The model is a fine-tuned version of a pretrained model and it picked up its bias from it.",
-			explain: "When applying Transfer Learning, the bias in the pretrained model used perspires in the fine-tuned model.",
+			explain: "When applying Transfer Learning, the bias in the pretrained model used persists in the fine-tuned model.",
 			correct: true
 		},
 		{

chapters/en/chapter1/4.mdx

@@ -97,7 +97,7 @@ By the way, you can evaluate the carbon footprint of your models' training throu
 
 This pretraining is usually done on very large amounts of data. Therefore, it requires a very large corpus of data, and training can take up to several weeks.
 
-*Fine-tuning*, on the other hand, is the training done **after** a model has been pretrained. To perform fine-tuning, you first acquire a pretrained language model, then perform additional training with a dataset specific to your task. Wait -- why not simply train directly for the final task? There are a couple of reasons:
+*Fine-tuning*, on the other hand, is the training done **after** a model has been pretrained. To perform fine-tuning, you first acquire a pretrained language model, then perform additional training with a dataset specific to your task. Wait -- why not simply train the model for your final use case from the start (**scratch**)? There are a couple of reasons:
 
 *  The pretrained model was already trained on a dataset that has some similarities with the fine-tuning dataset. The fine-tuning process is thus able to take advantage of knowledge acquired by the initial model during pretraining (for instance, with NLP problems, the pretrained model will have some kind of statistical understanding of the language you are using for your task). 
 *  Since the pretrained model was already trained on lots of data, the fine-tuning requires way less data to get decent results.
@@ -144,7 +144,7 @@ We will dive into those architectures independently in later sections.
 
 A key feature of Transformer models is that they are built with special layers called *attention layers*. In fact, the title of the paper introducing the Transformer architecture was ["Attention Is All You Need"](https://arxiv.org/abs/1706.03762)! We will explore the details of attention layers later in the course; for now, all you need to know is that this layer will tell the model to pay specific attention to certain words in the sentence you passed it (and more or less ignore the others) when dealing with the representation of each word.
 
-To put this into context, consider the task of translating text from English to French. Given the input "You like this course", a translation model will need to also attend to the adjacent word "You" to get the proper translation for the word "like", because in French the verb "like" is conjugated differently depending on the subject. The rest of the sentence, however, is not useful for the translation of that word. In the same vein, when translating "this" the model will also need to pay attention to the word "course", because "this" translates differently depending on whether the associated noun is masculine or feminine. Again, the other words in the sentence will not matter for the translation of "this". With more complex sentences (and more complex grammar rules), the model would need to pay special attention to words that might appear farther away in the sentence to properly translate each word.
+To put this into context, consider the task of translating text from English to French. Given the input "You like this course", a translation model will need to also attend to the adjacent word "You" to get the proper translation for the word "like", because in French the verb "like" is conjugated differently depending on the subject. The rest of the sentence, however, is not useful for the translation of that word. In the same vein, when translating "this" the model will also need to pay attention to the word "course", because "this" translates differently depending on whether the associated noun is masculine or feminine. Again, the other words in the sentence will not matter for the translation of "course". With more complex sentences (and more complex grammar rules), the model would need to pay special attention to words that might appear farther away in the sentence to properly translate each word.
 
 The same concept applies to any task associated with natural language: a word by itself has a meaning, but that meaning is deeply affected by the context, which can be any other word (or words) before or after the word being studied.
 

chapters/en/chapter1/5.mdx

@@ -15,8 +15,8 @@ Encoder models are best suited for tasks requiring an understanding of the full
 
 Representatives of this family of models include:
 
-- [ALBERT](https://huggingface.co/transformers/model_doc/albert.html)
-- [BERT](https://huggingface.co/transformers/model_doc/bert.html)
-- [DistilBERT](https://huggingface.co/transformers/model_doc/distilbert.html)
-- [ELECTRA](https://huggingface.co/transformers/model_doc/electra.html)
-- [RoBERTa](https://huggingface.co/transformers/model_doc/roberta.html)
+- [ALBERT](https://huggingface.co/docs/transformers/model_doc/albert)
+- [BERT](https://huggingface.co/docs/transformers/model_doc/bert)
+- [DistilBERT](https://huggingface.co/docs/transformers/model_doc/distilbert)
+- [ELECTRA](https://huggingface.co/docs/transformers/model_doc/electra)
+- [RoBERTa](https://huggingface.co/docs/transformers/model_doc/roberta)

chapters/en/chapter2/5.mdx

@@ -329,7 +329,7 @@ With Transformer models, there is a limit to the lengths of the sequences we can
 - Use a model with a longer supported sequence length.
 - Truncate your sequences.
 
-Models have different supported sequence lengths, and some specialize in handling very long sequences. [Longformer](https://huggingface.co/transformers/model_doc/longformer.html) is one example, and another is [LED](https://huggingface.co/transformers/model_doc/led.html). If you're working on a task that requires very long sequences, we recommend you take a look at those models.
+Models have different supported sequence lengths, and some specialize in handling very long sequences. [Longformer](https://huggingface.co/docs/transformers/model_doc/longformer) is one example, and another is [LED](https://huggingface.co/docs/transformers/model_doc/led). If you're working on a task that requires very long sequences, we recommend you take a look at those models.
 
 Otherwise, we recommend you truncate your sequences by specifying the `max_sequence_length` parameter:
 

chapters/en/chapter3/2.mdx

@@ -84,7 +84,7 @@ In this section we will use as an example the MRPC (Microsoft Research Paraphras
 <Youtube id="W_gMJF0xomE"/>
 {/if}
 
-The Hub doesn't just contain models; it also has multiple datasets in lots of different languages. You can browse the datasets [here](https://huggingface.co/datasets), and we recommend you try to load and process a new dataset once you have gone through this section (see the general documentation [here](https://huggingface.co/docs/datasets/loading_datasets.html#from-the-huggingface-hub)). But for now, let's focus on the MRPC dataset! This is one of the 10 datasets composing the [GLUE benchmark](https://gluebenchmark.com/), which is an academic benchmark that is used to measure the performance of ML models across 10 different text classification tasks.
+The Hub doesn't just contain models; it also has multiple datasets in lots of different languages. You can browse the datasets [here](https://huggingface.co/datasets), and we recommend you try to load and process a new dataset once you have gone through this section (see the general documentation [here](https://huggingface.co/docs/datasets/loading)). But for now, let's focus on the MRPC dataset! This is one of the 10 datasets composing the [GLUE benchmark](https://gluebenchmark.com/), which is an academic benchmark that is used to measure the performance of ML models across 10 different text classification tasks.
 
 The 🤗 Datasets library provides a very simple command to download and cache a dataset on the Hub. We can download the MRPC dataset like this:
 

chapters/en/chapter3/6.mdx

@@ -211,7 +211,7 @@ Test what you learned in this chapter!
 			explain: "This is what we did with <code>Trainer</code>, not the 🤗 Accelerate library. Try again!"
 		},
 		{
-			text: "It makes our training loops work on distributed strategies",
+			text: "It makes our training loops work on distributed strategies.",
 			explain: "Correct! With 🤗 Accelerate, your training loops will work for multiple GPUs and TPUs.",
             correct: true
 		},

chapters/en/chapter6/5.mdx

@@ -97,7 +97,7 @@ Let's take the example we used during training, with the three merge rules learn
 ("h", "ug") -> "hug"
 ```
 
-The word `"bug"` will be tokenized as `["b", "ug"]`. `"mug"`, however, will be tokenized as `["[UNK]", "ug"]` since the letter `"m"` was not in the base vocabulary. Likewise, the word `"thug"` will be tokenized as `["[UNK]", "hug"]`: the letter `"t"` is not in the base vocabulary, and applying the merge rules results first in `"u"` and `"g"` being merged and then `"hu"` and `"g"` being merged.
+The word `"bug"` will be tokenized as `["b", "ug"]`. `"mug"`, however, will be tokenized as `["[UNK]", "ug"]` since the letter `"m"` was not in the base vocabulary. Likewise, the word `"thug"` will be tokenized as `["[UNK]", "hug"]`: the letter `"t"` is not in the base vocabulary, and applying the merge rules results first in `"u"` and `"g"` being merged and then `"h"` and `"ug"` being merged.
 
 <Tip>
 

chapters/en/chapter6/7.mdx

@@ -58,7 +58,7 @@ So, the sum of all frequencies is 210, and the probability of the subword `"ug"`
 
 <Tip>
 
-✏️ **Now your turn!** Write the code to compute the the frequencies above and double-check that the results shown are correct, as well as the total sum.
+✏️ **Now your turn!** Write the code to compute the frequencies above and double-check that the results shown are correct, as well as the total sum.
 
 </Tip>
 

chapters/en/chapter7/3.mdx

@@ -347,7 +347,7 @@ print(f"'>>> Concatenated reviews length: {total_length}'")
 '>>> Concatenated reviews length: 951'
 ```
 
-Great, the total length checks out -- so now let's split the concatenated reviews into chunks of the size given by `block_size`. To do so, we iterate over the features in `concatenated_examples` and use a list comprehension to create slices of each feature. The result is a dictionary of chunks for each feature:
+Great, the total length checks out -- so now let's split the concatenated reviews into chunks of the size given by `chunk_size`. To do so, we iterate over the features in `concatenated_examples` and use a list comprehension to create slices of each feature. The result is a dictionary of chunks for each feature:
 
 ```python
 chunks = {
@@ -1035,7 +1035,7 @@ Neat -- our model has clearly adapted its weights to predict words that are more
 
 <Youtube id="0Oxphw4Q9fo"/>
 
-This wraps up our first experiment with training a language model. In [section 6](/course/en/chapter7/section6) you'll learn how to train an auto-regressive model like GPT-2 from scratch; head over there if you'd like to see how you can pretrain your very own Transformer model!
+This wraps up our first experiment with training a language model. In [section 6](/course/en/chapter7/6) you'll learn how to train an auto-regressive model like GPT-2 from scratch; head over there if you'd like to see how you can pretrain your very own Transformer model!
 
 <Tip>
 

chapters/en/chapter7/4.mdx

@@ -114,7 +114,7 @@ split_datasets["train"][1]["translation"]
  'fr': 'Par défaut, développer les fils de discussion'}
 ```
 
-We get a dictionary with two sentences in the pair of languages we requested. One particularity of this dataset full of technical computer science terms is that they are all fully translated in French. However, French engineers are often lazy and leave most computer science-specific words in English when they talk. Here, for instance, the word "threads" might well appear in a French sentence, especially in a technical conversation; but in this dataset it has been translated into the more correct "fils de discussion." The pretrained model we use, which has been pretrained on a larger corpus of French and English sentences, takes the easier option of leaving the word as is:
+We get a dictionary with two sentences in the pair of languages we requested. One particularity of this dataset full of technical computer science terms is that they are all fully translated in French. However, French engineers leave most computer science-specific words in English when they talk. Here, for instance, the word "threads" might well appear in a French sentence, especially in a technical conversation; but in this dataset it has been translated into the more correct "fils de discussion." The pretrained model we use, which has been pretrained on a larger corpus of French and English sentences, takes the easier option of leaving the word as is:
 
 ```py
 from transformers import pipeline

chapters/en/chapter7/6.mdx

@@ -870,7 +870,6 @@ for epoch in range(num_train_epochs):
         if step % 100 == 0:
             accelerator.print(
                 {
-                    "lr": get_lr(),
                     "samples": step * samples_per_step,
                     "steps": completed_steps,
                     "loss/train": loss.item() * gradient_accumulation_steps,
@@ -912,4 +911,4 @@ And that's it -- you now have your own custom training loop for causal language
 
 </Tip>
 
-{/if}
+{/if}

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**
 
-<iframe src="https://huggingface.co/spaces/Curranj/Words_To_SQL" frameBorder="0" height="640" title="Gradio app" class="container p-0 flex-grow space-iframe" allow="accelerometer; ambient-light-sensor; autoplay; battery; camera; document-domain; encrypted-media; fullscreen; geolocation; gyroscope; layout-animations; legacy-image-formats; magnetometer; microphone; midi; oversized-images; payment; picture-in-picture; publickey-credentials-get; sync-xhr; usb; vr ; wake-lock; xr-spatial-tracking" sandbox="allow-forms allow-modals allow-popups allow-popups-to-escape-sandbox allow-same-origin allow-scripts allow-downloads"></iframe>
+<iframe src="https://curranj-words-to-sql.hf.space" frameBorder="0" height="640" title="Gradio app" class="container p-0 flex-grow space-iframe" allow="accelerometer; ambient-light-sensor; autoplay; battery; camera; document-domain; encrypted-media; fullscreen; geolocation; gyroscope; layout-animations; legacy-image-formats; magnetometer; microphone; midi; oversized-images; payment; picture-in-picture; publickey-credentials-get; sync-xhr; usb; vr ; wake-lock; xr-spatial-tracking" sandbox="allow-forms allow-modals allow-popups allow-popups-to-escape-sandbox allow-same-origin allow-scripts allow-downloads"></iframe>

chapters/es/_toctree.yml

@@ -39,15 +39,25 @@
     title: ¡Haz completado el uso básico!
   - local: chapter2/8
     title: Quiz de final de capítulo
+    quiz: 2
 
 - title: 3. Ajuste (fine-tuning) de un modelo preentrenado
   sections:
   - local: chapter3/1
     title: Introducción
   - local: chapter3/2
     title: Procesamiento de los datos
+  - local: chapter3/3
+    title: Ajuste de un modelo con la API Trainer
+  - local: chapter3/3_tf
+    title: Ajuste de un modelo con Keras
   - local: chapter3/4
     title: Entrenamiento completo
+  - local: chapter3/5
+    title: Ajuste de modelos, ¡hecho!
+  - local: chapter3/6
+    title: Quiz de final de capítulo
+    quiz: 3
 
 - title: 5. La librería 🤗 Datasets
   sections:
@@ -66,9 +76,36 @@
   - local: chapter5/7
     title: 🤗 Datasets, ¡listo!
   - local: chapter5/8
-    title: Quiz
+    title: Quiz de final de capítulo
     quiz: 5
 
+
+- title: 6. La librería 🤗 Tokenizers
+  sections:
+  - local: chapter6/1
+    title: Introducción
+  - local: chapter6/2
+    title: Entrenar un nuevo tokenizador a partir de uno existente
+  - local: chapter6/3
+    title: Los poderes especiales de los Tokenizadores Rápidos (Fast tokenizers)
+  - local: chapter6/3b
+    title: Tokenizadores Rápidos en un Pipeline de Question-Answering
+  - local: chapter6/4
+    title: Normalización y pre-tokenización
+  - local: chapter6/5
+    title: Tokenización por Codificación Byte-Pair
+  - local: chapter6/6
+    title: Tokenización WordPiece
+  - local: chapter6/7
+    title: Tokenización Unigram
+  - local: chapter6/8
+    title: Construir un tokenizador, bloque por bloque
+  - local: chapter6/9
+    title: Tokenizadores, listo!
+  - local: chapter6/10
+    title: Quiz de final de capítulo
+    quiz: 1
+
 - title: 8. ¿Cómo solicitar ayuda?
   sections:
   - local: chapter8/1