+
+
+
+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")
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+The [🤗 Transformers library](https://github.com/huggingface/transformers) provides the functionality to create and use those shared models. The [Model Hub](https://huggingface.co/models) contains thousands of pretrained models that anyone can download and use. You can also upload your own models to the Hub!
+
+
-
-The [🤗 Transformers library](https://github.com/huggingface/transformers) provides the functionality to create and use those shared models. The [Model Hub](https://huggingface.co/models) contains thousands of pretrained models that anyone can download and use. You can also upload your own models to the Hub!
+
+[🤗 Transformers 库](https://github.com/huggingface/transformers)提供了创建和使用这些共享模型的功能。[模型中心（hub）](https://huggingface.co/models)包含数千个任何人都可以下载和使用的预训练模型。您还可以将自己的模型上传到 Hub！
+
+
+
+
+
+
+ 
+
+ 
+
+ 
+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)
+```
+
+
-
-
-
-
+
+
+
+
-
-
-
-
-
-
+
+
+
+
+
+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)
-```
-
-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)
+```
+
+
-
-
-
-
+
+
+
+
-
-
-
-
-
-
+
+
+
+
+
+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)
-```
-
-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)
+```
+
+
-
-`` et '' avec " et toute séquence de deux espaces ou plus par un seul espace, ainsi que la suppression des accents dans les textes à catégoriser.
-
-Le pré-*tokenizer* à utiliser pour tout *tokenizer SentencePiece* est `Metaspace` :
-
-```python
-tokenizer.pre_tokenizer = pre_tokenizers.Metaspace()
-```
-
-Nous pouvons jeter un coup d'oeil à la pré-tokénisation d'un exemple de texte comme précédemment :
-
-```python
-tokenizer.pre_tokenizer.pre_tokenize_str("Let's test the pre-tokenizer!")
-```
-
-```python out
-[("▁Let's", (0, 5)), ('▁test', (5, 10)), ('▁the', (10, 14)), ('▁pre-tokenizer!', (14, 29))]
-```
-
-Vient ensuite le modèle, qui doit être entraîné. XLNet possède un certain nombre de *tokens* spéciaux :
-
-```python
-special_tokens = ["
+
+`` et '' avec " et toute séquence de deux espaces ou plus par un seul espace, ainsi que la suppression des accents dans les textes à catégoriser.
+
+Le pré-*tokenizer* à utiliser pour tout *tokenizer SentencePiece* est `Metaspace` :
+
+```python
+tokenizer.pre_tokenizer = pre_tokenizers.Metaspace()
+```
+
+Nous pouvons jeter un coup d'oeil à la pré-tokénisation d'un exemple de texte comme précédemment :
+
+```python
+tokenizer.pre_tokenizer.pre_tokenize_str("Let's test the pre-tokenizer!")
+```
+
+```python out
+[("▁Let's", (0, 5)), ('▁test', (5, 10)), ('▁the', (10, 14)), ('▁pre-tokenizer!', (14, 29))]
+```
+
+Vient ensuite le modèle, qui doit être entraîné. XLNet possède un certain nombre de *tokens* spéciaux :
+
+```python
+special_tokens = ["
-
-
-
-Vous pouvez trouver le modèle que nous allons entraîner et télécharger sur le *Hub* et vérifier ses prédictions [ici](https://huggingface.co/huggingface-course/bert-finetuned-ner?text=My+nom+est+Sylvain+et+je+travaille+à+Hugging+Face+in+Brooklyn).
-
-## Préparation des données
-
-Tout d'abord, nous avons besoin d'un jeu de données adapté à la classification des *tokens*. Dans cette section, nous utiliserons le jeu de données [CoNLL-2003](https://huggingface.co/datasets/conll2003), qui contient des articles de presse de Reuters.
-
-
+
+
+
+Vous pouvez trouver le modèle que nous allons entraîner et télécharger sur le *Hub* et vérifier ses prédictions [ici](https://huggingface.co/huggingface-course/bert-finetuned-ner?text=My+nom+est+Sylvain+et+je+travaille+à+Hugging+Face+in+Brooklyn).
+
+## Préparation des données
+
+Tout d'abord, nous avons besoin d'un jeu de données adapté à la classification des *tokens*. Dans cette section, nous utiliserons le jeu de données [CoNLL-2003](https://huggingface.co/datasets/conll2003), qui contient des articles de presse de Reuters.
+
+
-
-
-
-Comme dans les sections précédentes, vous pouvez trouver le modèle réel que nous allons entraîner et télécharger sur le *Hub* en utilisant le code ci-dessous et vérifier ses prédictions [ici](https://huggingface.co/huggingface-course/marian-finetuned-kde4-en-to-fr?text=This+plugin+allows+you+to+automatically+translate+web+pages+between+several+languages.).
-
-## Préparation des données
-
-Pour affiner ou entraîner un modèle de traduction à partir de zéro, nous avons besoin d'un jeu de données adapté à cette tâche. Comme mentionné précédemment, nous utiliserons le jeu de données [KDE4](https://huggingface.co/datasets/kde4) dans cette section, mais vous pouvez adapter le code pour utiliser vos propres données assez facilement, tant que vous avez des paires de phrases dans les deux langues que vous voulez traduire de et vers. Reportez-vous au [Chapitre 5](/course/fr/chapter5) si vous avez besoin d'un rappel sur la façon de charger vos données personnalisées dans un `Dataset`.
-
-### Le jeu de données KDE4
-
-Comme d'habitude, nous téléchargeons notre jeu de données en utilisant la fonction `load_dataset()` :
-
-```py
-from datasets import load_dataset, load_metric
-
-raw_datasets = load_dataset("kde4", lang1="en", lang2="fr")
-```
-
-Si vous souhaitez travailler avec une autre paire de langues, vous pouvez les spécifier par leurs codes. Au total, 92 langues sont disponibles pour cet ensemble de données ; vous pouvez les voir toutes en développant les étiquettes de langue sur sa [fiche](https://huggingface.co/datasets/kde4).
-
-
-
-Jetons un coup d'œil au jeu de données :
-
-```py
-raw_datasets
-```
-
-```python out
-DatasetDict({
- train: Dataset({
- features: ['id', 'translation'],
- num_rows: 210173
- })
-})
-```
-
-Nous avons 210 173 paires de phrases, mais dans un seul split, donc nous devrons créer notre propre ensemble de validation. Comme nous l'avons vu dans le [Chapitre 5](/course/fr/chapter5), un `Dataset` possède une méthode `train_test_split()` qui peut nous aider. Nous allons fournir une graine pour la reproductibilité :
-
-```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
- })
-})
-```
-
-Nous pouvons renommer la clé "test" en "validation" comme ceci :
-
-```py
-split_datasets["validation"] = split_datasets.pop("test")
-```
-
-Examinons maintenant un élément de ce jeu de données :
-
-```py
-split_datasets["train"][1]["translation"]
-```
-
-```python out
-{'en': 'Default to expanded threads',
- 'fr': 'Par défaut, développer les fils de discussion'}
-```
-
-Nous obtenons un dictionnaire contenant deux phrases dans la paire de langues demandée.
-Une particularité de ce jeu de données rempli de termes techniques informatiques est qu'ils sont tous entièrement traduits en français. Cependant, les ingénieurs français sont souvent paresseux et laissent la plupart des mots spécifiques à l'informatique en anglais lorsqu'ils parlent. Ici, par exemple, le mot "threads" pourrait très bien apparaître dans une phrase française, surtout dans une conversation technique. Mais dans ce jeu de données, il a été traduit par le plus correct "fils de discussion". Le modèle pré-entraîné que nous utilisons, qui a été pré-entraîné sur un plus grand corpus de phrases françaises et anglaises, prend l'option la plus facile de laisser le mot tel quel :
-
-```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'}]
-```
-
-Un autre exemple de ce comportement peut être observé avec le mot "*plugin*", qui n'est pas officiellement un mot français mais que la plupart des locuteurs natifs comprendront et ne prendront pas la peine de traduire.
-Dans le jeu de données KDE4, ce mot a été traduit en français par le plus officiel "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."}
-```
-
-Notre modèle pré-entraîné, cependant, s'en tient au mot anglais compact et familier :
-
-```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."}]
-```
-
-Il sera intéressant de voir si notre modèle *finetuné* tient compte de ces particularités de l'ensemble de données (alerte *spoiler* : il le fera).
-
-
+
+
+
+Comme dans les sections précédentes, vous pouvez trouver le modèle réel que nous allons entraîner et télécharger sur le *Hub* en utilisant le code ci-dessous et vérifier ses prédictions [ici](https://huggingface.co/huggingface-course/marian-finetuned-kde4-en-to-fr?text=This+plugin+allows+you+to+automatically+translate+web+pages+between+several+languages.).
+
+## Préparation des données
+
+Pour affiner ou entraîner un modèle de traduction à partir de zéro, nous avons besoin d'un jeu de données adapté à cette tâche. Comme mentionné précédemment, nous utiliserons le jeu de données [KDE4](https://huggingface.co/datasets/kde4) dans cette section, mais vous pouvez adapter le code pour utiliser vos propres données assez facilement, tant que vous avez des paires de phrases dans les deux langues que vous voulez traduire de et vers. Reportez-vous au [Chapitre 5](/course/fr/chapter5) si vous avez besoin d'un rappel sur la façon de charger vos données personnalisées dans un `Dataset`.
+
+### Le jeu de données KDE4
+
+Comme d'habitude, nous téléchargeons notre jeu de données en utilisant la fonction `load_dataset()` :
+
+```py
+from datasets import load_dataset, load_metric
+
+raw_datasets = load_dataset("kde4", lang1="en", lang2="fr")
+```
+
+Si vous souhaitez travailler avec une autre paire de langues, vous pouvez les spécifier par leurs codes. Au total, 92 langues sont disponibles pour cet ensemble de données ; vous pouvez les voir toutes en développant les étiquettes de langue sur sa [fiche](https://huggingface.co/datasets/kde4).
+
+
+
+Jetons un coup d'œil au jeu de données :
+
+```py
+raw_datasets
+```
+
+```python out
+DatasetDict({
+ train: Dataset({
+ features: ['id', 'translation'],
+ num_rows: 210173
+ })
+})
+```
+
+Nous avons 210 173 paires de phrases, mais dans un seul split, donc nous devrons créer notre propre ensemble de validation. Comme nous l'avons vu dans le [Chapitre 5](/course/fr/chapter5), un `Dataset` possède une méthode `train_test_split()` qui peut nous aider. Nous allons fournir une graine pour la reproductibilité :
+
+```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
+ })
+})
+```
+
+Nous pouvons renommer la clé "test" en "validation" comme ceci :
+
+```py
+split_datasets["validation"] = split_datasets.pop("test")
+```
+
+Examinons maintenant un élément de ce jeu de données :
+
+```py
+split_datasets["train"][1]["translation"]
+```
+
+```python out
+{'en': 'Default to expanded threads',
+ 'fr': 'Par défaut, développer les fils de discussion'}
+```
+
+Nous obtenons un dictionnaire contenant deux phrases dans la paire de langues demandée.
+Une particularité de ce jeu de données rempli de termes techniques informatiques est qu'ils sont tous entièrement traduits en français. Cependant, les ingénieurs français sont souvent paresseux et laissent la plupart des mots spécifiques à l'informatique en anglais lorsqu'ils parlent. Ici, par exemple, le mot "threads" pourrait très bien apparaître dans une phrase française, surtout dans une conversation technique. Mais dans ce jeu de données, il a été traduit par le plus correct "fils de discussion". Le modèle pré-entraîné que nous utilisons, qui a été pré-entraîné sur un plus grand corpus de phrases françaises et anglaises, prend l'option la plus facile de laisser le mot tel quel :
+
+```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'}]
+```
+
+Un autre exemple de ce comportement peut être observé avec le mot "*plugin*", qui n'est pas officiellement un mot français mais que la plupart des locuteurs natifs comprendront et ne prendront pas la peine de traduire.
+Dans le jeu de données KDE4, ce mot a été traduit en français par le plus officiel "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."}
+```
+
+Notre modèle pré-entraîné, cependant, s'en tient au mot anglais compact et familier :
+
+```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."}]
+```
+
+Il sera intéressant de voir si notre modèle *finetuné* tient compte de ces particularités de l'ensemble de données (alerte *spoiler* : il le fera).
+
+
-
-
-
-
+
+
+
+
-
-
+
+
-
-
-
-
+
+
+
+
+
+
-
-
+
+d'analyse de sentiment (sentiment-analysis dans la documentation d'Hugging-Face)."
+ explain: "Cela correspondrait au pipeline d'analyse de sentiment (sentiment-analysis dans la documentation d'Hugging-Face)."
},
{
text: "Il renvoie un texte généré qui complète cette phrase.",
- explain: "C'est incorrect. Cela correspondrait au pipeline de génération de texte (text-generation dans la documentation d'Hugging-Face)."
+ explain: "Cela correspondrait au pipeline de génération de texte (text-generation dans la documentation d'Hugging-Face)."
},
{
text: "Il renvoie les entités nommées dans cette phrase, telles que les personnes, les organisations ou lieux.",
@@ -70,16 +70,16 @@ result = filler("...")
choices={[
{
text: "This <mask> has been waiting for you. # Ce <mask> vous attend.",
- explain: "Ceci est incorrect. Regardez la description du modèle bert-base-cased et essayez de trouver votre erreur."
+ explain: "Regardez la description du modèle bert-base-cased et essayez de trouver votre erreur."
},
{
text: "This [MASK] has been waiting for you. # Ce [MASK] vous attend.",
- explain: "Correct! Le modèle utilise [MASK] comme mot-masque.",
+ explain: "Le modèle utilise [MASK] comme mot-masque.",
correct: true
},
{
text: "This man has been waiting for you. # Cet homme vous attend.",
- explain: "Ceci est incorrect car ce pipeline permet de remplacer les mot manquants donc il a besoin d'un mot-masque."
+ explain: "Ce pipeline permet de remplacer les mot manquants donc il a besoin d'un mot-masque."
}
]}
/>
@@ -99,12 +99,12 @@ result = classifier(
choices={[
{
text: "Ce pipeline nécessite que des étiquettes soient données pour classifier ce texte.",
- explain: "Vrai. Le code doit inclure candidate_labels=[...].",
+ explain: "Le code doit inclure candidate_labels=[...].",
correct: true
},
{
text: "Ce pipeline nécessite que des phrases soient données, pas juste une phrase.",
- explain: "C'est incorrect, bien que ce pipeline puisse prendre une liste de phrases à traiter (comme tous les autres pipelines)."
+ explain: "Bien que ce pipeline puisse prendre une liste de phrases à traiter (comme tous les autres pipelines)."
},
{
text: "La bibliothèque 🤗 Transformers est cassée, comme d'habitude.",
@@ -112,7 +112,7 @@ result = classifier(
},
{
text: "Ce pipeline nécessite des phrases plus longues, celle-ci est trop courte.",
- explain: "C'est incorrect. Notez que si un texte est très long, il est tronqué par le pipeline."
+ explain: "Notez que si un texte est très long, il est tronqué par le pipeline."
}
]}
/>
@@ -127,12 +127,12 @@ result = classifier(
},
{
text: "Transférer les connaissances d'un modèle pré-entraîné vers un nouveau modèle en initialisant ce second modèle avec les poids du premier.",
- explain: "Correct. Quand le second modèle est entraîné sur une nouvelle tâche, il transfère les connaissances du premier modèle.",
+ explain: "Quand le second modèle est entraîné sur une nouvelle tâche, il transfère les connaissances du premier modèle.",
correct: true
},
{
text: "Transférer les connaissances d'un modèle pré-entraîné vers un nouveau modèle en construisant le second modèle avec la même architecture que le premier.",
- explain: "C'est incorrect, l'architecture correspond uniquement à la structure du modèle, pas à ses connaissances. Il n'y a donc pas de connaissances à transférer dans ce cas.",
+ explain: "L'architecture correspond uniquement à la structure du modèle, pas à ses connaissances. Il n'y a donc pas de connaissances à transférer dans ce cas.",
}
]}
/>
@@ -144,7 +144,7 @@ result = classifier(
choices={[
{
text: "Vrai",
- explain: "Correct, le pré-entraînement est autosupervisé, ce qui signifie que les étiquettes sont créées automatiquement à partir des données d'entrée (comme prédire le mot suivant ou remplacer des mots masqués).",
+ explain: "Le pré-entraînement est autosupervisé, ce qui signifie que les étiquettes sont créées automatiquement à partir des données d'entrée (comme prédire le mot suivant ou remplacer des mots masqués).",
correct: true
},
{
diff --git a/chapters/fr/chapter1/2.mdx b/chapters/fr/chapter1/2.mdx
index c93675ec0..ef5803d79 100644
--- a/chapters/fr/chapter1/2.mdx
+++ b/chapters/fr/chapter1/2.mdx
@@ -1,4 +1,4 @@
-# Traitement du langage naturel (NLP pour *Natural Language Processing*)
+# Traitement du langage naturel (NLP pour Natural Language Processing)
Avant de commencer avec les *transformers*, voyons succinctement ce qu'est le traitement du langage naturel et pourquoi il est important.
@@ -8,11 +8,11 @@ Le traitement du langage naturel est un domaine de linguistique et d'apprentissa
La liste suivante regroupe les tâches de NLP les plus courantes, avec pour chacune quelques exemples :
-- **classification de phrases entières** : analyser le sentiment d'un avis, détecter si un email est un spam, déterminer si une phrase est grammaticalement correcte, déterminer si deux phrases sont logiquement reliées ou non, etc.
-- **classification de chaque mot d'une phrase** : identifier les composants grammaticaux d'une phrase (nom, verbe, adjectif), identifier les entités nommées (personne, lieu, organisation), etc.
-- **génération de texte** : compléter le début d'un texte avec un texte généré automatiquement, remplacer les mots manquants ou masqués dans un texte, etc.
-- **extraction d'une réponse à partir d'un texte** : étant donné une question et un contexte extraire la réponse à la question en fonction des informations fournies par le contexte, etc.
-- **génération de nouvelles phrases à partir d'un texte** : traduire un texte dans une autre langue, faire le résumé d'un texte, etc.
+- **Classification de phrases entières** : analyser le sentiment d'un avis, détecter si un email est un spam, déterminer si une phrase est grammaticalement correcte, déterminer si deux phrases sont logiquement reliées ou non, etc.
+- **Classification de chaque mot d'une phrase** : identifier les composants grammaticaux d'une phrase (nom, verbe, adjectif), identifier les entités nommées (personne, lieu, organisation), etc.
+- **Génération de texte** : compléter le début d'un texte avec un texte généré automatiquement, remplacer les mots manquants ou masqués dans un texte, etc.
+- **Extraction d'une réponse à partir d'un texte** : étant donné une question et un contexte extraire la réponse à la question en fonction des informations fournies par le contexte, etc.
+- **Génération de nouvelles phrases à partir d'un texte** : traduire un texte dans une autre langue, faire le résumé d'un texte, etc.
Le traitement du langage naturel ne se limite pas qu'à la compréhension du texte. Il s'intéresse aussi aux problèmes complexes de reconnaissance de la parole et de vision par ordinateur tels que la génération d'une transcription à partir d'un échantillon audio ou la description d'une image.
diff --git a/chapters/fr/chapter1/3.mdx b/chapters/fr/chapter1/3.mdx
index df63c9e50..beb4b7700 100644
--- a/chapters/fr/chapter1/3.mdx
+++ b/chapters/fr/chapter1/3.mdx
@@ -1,4 +1,4 @@
-# Que peuvent faire les *transformers* ?
+# Que peuvent faire les transformers ?
-La bibliothèque [🤗 *Transformers*](https://github.com/huggingface/transformers) fournit toutes les fonctionnalités nécessaires pour créer et utiliser les modèles partagés. Le [Model Hub](https://huggingface.co/models) contient des milliers de modèles pré-entraînés que n'importe qui peut télécharger et utiliser. Vous pouvez également transférer vos propres modèles vers le Hub !
+La bibliothèque [🤗 *Transformers*](https://github.com/huggingface/transformers) fournit toutes les fonctionnalités nécessaires pour créer et utiliser les modèles partagés. Le [*Hub*](https://huggingface.co/models) contient des milliers de modèles pré-entraînés que n'importe qui peut télécharger et utiliser. Vous pouvez également transférer vos propres modèles vers le Hub !
-## Les *transformers* sont énormes
+## Les transformers sont énormes
En dehors de quelques exceptions (comme DistilBERT), la stratégie générale pour obtenir de meilleure performance consiste à augmenter la taille des modèles ainsi que la quantité de données utilisées pour l'entraînement de ces derniers.
@@ -133,9 +133,9 @@ Nous verrons plus en détails chacune de ces architectures plus tard.
## Les couches d'attention
-Une caractéristique clé des *transformers* est qu'ils sont construits avec des couches spéciales appelées couches d'attention. En fait, le titre du papier introduisant l'architecture *transformer* s'e nome [*Attention Is All You Need*](https://arxiv.org/abs/1706.03762) ! Nous explorerons les détails des couches d'attention plus tard dans le cours. Pour l'instant, tout ce que vous devez savoir est que cette couche indique au modèle de prêter une attention spécifique à certains mots de la phrase que vous lui avez passée (et d'ignorer plus ou moins les autres) lors du traitement de la représentation de chaque mot.
+Une caractéristique clé des *transformers* est qu'ils sont construits avec des couches spéciales appelées couches d'attention. En fait, le titre du papier introduisant l'architecture *transformer* se nomme [*Attention Is All You Need*](https://arxiv.org/abs/1706.03762) ! Nous explorerons les détails des couches d'attention plus tard dans le cours. Pour l'instant, tout ce que vous devez savoir est que cette couche indique au modèle de prêter une attention spécifique à certains mots de la phrase que vous lui avez passée (et d'ignorer plus ou moins les autres) lors du traitement de la représentation de chaque mot.
-Pour mettre cela en contexte, considérons la tâche de traduire un texte de l'anglais au français. Étant donné l'entrée « You like this course », un modèle de traduction devra également s'intéresser au mot adjacent « You » pour obtenir la traduction correcte du mot « like », car en français le verbe « like » se conjugue différemment selon le sujet. Le reste de la phrase n'est en revanche pas utile pour la traduction de ce mot. Dans le même ordre d'idées, pour traduire « this », le modèle devra également faire attention au mot « course » car « this » se traduit différemment selon que le nom associé est masculin ou féminin. Là encore, les autres mots de la phrase n'auront aucune importance pour la traduction de « this ». Avec des phrases plus complexes (et des règles de grammaire plus complexes), le modèle devra prêter une attention particulière aux mots qui pourraient apparaître plus loin dans la phrase pour traduire correctement chaque mot.
+Pour mettre cela en contexte, considérons la tâche de traduire un texte de l'anglais au français. Étant donné l'entrée « *You like this course* », un modèle de traduction devra également s'intéresser au mot adjacent « *You* » pour obtenir la traduction correcte du mot « *like* », car en français le verbe « *like* » se conjugue différemment selon le sujet. Le reste de la phrase n'est en revanche pas utile pour la traduction de ce mot. Dans le même ordre d'idées, pour traduire « *this* », le modèle devra également faire attention au mot « *course* » car « *this* » se traduit différemment selon que le nom associé est masculin ou féminin. Là encore, les autres mots de la phrase n'auront aucune importance pour la traduction de « *this* ». Avec des phrases plus complexes (et des règles de grammaire plus complexes), le modèle devra prêter une attention particulière aux mots qui pourraient apparaître plus loin dans la phrase pour traduire correctement chaque mot.
Le même concept s'applique à toute tâche associée au langage naturel : un mot en lui-même a un sens, mais ce sens est profondément affecté par le contexte, qui peut être n'importe quel autre mot (ou mots) avant ou après le mot étudié.
@@ -158,9 +158,9 @@ Notez que la première couche d'attention dans un bloc décodeur prête attentio
Le *masque d'attention* peut également être utilisé dans l'encodeur/décodeur pour empêcher le modèle de prêter attention à certains mots spéciaux. Par exemple, le mot de remplissage spécial (le *padding*) utilisé pour que toutes les entrées aient la même longueur lors du regroupement de phrases.
-## Architectures contre *checkpoints*
+## Architectures contre checkpoints
-En approfondissant l'étude des *transformers* dans ce cours, vous verrez des mentions d'*architectures* et de *checkpoints* ainsi que de *modèles*. Ces termes ont tous des significations légèrement différentes :
+En approfondissant l'étude des transformers dans ce cours, vous verrez des mentions d'architectures et de checkpoints ainsi que de modèles. Ces termes ont tous des significations légèrement différentes :
* **Architecture** : c'est le squelette du modèle, la définition de chaque couche et chaque opération qui se produit au sein du modèle.
* **Checkpoints** : ce sont les poids qui seront chargés dans une architecture donnée.
diff --git a/chapters/fr/chapter1/8.mdx b/chapters/fr/chapter1/8.mdx
index acf86a09c..e3e3c2310 100644
--- a/chapters/fr/chapter1/8.mdx
+++ b/chapters/fr/chapter1/8.mdx
@@ -23,8 +23,10 @@ print([r["token_str"] for r in result])
```
```python out
-['lawyer', 'carpenter', 'doctor', 'waiter', 'mechanic'] # [avocat, charpentier, médecin, serveur, mécanicien]
-['nurse', 'waitress', 'teacher', 'maid', 'prostitute'] # ["infirmière", "serveuse", "professeur", "femme de chambre", "prostituée"]
+['lawyer', 'carpenter', 'doctor', 'waiter', 'mechanic']
+# [avocat, charpentier, médecin, serveur, mécanicien]
+['nurse', 'waitress', 'teacher', 'maid', 'prostitute']
+# ["infirmière", "serveuse", "professeur", "femme de chambre", "prostituée"]
```
Lorsque l'on demande au modèle de remplacer le mot manquant dans ces deux phrases, il ne propose qu'un seul métier ne portant pas la marque du genre (*waiter*/*waitress* → serveur/serveuse). Les autres sont des métiers habituellement associés à un genre spécifique : et oui malheureusement, prostituée a été retenu dans les 5 premiers choix du modèle, mot associé à « femme » et à « travail » par le modèle. Cela se produit même si BERT est l'un des rare *transformers* qui n'a pas été construit avec des données récupérées par *scrapping* sur internet, mais à l'aide de données en apparence neutres. En effet, il est entraîné sur les jeux de donnés [Wikipédia Anglais](https://huggingface.co/datasets/wikipedia) et [BookCorpus](https://huggingface.co/datasets/bookcorpus)).
diff --git a/chapters/fr/chapter2/1.mdx b/chapters/fr/chapter2/1.mdx
index bf0c05190..77a53ca12 100644
--- a/chapters/fr/chapter2/1.mdx
+++ b/chapters/fr/chapter2/1.mdx
@@ -1,24 +1,24 @@
-# Introduction
-
-Comme vous l'avez vu dans le [Chapitre 1](/course/fr/chapter1), les *transformers* sont généralement très grands. Pouvant aller de plusieurs millions à des dizaines de milliards de paramètres, l'entraînement et le déploiement de ces modèles est une entreprise compliquée. De plus, avec de nouveaux modèles publiés presque quotidiennement et ayant chacun sa propre implémentation, les essayer tous n'est pas une tâche facile.
-
-La bibliothèque 🤗 *Transformers* a été créée pour résoudre ce problème. Son objectif est de fournir une API unique à travers laquelle tout modèle de *transformers* peut être chargé, entraîné et sauvegardé. Les principales caractéristiques de la bibliothèque sont :
-
-- **la facilité d'utilisation** : en seulement deux lignes de code il est possible de télécharger, charger et utiliser un modèle de NLP à l'état de l'art pour faire de l'inférence,
-- **la flexibilité** : au fond, tous les modèles sont de simples classes PyTorch `nn.Module` ou TensorFlow `tf.keras.Model` et peuvent être manipulés comme n'importe quel autre modèle dans leurs *frameworks* d'apprentissage automatique respectifs,
-- **la simplicité** : pratiquement aucune abstraction n'est faite dans la bibliothèque. Avoir tout dans un fichier est un concept central : la passe avant d'un modèle est entièrement définie dans un seul fichier afin que le code lui-même soit compréhensible et piratable.
-
-Cette dernière caractéristique rend 🤗 *Transformers* très différent des autres bibliothèques d'apprentissage automatique.
-Les modèles ne sont pas construits sur des modules partagés entre plusieurs fichiers. Au lieu de cela, chaque modèle possède ses propres couches.
-En plus de rendre les modèles plus accessibles et compréhensibles, cela vous permet d'expérimenter des choses facilement sur un modèle sans affecter les autres.
-
-Ce chapitre commence par un exemple de bout en bout où nous utilisons un modèle et un *tokenizer* ensemble pour reproduire la fonction `pipeline()` introduite dans le [Chapitre 1](/course/chapter1).
-Ensuite, nous aborderons l'API *model* : nous nous plongerons dans les classes de modèle et de configuration, nous verrons comment charger un modèle et enfin comment il traite les entrées numériques pour produire des prédictions.
-
-Nous examinerons ensuite l'API *tokenizer* qui est l'autre composant principal de la fonction `pipeline()`.
-Les *tokenizers* s'occupent de la première et de la dernière étape du traitement en gérant la conversion du texte en entrées numériques pour le réseau neuronal et la reconversion en texte lorsqu'elle est nécessaire.
-Enfin, nous montrerons comment gérer l'envoi de plusieurs phrases à travers un modèle dans un batch préparé et nous conclurons le tout en examinant de plus près la fonction `tokenizer()`.
-
-
@@ -62,14 +63,14 @@ Comme nous l'avons vu dans le [Chapitre 1](/course/fr/chapter1), ce pipeline reg
Passons rapidement en revue chacun de ces éléments.
-## Prétraitement avec un *tokenizer*
+## Prétraitement avec un tokenizer
Comme d'autres réseaux de neurones, les *transformers* ne peuvent pas traiter directement le texte brut, donc la première étape de notre pipeline est de convertir les entrées textuelles en nombres afin que le modèle puisse les comprendre. Pour ce faire, nous utilisons un *tokenizer*, qui sera responsable de :
- diviser l'entrée en mots, sous-mots, ou symboles (comme la ponctuation) qui sont appelés *tokens*,
- associer chaque *token* à un nombre entier,
- ajouter des entrées supplémentaires qui peuvent être utiles au modèle.
-Tout ce prétraitement doit être effectué exactement de la même manière que celui appliqué lors du pré-entraînement du modèle. Nous devons donc d'abord télécharger ces informations depuis le [*Model Hub*](https://huggingface.co/models). Pour ce faire, nous utilisons la classe `AutoTokenizer` et sa méthode `from_pretrained()`. En utilisant le nom du *checkpoint* de notre modèle, elle va automatiquement récupérer les données associées au *tokenizer* du modèle et les mettre en cache (afin qu'elles ne soient téléchargées que la première fois que vous exécutez le code ci-dessous).
+Tout ce prétraitement doit être effectué exactement de la même manière que celui appliqué lors du pré-entraînement du modèle. Nous devons donc d'abord télécharger ces informations depuis le [*Hub*](https://huggingface.co/models). Pour ce faire, nous utilisons la classe `AutoTokenizer` et sa méthode `from_pretrained()`. En utilisant le nom du *checkpoint* de notre modèle, elle va automatiquement récupérer les données associées au *tokenizer* du modèle et les mettre en cache (afin qu'elles ne soient téléchargées que la première fois que vous exécutez le code ci-dessous).
Puisque le *checkpoint* par défaut du pipeline `sentiment-analysis` (analyse de sentiment) est `distilbert-base-uncased-finetuned-sst-2-english` (vous pouvez voir la carte de ce modèle [ici](https://huggingface.co/distilbert-base-uncased-finetuned-sst-2-english)), nous exécutons ce qui suit :
@@ -89,7 +90,8 @@ Pour spécifier le type de tenseurs que nous voulons récupérer (PyTorch, Tenso
{#if fw === 'pt'}
```python
raw_inputs = [
- "I've been waiting for a HuggingFace course my whole life.", # J'ai attendu un cours de HuggingFace toute ma vie.
+ "I've been waiting for a HuggingFace course my whole life.",
+ # J'ai attendu un cours de HuggingFace toute ma vie.
"I hate this so much!", # Je déteste tellement ça !
]
inputs = tokenizer(raw_inputs, padding=True, truncation=True, return_tensors="pt")
@@ -98,7 +100,8 @@ print(inputs)
{:else}
```python
raw_inputs = [
- "I've been waiting for a HuggingFace course my whole life.", # J'ai attendu un cours de HuggingFace toute ma vie.
+ "I've been waiting for a HuggingFace course my whole life.",
+ # J'ai attendu un cours de HuggingFace toute ma vie.
"I hate this so much!", # Je déteste tellement ça !
]
inputs = tokenizer(raw_inputs, padding=True, truncation=True, return_tensors="tf")
@@ -175,7 +178,7 @@ Pour chaque entrée du modèle, nous récupérons un vecteur en grande dimension
Si cela ne fait pas sens, ne vous inquiétez pas. Nous expliquons tout plus tard.
-Bien que ces états cachés puissent être utiles en eux-mêmes, ils sont généralement les entrées d'une autre partie du modèle, connue sous le nom de *tête*. Dans le [Chapitre 1](/course/fr/chapter1), les différentes tâches auraient pu être réalisées avec la même architecture mais en ayant chacune d'elles une tête différente.
+Bien que ces états cachés puissent être utiles en eux-mêmes, ils sont généralement les entrées d'une autre partie du modèle, connue sous le nom de *tête*. Dans le [chapitre 1](/course/fr/chapter1), les différentes tâches auraient pu être réalisées avec la même architecture mais en ayant chacune d'elles une tête différente.
### Un vecteur de grande dimension ?
@@ -210,7 +213,7 @@ print(outputs.last_hidden_state.shape)
```
{/if}
-Notez que les sorties des modèles de la bibliothèque 🤗 Transformers se comportent comme des `namedtuples` ou des dictionnaires. Vous pouvez accéder aux éléments par attributs (comme nous l'avons fait), par clé (`outputs["last_hidden_state"]`), ou même par l’index si vous savez exactement où se trouve la chose que vous cherchez (`outputs[0]`).
+Notez que les sorties des modèles de la bibliothèque 🤗 *Transformers* se comportent comme des `namedtuples` ou des dictionnaires. Vous pouvez accéder aux éléments par attributs (comme nous l'avons fait), par clé (`outputs["last_hidden_state"]`), ou même par l’index si vous savez exactement où se trouve la chose que vous cherchez (`outputs[0]`).
### Les têtes des modèles : donner du sens aux chiffres
Les têtes des modèles prennent en entrée le vecteur de grande dimension des états cachés et le projettent sur une autre dimension. Elles sont généralement composées d'une ou de quelques couches linéaires :
@@ -289,7 +292,7 @@ tensor([[-1.5607, 1.6123],
```
{/if}
-Notre modèle a prédit `[-1.5607, 1.6123]` pour la première phrase et `[ 4.1692, -3.3464]` pour la seconde. Ce ne sont pas des probabilités mais des *logits*, les scores bruts, non normalisés, produits par la dernière couche du modèle. Pour être convertis en probabilités, ils doivent passer par une couche [SoftMax](https://fr.wikipedia.org/wiki/Fonction_softmax) (tous les modèles de la bibliothèque 🤗 Transformers sortent les logits car la fonction de perte de l'entraînement fusionne généralement la dernière fonction d'activation, comme la SoftMax, avec la fonction de perte réelle, comme l'entropie croisée) :
+Notre modèle a prédit `[-1.5607, 1.6123]` pour la première phrase et `[ 4.1692, -3.3464]` pour la seconde. Ce ne sont pas des probabilités mais des *logits*, les scores bruts, non normalisés, produits par la dernière couche du modèle. Pour être convertis en probabilités, ils doivent passer par une couche [SoftMax](https://fr.wikipedia.org/wiki/Fonction_softmax) (tous les modèles de la bibliothèque 🤗 *Transformers* sortent les logits car la fonction de perte de l'entraînement fusionne généralement la dernière fonction d'activation, comme la SoftMax, avec la fonction de perte réelle, comme l'entropie croisée) :
{#if fw === 'pt'}
```py
diff --git a/chapters/fr/chapter2/3.mdx b/chapters/fr/chapter2/3.mdx
index 96e555191..9fce3d02f 100644
--- a/chapters/fr/chapter2/3.mdx
+++ b/chapters/fr/chapter2/3.mdx
@@ -1,231 +1,231 @@
-
-
-
-
-
-
-
+
+
+
+
+
+encode existe sur les tokenizer, elle n'existe pas sur les modèles."
- },
- {
- text: "Appeler directement l'objet tokenizer",
- explain: " Exactement ! La méthode __call__ du tokenizer est une méthode très puissante qui peut traiter à peu près tout. C'est également la méthode utilisée pour récupérer les prédictions d'un modèle.",
- correct: true
- },
- {
- text: "pad",
- explain: "C'est faux ! Le padding est très utile mais ce n'est qu'une partie de l'API tokenizer."
- },
- {
- text: "tokenize",
- explain: "La méthode tokenize est est sans doute l'une des méthodes les plus utiles, mais elle ne constitue pas le cœur de l'API tokenizer."
- }
- ]}
-/>
-
-### 9. Que contient la variable `result` dans cet exemple de code ?
-
-```py
-from transformers import AutoTokenizer
-
-tokenizer = AutoTokenizer.from_pretrained("bert-base-cased")
-result = tokenizer.tokenize("Hello!")
-```
-
-__call__ ou la méthode convert_tokens_to_ids sert !"
- },
- {
- text: "Une chaîne contenant tous les tokens",
- explain: "Ce serait sous-optimal car le but est de diviser la chaîne de caractères en plusieurs éléments."
- }
- ]}
-/>
-
-{#if fw === 'pt'}
-### 10. Y a-t-il un problème avec le code suivant ?
-
-
-```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)
-```
-
-encode existe sur les tokenizer, elle n'existe pas sur les modèles."
+ },
+ {
+ text: "Appeler directement l'objet tokenizer",
+ explain: "La méthode __call__ du tokenizer est une méthode très puissante qui peut traiter à peu près tout. C'est également la méthode utilisée pour récupérer les prédictions d'un modèle.",
+ correct: true
+ },
+ {
+ text: "pad",
+ explain: "Le padding est très utile mais ce n'est qu'une partie de l'API tokenizer."
+ },
+ {
+ text: "tokenize",
+ explain: "La méthode tokenize est est sans doute l'une des méthodes les plus utiles, mais elle ne constitue pas le cœur de l'API tokenizer."
+ }
+ ]}
+/>
+
+### 9. Que contient la variable `result` dans cet exemple de code ?
+
+```py
+from transformers import AutoTokenizer
+
+tokenizer = AutoTokenizer.from_pretrained("bert-base-cased")
+result = tokenizer.tokenize("Hello!")
+```
+
+__call__ ou la méthode convert_tokens_to_ids sert !"
+ },
+ {
+ text: "Une chaîne contenant tous les tokens",
+ explain: "Ce serait sous-optimal car le but est de diviser la chaîne de caractères en plusieurs éléments."
+ }
+ ]}
+/>
+
+{#if fw === 'pt'}
+### 10. Y a-t-il un problème avec le code suivant ?
+
+
+```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. Nous avons utilisé la fonction DataCollatorWithPadding qui remplit tous les éléments d'un batch pour qu'ils aient la même longueur.",
+ explain: "Vous pouvez passer la fonction de rassemblement comme argument d'une fonction DataLoader. Nous avons utilisé la fonction DataCollatorWithPadding qui remplit tous les éléments d'un batch pour qu'ils aient la même longueur.",
correct: true
},
{
@@ -155,7 +155,7 @@ Testez ce que vous avez appris dans ce chapitre !
},
{
text: "La tête du modèle pré-entraîné est supprimée et une nouvelle tête adaptée à la tâche est insérée à la place.",
- explain: "Correct. Par exemple, lorsque nous avons utilisé l'AutoModelForSequenceClassification avec bert-base-uncased, nous avons eu des messages d'avertissement lors de l'instanciation du modèle. La tête pré-entraînée n'est pas utilisée pour la tâche de classification de séquences, elle est donc supprimée et une nouvelle tête est instanciée avec des poids aléatoires..",
+ explain: "Par exemple, lorsque nous avons utilisé l'AutoModelForSequenceClassification avec bert-base-uncased, nous avons eu des messages d'avertissement lors de l'instanciation du modèle. La tête pré-entraînée n'est pas utilisée pour la tâche de classification de séquences, elle est donc supprimée et une nouvelle tête est instanciée avec des poids aléatoires..",
correct: true
},
{
@@ -175,7 +175,7 @@ Testez ce que vous avez appris dans ce chapitre !
choices={[
{
text: "Contenir tous les hyperparamètres utilisés pour l'entraînement et l'évaluation avec le Trainer.",
- explain: "Correct !",
+ explain: "",
correct: true
},
{
@@ -207,7 +207,7 @@ Testez ce que vous avez appris dans ce chapitre !
},
{
text: "Elle permet à nos boucles d'entraînement de fonctionner avec des stratégies distribuées.",
- explain: "Correct ! Avec 🤗 Accelerate, vos boucles d'entraînement fonctionneront pour plusieurs GPUs et TPUs.",
+ explain: "Avec 🤗 Accelerate, vos boucles d'entraînement fonctionneront pour plusieurs GPUs et TPUs.",
correct: true
},
{
@@ -228,7 +228,7 @@ Testez ce que vous avez appris dans ce chapitre !
},
{
text: "La tête du modèle pré-entraîné est supprimée et une nouvelle tête adaptée à la tâche est insérée à la place.",
- explain: "Correct. Par exemple, lorsque nous avons utilisé TFAutoModelForSequenceClassification avec bert-base-uncased, nous avons eu des messages d'avertissement lors de l'instanciation du modèle. La tête pré-entraînée n'est pas utilisée pour la tâche de classification de séquences, elle est donc supprimée et une nouvelle tête est instanciée avec des poids aléatoires..",
+ explain: "Par exemple, lorsque nous avons utilisé TFAutoModelForSequenceClassification avec bert-base-uncased, nous avons eu des messages d'avertissement lors de l'instanciation du modèle. La tête pré-entraînée n'est pas utilisée pour la tâche de classification de séquences, elle est donc supprimée et une nouvelle tête est instanciée avec des poids aléatoires..",
correct: true
},
{
@@ -252,12 +252,12 @@ Testez ce que vous avez appris dans ce chapitre !
},
{
text: "Vous pouvez tirer parti des méthodes existantes telles que compile(), fit() et predict().",
- explain: "Correct ! Une fois que vous disposez des données, l'entraînement sur celles-ci ne demande que très peu de travail.",
+ explain: "Une fois que vous disposez des données, l'entraînement sur celles-ci ne demande que très peu de travail.",
correct: true
},
{
text: "Vous apprendrez à connaître Keras ainsi que transformers.",
- explain: "Correct, mais nous cherchons quelque chose d'autre :)",
+ explain: "Mais nous cherchons quelque chose d'autre :)",
correct: true
},
{
@@ -282,7 +282,7 @@ Testez ce que vous avez appris dans ce chapitre !
},
{
text: "En utilisant un callable avec la signature metric_fn(y_true, y_pred).",
- explain: "Correct !",
+ explain: " ",
correct: true
},
{
diff --git a/chapters/fr/chapter4/1.mdx b/chapters/fr/chapter4/1.mdx
index b9c2057a4..7a0420461 100644
--- a/chapters/fr/chapter4/1.mdx
+++ b/chapters/fr/chapter4/1.mdx
@@ -1,17 +1,17 @@
-# Le *Hub* d'Hugging Face
-
-Le [*Hub* d'Hugging Face](https://huggingface.co/), notre site internet principal, est une plateforme centrale qui permet à quiconque de découvrir, d'utiliser et de contribuer à de nouveaux modèles et jeux de données de pointe. Il héberge une grande variété de modèles, dont plus de 10 000 sont accessibles au public. Nous nous concentrerons sur les modèles dans ce chapitre, et nous examinerons les jeux de données au chapitre 5.
-
-Les modèles présents dans le *Hub* ne sont pas limités à 🤗 *Transformers* ou même au NLP. Il existe des modèles de [Flair](https://github.com/flairNLP/flair) et [AllenNLP](https://github.com/allenai/allennlp) pour le NLP, [Asteroid](https://github.com/asteroid-team/asteroid) et [pyannote](https://github.com/pyannote/pyannote-audio) pour l'audio, et [timm](https://github.com/rwightman/pytorch-image-models) pour la vision, pour n'en citer que quelques-uns.
-
-Chacun de ces modèles est hébergé sous forme de dépôt Git, ce qui permet le suivi des versions et la reproductibilité. Partager un modèle sur le *Hub*, c'est l'ouvrir à la communauté et le rendre accessible à tous ceux qui souhaitent l'utiliser facilement, ce qui leur évite d'avoir à entraîner eux-mêmes un modèle et simplifie le partage et l'utilisation.
-
-En outre, le partage d'un modèle sur le *Hub* déploie automatiquement une API d'inférence hébergée pour ce modèle. Toute personne de la communauté est libre de la tester directement sur la page du modèle, avec des entrées personnalisées et des *widgets* appropriés.
-
-La meilleure partie est que le partage ainsi que l'utilisation de n'importe quel modèle public sur le *Hub* sont totalement gratuits ! [Des plans payants](https://huggingface.co/pricing) existent également si vous souhaitez partager des modèles en privé.
-
-La vidéo ci-dessous montre comment naviguer sur le *Hub* :
-
-
-
-
+
+
diff --git a/chapters/fr/chapter4/4.mdx b/chapters/fr/chapter4/4.mdx
index 745d846ba..4f2086aea 100644
--- a/chapters/fr/chapter4/4.mdx
+++ b/chapters/fr/chapter4/4.mdx
@@ -6,7 +6,7 @@ Documenter le processus d'entraînement et d'évaluation aide les autres à comp
Par conséquent, la création d'une carte de modèle définissant clairement votre modèle est une étape très importante. Nous vous donnons ici quelques conseils qui vous aideront à le faire. La création de la fiche de modèle se fait par le biais du fichier *README.md* que vous avez vu précédemment, qui est un fichier Markdown.
-Le concept de carte de modèle provient d'une direction de recherche de Google, partagée pour la première fois dans l'article ["*Model Cards for Model Reporting*"](https://arxiv.org/abs/1810.03993) par Margaret Mitchell et al. De nombreuses informations contenues dans ce document sont basées sur cet article et nous vous recommandons d'y jeter un coup d'œil pour comprendre pourquoi les cartes de modèles sont si importantes dans un monde qui valorise la reproductibilité, la réutilisation et l'équité.
+Le concept de carte de modèle provient d'une direction de recherche de Google, partagée pour la première fois dans l'article [« *Model Cards for Model Reporting* »](https://arxiv.org/abs/1810.03993) par Margaret Mitchell et al. De nombreuses informations contenues dans ce document sont basées sur cet article et nous vous recommandons d'y jeter un coup d'œil pour comprendre pourquoi les cartes de modèles sont si importantes dans un monde qui valorise la reproductibilité, la réutilisation et l'équité.
La carte de modèle commence généralement par une très brève présentation de haut niveau de l'objet du modèle, suivie de détails supplémentaires dans les sections suivantes :
@@ -81,4 +81,4 @@ datasets:
Ces métadonnées sont analysées par le *Hub* qui identifie alors ce modèle comme étant un modèle français, avec une licence MIT, entraîné sur le jeu de données Oscar.
-La [spécification complète de la carte du modèle](https://github.com/huggingface/hub-docs/blame/main/modelcard.md) permet de spécifier les langues, les licences, les balises, les jeux de données, les mesures, ainsi que les résultats d'évaluation obtenus par le modèle lors de l'entraînement.
\ No newline at end of file
+La [spécification complète de la carte du modèle](https://github.com/huggingface/hub-docs/blame/main/modelcard.md) permet de spécifier les langues, les licences, les balises, les jeux de données, les mesures, ainsi que les résultats d'évaluation obtenus par le modèle lors de l'entraînement.
diff --git a/chapters/fr/chapter4/5.mdx b/chapters/fr/chapter4/5.mdx
index 366b68a81..4365a6733 100644
--- a/chapters/fr/chapter4/5.mdx
+++ b/chapters/fr/chapter4/5.mdx
@@ -1,7 +1,7 @@
-# Fin de la première partie du cours !
-
-C'est la fin de la première partie du cours ! La partie 2 sera publiée le 15 novembre 2021 avec un grand événement communautaire, pour plus d'informations voir [ici](https://huggingface.co/blog/course-launch-event).
-
-Vous devriez maintenant être capable de *finetuner* un modèle pré-entraîné sur un problème de classification de texte (phrases simples ou paires de phrases) et de télécharger le résultat sur le *Hub*. Pour vous assurer que vous maîtrisez cette première section, vous devriez refaire ça sur un problème qui vous intéresse (et pas nécessairement en anglais si vous parlez une autre langue) ! Vous pouvez trouver de l'aide dans les [forums Hugging Face](https://discuss.huggingface.co/) et partager votre projet dans [ce sujet](https://discuss.huggingface.co/t/share-your-projects/6803) une fois que vous avez terminé.
-
-Nous sommes impatients de voir ce que vous allez construire avec cet outil !
+# Fin de la première partie du cours !
+
+C'est la fin de la première partie du cours ! La partie 2 sera publiée le 15 novembre 2021 avec un grand événement communautaire, pour plus d'informations voir [ici](https://huggingface.co/blog/course-launch-event).
+
+Vous devriez maintenant être capable de *finetuner* un modèle pré-entraîné sur un problème de classification de texte (phrases simples ou paires de phrases) et de télécharger le résultat sur le *Hub*. Pour vous assurer que vous maîtrisez cette première section, vous devriez refaire ça sur un problème qui vous intéresse (et pas nécessairement en anglais si vous parlez une autre langue) ! Vous pouvez trouver de l'aide dans les [forums d'Hugging Face](https://discuss.huggingface.co/) et partager votre projet dans [ce sujet](https://discuss.huggingface.co/t/share-your-projects/6803) une fois que vous avez terminé.
+
+Nous sommes impatients de voir ce que vous allez construire avec cet outil !
\ No newline at end of file
diff --git a/chapters/fr/chapter4/6.mdx b/chapters/fr/chapter4/6.mdx
index 375cb8655..a180d67fa 100644
--- a/chapters/fr/chapter4/6.mdx
+++ b/chapters/fr/chapter4/6.mdx
@@ -1,223 +1,223 @@
-git-lfs pour les fichiers volumineux.",
- correct: true
- }
- ]}
-/>
-
-### 3. Que pouvez-vous faire en utilisant l'interface web du *Hub* ?
-
-push_to_hub et l'utiliser poussera tous les fichiers du tokenizer (vocabulaire, architecture du tokenizer, etc.) vers un dépôt donné. Ce n'est pas la seule bonne réponse, cependant !",
- correct: true
- },
- {
- text: "Une configuration de modèle",
- explain: "C'est vrai ! Toutes les configurations de modèles ont la méthode push_to_hub et son utilisation les poussera vers un dépôt donné. Que pouvez-vous partager d'autre ?",
- correct: true
- },
- {
- text: "Un modèle",
- explain: "Correct ! Tous les modèles ont la méthode push_to_hub qui le pushra ainsi que leurs fichiers de configuration, vers un dépôt donné. Ce n'est pas tout ce que vous pouvez partager, cependant.",
- correct: true
- },
- {
- text: "Trainer",
- explain: "C'est exact. Le Trainer implémente aussi la méthode push_to_hub. L'utiliser téléchargera le modèle, sa configuration, le tokenizer et une ébauche de carte de modèle vers un dépôt donné. Essayez une autre réponse !",
- correct: true
- }
- ]}
-/>
-{:else}
-push_to_hub et son utilisation les poussera vers un dépôt donné. Que pouvez-vous partager d'autre ?",
- correct: true
- },
- {
- text: "Une configuration de modèle",
- explain: "C'est vrai ! Toutes les configurations de modèles ont la méthode push_to_hub et son utilisation les poussera vers un dépôt donné. Que pouvez-vous partager d'autre ?",
- correct: true
- },
- {
- text: "Un modèle",
- explain: "Correct ! Tous les modèles ont la méthode push_to_hub qui le pushra ainsi que leurs fichiers de configuration, vers un dépôt donné. Ce n'est pas tout ce que vous pouvez partager, cependant.",
- correct: true
- },
- {
- text: "Tout ce qui précède avec un callback dédié",
- explain: "C'est exact. Le PushToHubCallback enverra régulièrement tous ces objets à un dépôt pendant l'entraînement.",
- correct: true
- }
- ]}
-/>
-{/if}
-
-### 6. Quelle est la première étape lorsqu'on utilise la méthode `push_to_hub()` ou les outils CLI ?
-
-huggingface_hub.",
- explain: "Les modèles et les tokenizers bénéficient déjà de huggingface_hub : pas besoin d'emballage supplémentaire !"
- },
- {
- text: "En les sauvegardant sur le disque et en appelant transformers-cli upload-model.",
- explain: "La commande upload-model n'existe pas."
- }
- ]}
-/>
-
-### 8. Quelles opérations git pouvez-vous faire avec la classe `Repository` ?
-
-git_commit() est là pour ça.",
- correct: true
- },
- {
- text: "Un pull.",
- explain: "C'est le but de la méthode git_pull().",
- correct: true
- },
- {
- text: "Un push.",
- explain: "La méthode git_push() fait ça.",
- correct: true
- },
- {
- text: "Un merge.",
- explain: "Non, cette opération ne sera jamais possible avec cette API."
- }
- ]}
-/>
+git-lfs pour les fichiers volumineux.",
+ correct: true
+ }
+ ]}
+/>
+
+### 3. Que pouvez-vous faire en utilisant l'interface web du *Hub* ?
+
+push_to_hub et l'utiliser poussera tous les fichiers du tokenizer (vocabulaire, architecture du tokenizer, etc.) vers un dépôt donné. Ce n'est pas la seule bonne réponse, cependant !",
+ correct: true
+ },
+ {
+ text: "Une configuration de modèle",
+ explain: "Toutes les configurations de modèles ont la méthode push_to_hub et son utilisation les poussera vers un dépôt donné. Que pouvez-vous partager d'autre ?",
+ correct: true
+ },
+ {
+ text: "Un modèle",
+ explain: "Tous les modèles ont la méthode push_to_hub qui le pushra ainsi que leurs fichiers de configuration, vers un dépôt donné. Ce n'est pas tout ce que vous pouvez partager, cependant.",
+ correct: true
+ },
+ {
+ text: "Trainer",
+ explain: "Le Trainer implémente aussi la méthode push_to_hub. L'utiliser téléchargera le modèle, sa configuration, le tokenizer et une ébauche de carte de modèle vers un dépôt donné. Essayez une autre réponse !",
+ correct: true
+ }
+ ]}
+/>
+{:else}
+push_to_hub et son utilisation les poussera vers un dépôt donné. Que pouvez-vous partager d'autre ?",
+ correct: true
+ },
+ {
+ text: "Une configuration de modèle",
+ explain: "Toutes les configurations de modèles ont la méthode push_to_hub et son utilisation les poussera vers un dépôt donné. Que pouvez-vous partager d'autre ?",
+ correct: true
+ },
+ {
+ text: "Un modèle",
+ explain: "Tous les modèles ont la méthode push_to_hub qui le pushra ainsi que leurs fichiers de configuration, vers un dépôt donné. Ce n'est pas tout ce que vous pouvez partager, cependant.",
+ correct: true
+ },
+ {
+ text: "Tout ce qui précède avec un callback dédié",
+ explain: "Le PushToHubCallback enverra régulièrement tous ces objets à un dépôt pendant l'entraînement.",
+ correct: true
+ }
+ ]}
+/>
+{/if}
+
+### 6. Quelle est la première étape lorsqu'on utilise la méthode `push_to_hub()` ou les outils CLI ?
+
+huggingface_hub.",
+ explain: "Les modèles et les tokenizers bénéficient déjà de huggingface_hub : pas besoin d'emballage supplémentaire !"
+ },
+ {
+ text: "En les sauvegardant sur le disque et en appelant transformers-cli upload-model.",
+ explain: "La commande upload-model n'existe pas."
+ }
+ ]}
+/>
+
+### 8. Quelles opérations git pouvez-vous faire avec la classe `Repository` ?
+
+git_commit() est là pour ça.",
+ correct: true
+ },
+ {
+ text: "Un pull.",
+ explain: "C'est le but de la méthode git_pull().",
+ correct: true
+ },
+ {
+ text: "Un push.",
+ explain: "La méthode git_push() fait ça.",
+ correct: true
+ },
+ {
+ text: "Un merge.",
+ explain: "Cette opération ne sera jamais possible avec cette API."
+ }
+ ]}
+/>
\ No newline at end of file
diff --git a/chapters/fr/chapter5/1.mdx b/chapters/fr/chapter5/1.mdx
index 145c6ecb0..2817734c9 100644
--- a/chapters/fr/chapter5/1.mdx
+++ b/chapters/fr/chapter5/1.mdx
@@ -1,17 +1,17 @@
-# Introduction
-
-Dans le [Chapitre 3](/course/fr/chapter3) vous avez eu un premier aperçu de la bibliothèque 🤗 *Datasets* et qu'il y a trois étapes principales pour *finetuner* un modèle :
-
-1. charger un jeu de données à partir du *Hub* d’Hugging Face.
-2. Prétraiter les données avec `Dataset.map()`.
-3. Charger et calculer des métriques.
-
-Mais ce n'est qu'effleurer la surface de ce que 🤗 *Datasets* peut faire ! Dans ce chapitre, nous allons plonger profondément dans cette bibliothèque. En cours de route, nous trouverons des réponses aux questions suivantes :
-
-* que faire lorsque votre jeu de données n'est pas sur le *Hub* ?
-* comment découper et trancher un jeu de données ? (Et si on a _vraiment_ besoin d'utiliser Pandas ?)
-* que faire lorsque votre jeu de données est énorme et va monopoliser la RAM de votre ordinateur portable ?
-* qu'est-ce que c'est que le « *memory mapping* » et Apache Arrow ?
-* comment créer votre propre jeu de données et le pousser sur le *Hub* ?
-
-Les techniques apprises dans ce chapitre vous prépareront aux tâches avancées de tokenisation et de *finetuning* du [Chapitre 6](/course/fr/chapter6) et du [Chapitre 7](/course/fr/chapter7). Alors prenez un café et commençons !
+# Introduction
+
+Dans le [chapitre 3](/course/fr/chapter3) vous avez eu un premier aperçu de la bibliothèque 🤗 *Datasets* et des trois étapes principales pour *finetuner* un modèle :
+
+1. chargement d'un jeu de données à partir du *Hub* d’Hugging Face,
+2. prétraitement des données avec `Dataset.map()`,
+3. chargement et calcul des métriques.
+
+Mais ce n'est qu'effleurer la surface de ce que 🤗 *Datasets* peut faire ! Dans ce chapitre, nous allons plonger profondément dans cette bibliothèque. En cours de route, nous trouverons des réponses aux questions suivantes :
+
+* que faire lorsque votre jeu de données n'est pas sur le *Hub* ?
+* comment découper et trancher un jeu de données ? (Et si on a _vraiment_ besoin d'utiliser Pandas ?)
+* que faire lorsque votre jeu de données est énorme et va monopoliser la RAM de votre ordinateur portable ?
+* qu'est-ce que c'est que le « *memory mapping* » et Apache Arrow ?
+* comment créer votre propre jeu de données et le pousser sur le *Hub* ?
+
+Les techniques apprises dans ce chapitre vous prépareront aux tâches avancées de tokenisation du [chapitre 6](/course/fr/chapter6) et de *finetuning* du [chapitre 7](/course/fr/chapter7). Alors prenez un café et commençons !
\ No newline at end of file
diff --git a/chapters/fr/chapter5/2.mdx b/chapters/fr/chapter5/2.mdx
index 7f4f93a2b..f05424005 100644
--- a/chapters/fr/chapter5/2.mdx
+++ b/chapters/fr/chapter5/2.mdx
@@ -1,165 +1,167 @@
-# Que faire si mon jeu de données n'est pas sur le *Hub* ?
-
-| - | 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 | -
| + | 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 | +
-
-
-
-
-
-
+
+
+
+
+
+
-
-| - | html_url | -title | -comments | -body | -
|---|---|---|---|---|
| 0 | -https://github.com/huggingface/datasets/issues/2787 | -ConnectionError: Couldn't reach https://raw.githubusercontent.com | -the bug code locate in ：\r\n if data_args.task_name is not None... | -Hello,\r\nI am trying to run run_glue.py and it gives me this error... | -
| 1 | -https://github.com/huggingface/datasets/issues/2787 | -ConnectionError: Couldn't reach https://raw.githubusercontent.com | -Hi @jinec,\r\n\r\nFrom time to time we get this kind of `ConnectionError` coming from the github.com website: https://raw.githubusercontent.com... | -Hello,\r\nI am trying to run run_glue.py and it gives me this error... | -
| 2 | -https://github.com/huggingface/datasets/issues/2787 | -ConnectionError: Couldn't reach https://raw.githubusercontent.com | -cannot connect，even by Web browser，please check that there is some problems。 | -Hello,\r\nI am trying to run run_glue.py and it gives me this error... | -
| 3 | -https://github.com/huggingface/datasets/issues/2787 | -ConnectionError: Couldn't reach https://raw.githubusercontent.com | -I can access https://raw.githubusercontent.com/huggingface/datasets/1.7.0/datasets/glue/glue.py without problem... | -Hello,\r\nI am trying to run run_glue.py and it gives me this error... | -
+
+| + | html_url | +title | +comments | +body | +
|---|---|---|---|---|
| 0 | +https://github.com/huggingface/datasets/issues/2787 | +ConnectionError: Couldn't reach https://raw.githubusercontent.com | +the bug code locate in ：\r\n if data_args.task_name is not None... | +Hello,\r\nI am trying to run run_glue.py and it gives me this error... | +
| 1 | +https://github.com/huggingface/datasets/issues/2787 | +ConnectionError: Couldn't reach https://raw.githubusercontent.com | +Hi @jinec,\r\n\r\nFrom time to time we get this kind of `ConnectionError` coming from the github.com website: https://raw.githubusercontent.com... | +Hello,\r\nI am trying to run run_glue.py and it gives me this error... | +
| 2 | +https://github.com/huggingface/datasets/issues/2787 | +ConnectionError: Couldn't reach https://raw.githubusercontent.com | +cannot connect，even by Web browser，please check that there is some problems。 | +Hello,\r\nI am trying to run run_glue.py and it gives me this error... | +
| 3 | +https://github.com/huggingface/datasets/issues/2787 | +ConnectionError: Couldn't reach https://raw.githubusercontent.com | +I can access https://raw.githubusercontent.com/huggingface/datasets/1.7.0/datasets/glue/glue.py without problem... | +Hello,\r\nI am trying to run run_glue.py and it gives me this error... | +
load_dataset() pour charger les jeux de données locaux.",
- correct: true
- },
- {
- text: "Le Hub d’Hugging Face.",
- explain: "Correct ! Vous pouvez charger des jeux de données sur le Hub> en fournissant l'ID du jeu de données. Par exemple : load_dataset('emotion').",
- correct: true
- },
- {
- text: "Un serveur distant.",
- explain: "Correct ! Vous pouvez passer des URLs à l'argument data_files de load_dataset() pour charger des fichiers distants.",
- correct: true
- },
- ]}
-/>
-
-### 2. Supposons que vous chargiez l'une des tâches du jeu de données GLUE comme suit :
-
-```py
-from datasets import load_dataset
-
-dataset = load_dataset("glue", "mrpc", split="train")
-```
-
-Laquelle des commandes suivantes produira un échantillon aléatoire de 50 éléments à partir de `dataset` ?
-
-Dataset.sample()."
- },
- {
- text: "dataset.shuffle().select(range(50))",
- explain: "Correct ! Comme vous l'avez vu dans ce chapitre, vous mélangez d'abord le jeu de données puis sélectionnez les échantillons à partir de celui-ci.",
- correct: true
- },
- {
- text: "dataset.select(range(50)).shuffle()",
- explain: "Ceci est incorrect. Bien que le code s'exécute, il ne mélange que les 50 premiers éléments du jeu de données."
- }
- ]}
-/>
-
-### 3. Supposons que vous disposiez d'un jeu de données sur les animaux domestiques appelé `pets_dataset` qui comporte une colonne `name` indiquant le nom de chaque animal. Parmi les approches suivantes, laquelle vous permettrait de filtrer le jeu de données pour tous les animaux dont le nom commence par la lettre « L » ?
-
-pets_dataset.filter(lambda x['name'].startswith('L'))",
- explain: "Ceci est incorrect. Une fonction lambda prend la forme générale lambda *arguments* : *expression*, vous devez donc fournir des arguments dans ce cas."
- },
- {
- text: "Créer une fonction comme def filter_names(x): return x['name'].startswith('L') et exécuter pets_dataset.filter(filter_names).",
- explain: "Correct ! Tout comme avec Dataset.map(), vous pouvez passer des fonctions explicites à Dataset.filter(). Ceci est utile lorsque vous avez une logique complexe qui ne convient pas à une fonction lambda courte. Parmi les autres solutions, laquelle fonctionnerait ?",
- correct: true
- }
- ]}
-/>
-
-### 4. Qu'est-ce que le *memory mapping* ?
-
-IterableDataset est un générateur, pas un conteneur. Vous devez donc accéder à ses éléments en utilisant next(iter(dataset)).",
- correct: true
- },
- {
- text: "Le jeu de données allocine n'a pas d’échantillon train.",
- explain: "Ceci est incorrect. Consultez la [fiche d’ allocine](https://huggingface.co/datasets/allocine) sur le Hub pour voir quels échantillons il contient."
- }
- ]}
-/>
-
-### 7. Parmi les avantages suivants, lesquels sont les principaux pour la création d'une fiche pour les jeux de données ?
-
-load_dataset() pour charger les jeux de données locaux.",
+ correct: true
+ },
+ {
+ text: "Le Hub d’Hugging Face.",
+ explain: "Vous pouvez charger des jeux de données sur le Hub en fournissant l'ID du jeu de données. Par exemple : load_dataset('emotion').",
+ correct: true
+ },
+ {
+ text: "Un serveur distant.",
+ explain: "Vous pouvez passer des URLs à l'argument data_files de load_dataset() pour charger des fichiers distants.",
+ correct: true
+ },
+ ]}
+/>
+
+### 2. Supposons que vous chargiez l'une des tâches du jeu de données GLUE comme suit :
+
+```py
+from datasets import load_dataset
+
+dataset = load_dataset("glue", "mrpc", split="train")
+```
+
+Laquelle des commandes suivantes produira un échantillon aléatoire de 50 éléments à partir de `dataset` ?
+
+Dataset.sample()."
+ },
+ {
+ text: "dataset.shuffle().select(range(50))",
+ explain: "Comme vous l'avez vu dans ce chapitre, vous mélangez d'abord le jeu de données puis sélectionnez les échantillons à partir de celui-ci.",
+ correct: true
+ },
+ {
+ text: "dataset.select(range(50)).shuffle()",
+ explain: "Bien que le code s'exécute, il ne mélange que les 50 premiers éléments du jeu de données."
+ }
+ ]}
+/>
+
+### 3. Supposons que vous disposiez d'un jeu de données sur les animaux domestiques appelé `pets_dataset` qui comporte une colonne `name` indiquant le nom de chaque animal. Parmi les approches suivantes, laquelle vous permettrait de filtrer le jeu de données pour tous les animaux dont le nom commence par la lettre « L » ?
+
+pets_dataset.filter(lambda x['name'].startswith('L'))",
+ explain: "Une fonction lambda prend la forme générale lambda *arguments* : *expression*, vous devez donc fournir des arguments dans ce cas."
+ },
+ {
+ text: "Créer une fonction comme def filter_names(x): return x['name'].startswith('L') et exécuter pets_dataset.filter(filter_names).",
+ explain: "Tout comme avec Dataset.map(), vous pouvez passer des fonctions explicites à Dataset.filter(). Ceci est utile lorsque vous avez une logique complexe qui ne convient pas à une fonction lambda courte. Parmi les autres solutions, laquelle fonctionnerait ?",
+ correct: true
+ }
+ ]}
+/>
+
+### 4. Qu'est-ce que le *memory mapping* ?
+
+IterableDataset est un générateur, pas un conteneur. Vous devez donc accéder à ses éléments en utilisant next(iter(dataset)).",
+ correct: true
+ },
+ {
+ text: "Le jeu de données allocine n'a pas d’échantillon train.",
+ explain: "Consultez le jeu de données allocine sur le Hub (https://huggingface.co/datasets/allocine) pour voir quels échantillons il contient."
+ }
+ ]}
+/>
+
+### 7. Parmi les avantages suivants, lesquels sont les principaux pour la création d'une fiche pour les jeux de données ?
+
+train_new_from_iterator() ?
-
-`` et '' avec " et toute séquence de deux espaces ou plus par un seul espace, ainsi que la suppression des accents dans les textes à catégoriser.
-
-Le pré-*tokenizer* à utiliser pour tout *tokenizer SentencePiece* est `Metaspace` :
-
-```python
-tokenizer.pre_tokenizer = pre_tokenizers.Metaspace()
-```
-
-Nous pouvons jeter un coup d'oeil à la pré-tokénisation d'un exemple de texte comme précédemment :
-
-```python
-tokenizer.pre_tokenizer.pre_tokenize_str("Let's test the pre-tokenizer!")
-```
-
-```python out
-[("▁Let's", (0, 5)), ('▁test', (5, 10)), ('▁the', (10, 14)), ('▁pre-tokenizer!', (14, 29))]
-```
-
-Vient ensuite le modèle, qui doit être entraîné. XLNet possède un certain nombre de *tokens* spéciaux :
-
-```python
-special_tokens = ["
+
+`` et '' par " et toute séquence de deux espaces ou plus par un seul espace, de plus il supprime les accents.
+
+Le prétokenizer à utiliser pour tout *tokenizer SentencePiece* est `Metaspace` :
+
+```python
+tokenizer.pre_tokenizer = pre_tokenizers.Metaspace()
+```
+
+Nous pouvons jeter un coup d'oeil à la prétokénisation sur le même exemple de texte que précédemment :
+
+```python
+tokenizer.pre_tokenizer.pre_tokenize_str("Let's test the pre-tokenizer!")
+```
+
+```python out
+[("▁Let's", (0, 5)), ('▁test', (5, 10)), ('▁the', (10, 14)), ('▁pre-tokenizer!', (14, 29))]
+```
+
+Vient ensuite le modèle, qui doit être entraîné. XLNet possède un certain nombre de *tokens* spéciaux :
+
+```python
+special_tokens = ["
-
-
-
-Vous pouvez trouver le modèle que nous allons entraîner et télécharger sur le *Hub* et vérifier ses prédictions [ici](https://huggingface.co/huggingface-course/bert-finetuned-ner?text=My+nom+est+Sylvain+et+je+travaille+à+Hugging+Face+in+Brooklyn).
-
-## Préparation des données
-
-Tout d'abord, nous avons besoin d'un jeu de données adapté à la classification des *tokens*. Dans cette section, nous utiliserons le jeu de données [CoNLL-2003](https://huggingface.co/datasets/conll2003), qui contient des articles de presse de Reuters.
-
-
+
+
+
+Vous pouvez trouver le modèle que nous allons entraîner et télécharger sur le *Hub* et vérifier ses prédictions [ici](https://huggingface.co/huggingface-course/bert-finetuned-ner?text=My+nom+est+Sylvain+et+je+travaille+à+Hugging+Face+in+Brooklyn).
+
+## Préparation des données
+
+Tout d'abord, nous avons besoin d'un jeu de données adapté à la classification des *tokens*. Dans cette section, nous utiliserons le jeu de données [CoNLL-2003](https://huggingface.co/datasets/conll2003), qui contient des articles de presse de Reuters.
+
+
-
-
-
-Comme dans les sections précédentes, vous pouvez trouver le modèle réel que nous allons entraîner et télécharger sur le *Hub* en utilisant le code ci-dessous et vérifier ses prédictions [ici](https://huggingface.co/huggingface-course/marian-finetuned-kde4-en-to-fr?text=This+plugin+allows+you+to+automatically+translate+web+pages+between+several+languages.).
-
-## Préparation des données
-
-Pour affiner ou entraîner un modèle de traduction à partir de zéro, nous avons besoin d'un jeu de données adapté à cette tâche. Comme mentionné précédemment, nous utiliserons le jeu de données [KDE4](https://huggingface.co/datasets/kde4) dans cette section, mais vous pouvez adapter le code pour utiliser vos propres données assez facilement, tant que vous avez des paires de phrases dans les deux langues que vous voulez traduire de et vers. Reportez-vous au [Chapitre 5](/course/fr/chapter5) si vous avez besoin d'un rappel sur la façon de charger vos données personnalisées dans un `Dataset`.
-
-### Le jeu de données KDE4
-
-Comme d'habitude, nous téléchargeons notre jeu de données en utilisant la fonction `load_dataset()` :
-
-```py
-from datasets import load_dataset, load_metric
-
-raw_datasets = load_dataset("kde4", lang1="en", lang2="fr")
-```
-
-Si vous souhaitez travailler avec une autre paire de langues, vous pouvez les spécifier par leurs codes. Au total, 92 langues sont disponibles pour cet ensemble de données ; vous pouvez les voir toutes en développant les étiquettes de langue sur sa [fiche](https://huggingface.co/datasets/kde4).
-
-
-
-Jetons un coup d'œil au jeu de données :
-
-```py
-raw_datasets
-```
-
-```python out
-DatasetDict({
- train: Dataset({
- features: ['id', 'translation'],
- num_rows: 210173
- })
-})
-```
-
-Nous avons 210 173 paires de phrases, mais dans un seul split, donc nous devrons créer notre propre ensemble de validation. Comme nous l'avons vu dans le [Chapitre 5](/course/fr/chapter5), un `Dataset` possède une méthode `train_test_split()` qui peut nous aider. Nous allons fournir une graine pour la reproductibilité :
-
-```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
- })
-})
-```
-
-Nous pouvons renommer la clé "test" en "validation" comme ceci :
-
-```py
-split_datasets["validation"] = split_datasets.pop("test")
-```
-
-Examinons maintenant un élément de ce jeu de données :
-
-```py
-split_datasets["train"][1]["translation"]
-```
-
-```python out
-{'en': 'Default to expanded threads',
- 'fr': 'Par défaut, développer les fils de discussion'}
-```
-
-Nous obtenons un dictionnaire contenant deux phrases dans la paire de langues demandée.
-Une particularité de ce jeu de données rempli de termes techniques informatiques est qu'ils sont tous entièrement traduits en français. Cependant, les ingénieurs français sont souvent paresseux et laissent la plupart des mots spécifiques à l'informatique en anglais lorsqu'ils parlent. Ici, par exemple, le mot "threads" pourrait très bien apparaître dans une phrase française, surtout dans une conversation technique. Mais dans ce jeu de données, il a été traduit par le plus correct "fils de discussion". Le modèle pré-entraîné que nous utilisons, qui a été pré-entraîné sur un plus grand corpus de phrases françaises et anglaises, prend l'option la plus facile de laisser le mot tel quel :
-
-```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'}]
-```
-
-Un autre exemple de ce comportement peut être observé avec le mot "*plugin*", qui n'est pas officiellement un mot français mais que la plupart des locuteurs natifs comprendront et ne prendront pas la peine de traduire.
-Dans le jeu de données KDE4, ce mot a été traduit en français par le plus officiel "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."}
-```
-
-Notre modèle pré-entraîné, cependant, s'en tient au mot anglais compact et familier :
-
-```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."}]
-```
-
-Il sera intéressant de voir si notre modèle *finetuné* tient compte de ces particularités de l'ensemble de données (alerte *spoiler* : il le fera).
-
-
+
+
+
+Comme dans les sections précédentes, vous pouvez trouver le modèle réel que nous allons entraîner et télécharger sur le *Hub* en utilisant le code ci-dessous et vérifier ses prédictions [ici](https://huggingface.co/huggingface-course/marian-finetuned-kde4-en-to-fr?text=This+plugin+allows+you+to+automatically+translate+web+pages+between+several+languages.).
+
+## Préparation des données
+
+Pour affiner ou entraîner un modèle de traduction à partir de zéro, nous avons besoin d'un jeu de données adapté à cette tâche. Comme mentionné précédemment, nous utiliserons le jeu de données [KDE4](https://huggingface.co/datasets/kde4) dans cette section, mais vous pouvez adapter le code pour utiliser vos propres données assez facilement, tant que vous avez des paires de phrases dans les deux langues que vous voulez traduire de et vers. Reportez-vous au [Chapitre 5](/course/fr/chapter5) si vous avez besoin d'un rappel sur la façon de charger vos données personnalisées dans un `Dataset`.
+
+### Le jeu de données KDE4
+
+Comme d'habitude, nous téléchargeons notre jeu de données en utilisant la fonction `load_dataset()` :
+
+```py
+from datasets import load_dataset, load_metric
+
+raw_datasets = load_dataset("kde4", lang1="en", lang2="fr")
+```
+
+Si vous souhaitez travailler avec une autre paire de langues, vous pouvez les spécifier par leurs codes. Au total, 92 langues sont disponibles pour cet ensemble de données ; vous pouvez les voir toutes en développant les étiquettes de langue sur sa [fiche](https://huggingface.co/datasets/kde4).
+
+
+
+Jetons un coup d'œil au jeu de données :
+
+```py
+raw_datasets
+```
+
+```python out
+DatasetDict({
+ train: Dataset({
+ features: ['id', 'translation'],
+ num_rows: 210173
+ })
+})
+```
+
+Nous avons 210 173 paires de phrases, mais dans un seul split, donc nous devrons créer notre propre ensemble de validation. Comme nous l'avons vu dans le [Chapitre 5](/course/fr/chapter5), un `Dataset` possède une méthode `train_test_split()` qui peut nous aider. Nous allons fournir une graine pour la reproductibilité :
+
+```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
+ })
+})
+```
+
+Nous pouvons renommer la clé "test" en "validation" comme ceci :
+
+```py
+split_datasets["validation"] = split_datasets.pop("test")
+```
+
+Examinons maintenant un élément de ce jeu de données :
+
+```py
+split_datasets["train"][1]["translation"]
+```
+
+```python out
+{'en': 'Default to expanded threads',
+ 'fr': 'Par défaut, développer les fils de discussion'}
+```
+
+Nous obtenons un dictionnaire contenant deux phrases dans la paire de langues demandée.
+Une particularité de ce jeu de données rempli de termes techniques informatiques est qu'ils sont tous entièrement traduits en français. Cependant, les ingénieurs français sont souvent paresseux et laissent la plupart des mots spécifiques à l'informatique en anglais lorsqu'ils parlent. Ici, par exemple, le mot "threads" pourrait très bien apparaître dans une phrase française, surtout dans une conversation technique. Mais dans ce jeu de données, il a été traduit par le plus correct "fils de discussion". Le modèle pré-entraîné que nous utilisons, qui a été pré-entraîné sur un plus grand corpus de phrases françaises et anglaises, prend l'option la plus facile de laisser le mot tel quel :
+
+```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'}]
+```
+
+Un autre exemple de ce comportement peut être observé avec le mot "*plugin*", qui n'est pas officiellement un mot français mais que la plupart des locuteurs natifs comprendront et ne prendront pas la peine de traduire.
+Dans le jeu de données KDE4, ce mot a été traduit en français par le plus officiel "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."}
+```
+
+Notre modèle pré-entraîné, cependant, s'en tient au mot anglais compact et familier :
+
+```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."}]
+```
+
+Il sera intéressant de voir si notre modèle *finetuné* tient compte de ces particularités de l'ensemble de données (alerte *spoiler* : il le fera).
+
+
-
-
-
-
+
+
+
+
-
-
+
+
@@ -354,9 +354,9 @@ input_ids = inputs["input_ids"][0]
outputs = model(**inputs)
answer_start_scores = outputs.start_logits
answer_end_scores = outputs.end_logits
-# Obtenez le début de réponse le plus probable avec l'argmax du score.
+# Pour obtenir le début de réponse le plus probable avec l'argmax du score
answer_start = torch.argmax(answer_start_scores)
-# Obtenir la fin de réponse la plus probable avec l'argmax du score
+# Pour obtenir la fin de réponse la plus probable avec l'argmax du score
answer_end = torch.argmax(answer_end_scores) + 1
answer = tokenizer.convert_tokens_to_string(
tokenizer.convert_ids_to_tokens(input_ids[answer_start:answer_end])
@@ -372,4 +372,4 @@ Answer: pytorch, tensorflow, and jax # pytorch, tensorflow et jax
"""
```
-Super, ça a marché ! Voilà un excellent exemple de l'utilité de Stack Overflow : en identifiant un problème similaire, nous avons pu bénéficier de l'expérience d'autres membres de la communauté. Cependant, une recherche de ce type ne donne pas toujours une réponse pertinente, alors que faire dans ce cas ? Heureusement, il existe une communauté accueillante de développeurs sur le [forum d'Hugging Face](https://discuss.huggingface.co/) qui peut vous aider ! Dans la prochaine section, nous verrons comment rédiger de bonnes questions de forum qui ont des chances d'obtenir une réponse.
+Super, ça a marché ! Voilà un excellent exemple de l'utilité de Stack Overflow : en identifiant un problème similaire, nous avons pu bénéficier de l'expérience d'autres membres de la communauté. Cependant, une recherche de ce type ne donne pas toujours une réponse pertinente. Que faire alors dans ce cas ? Heureusement, il existe une communauté accueillante de développeurs sur le [forum d'Hugging Face](https://discuss.huggingface.co/) qui peut vous aider ! Dans la prochaine section, nous verrons comment rédiger de bonnes questions sur les forums pour avoir de bonnes chances d'obtenir une réponse.
diff --git a/chapters/fr/chapter8/3.mdx b/chapters/fr/chapter8/3.mdx
index 526fe482b..a75b49f95 100644
--- a/chapters/fr/chapter8/3.mdx
+++ b/chapters/fr/chapter8/3.mdx
@@ -9,23 +9,23 @@
GPT3ForSequenceClassification?",
- explain: "Bon choix ! Ce titre est concis et donne au lecteur un indice sur ce qui pourrait être erroné (par exemple, que GPT-3 n'est pas pris en charge dans 🤗 Transformers).",
+ explain: "Ce titre est concis et donne au lecteur un indice sur ce qui pourrait être erroné (par exemple, que GPT-3 n'est pas pris en charge dans 🤗 Transformers).",
correct: true
},
{
text: "Le GPT-3 est-il pris en charge dans 🤗 Transformers ?",
- explain: "Bien vu ! Utiliser des questions comme titres de sujets est un excellent moyen de communiquer le problème à la communauté..",
+ explain: "Utiliser des questions comme titres de sujets est un excellent moyen de communiquer le problème à la communauté.",
correct: true
}
]}
@@ -89,7 +89,7 @@ Lequel des éléments suivants pourrait être un bon choix pour le titre d'un su
choices={[
{
text: "L'étape d'optimisation où nous calculons les gradients et effectuons la rétropropagation.",
- explain: "Bien qu'il puisse y avoir des bogues dans votre optimiseur, cela se produit généralement à plusieurs étapes du pipeline d'entraînement, il y a donc d'autres choses à vérifier d'abord. Essayez à nouveau !"
+ explain: "Bien qu'il puisse y avoir des bugs dans votre optimiseur, cela se produit généralement à plusieurs étapes du pipeline d'entraînement, il y a donc d'autres choses à vérifier d'abord. Essayez à nouveau !"
},
{
text: "L'étape d'évaluation où nous calculons les métriques",
@@ -140,8 +140,8 @@ Lequel des éléments suivants pourrait être un bon choix pour le titre d'un su
+
+
+"""
+
+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."
+# Jetez un coup d'œil au [bot original Rick et Morty] (https://huggingface.co/spaces/kingabzpro/Rick_and_Morty_Bot) sur lequel cette démo est basée.
+
+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?"]]
+ # ["Que faites-vous ?"], ["Où devrions-nous voyager dans le temps ?"]
+).launch()
+```
+
+En utilisant les options ci-dessus, nous obtenons une interface plus complète. Essayez l'interface ci-dessous :
+
+
+
+### Partager votre démo avec des liens temporaires
+Maintenant que nous avons une démo fonctionnelle de notre modèle d'apprentissage automatique, apprenons à partager facilement un lien vers notre interface.
+Les interfaces peuvent être facilement partagées publiquement en mettant `share=True` dans la méthode `launch()` :
+
+```python
+gr.Interface(classify_image, "image", "label").launch(share=True)
+```
+
+Cela génère un lien public et partageable que vous pouvez envoyer à n'importe qui ! Lorsque vous envoyez ce lien, l'utilisateur de l'autre côté peut essayer le modèle dans son navigateur pendant 72 heures au maximum. Le traitement s'effectuant sur votre appareil (tant qu'il reste allumé !), vous n'avez pas à vous soucier de la mise en place de dépendances. Si vous travaillez à partir d'un *notebook* Google Colab, un lien de partage est toujours créé automatiquement. Il ressemble généralement à quelque chose comme ceci : **XXXXX.gradio.app**. Bien que le lien soit servi par un lien *Gradio*, nous ne sommes qu'un proxy pour votre serveur local, et nous ne stockons pas les données envoyées par les interfaces.
+
+Gardez cependant à l'esprit que ces liens sont accessibles au public, ce qui signifie que n'importe qui peut utiliser votre modèle pour la prédiction ! Par conséquent, assurez-vous de ne pas exposer d'informations sensibles à travers les fonctions que vous écrivez, ou de permettre que des changements critiques se produisent sur votre appareil. Si vous définissez `share=False` (la valeur par défaut), seul un lien local est créé.
+
+### Hébergement de votre démo sur Hugging Face Spaces
+
+Un lien de partage que vous pouvez passer à vos collègues est cool, mais comment pouvez-vous héberger de façon permanente votre démo et la faire exister dans son propre « espace » sur internet ?
+
+*Hugging Face Spaces* fournit l'infrastructure pour héberger de façon permanente votre démo *Gradio* sur internet et **gratuitement** ! *Spaces* vous permet de créer et de pousser vers un dépôt (public ou privé) le code de votre interface *Gradio*. Il sera placé dans un fichier `app.py`. [Lisez ce tutoriel étape par étape](https://huggingface.co/blog/gradio-spaces) pour commencer ou regardez la vidéo ci-dessous.
+
+Sketch Recognition | Demo Model
", + live=True, +) +interface.launch(share=True) +``` + + + + +Notice the `live=True` parameter in `Interface`, which means that the sketch demo makes a prediction every time someone draws on the sketchpad (no submit button!). + +De plus, nous avons également défini l'argument `share=True` dans la méthode `launch()`. +Cela créera un lien public que vous pourrez envoyer à n'importe qui ! Lorsque vous envoyez ce lien, l'utilisateur de l'autre côté peut essayer le modèle de reconnaissance de croquis. Pour réitérer, vous pouvez également héberger le modèle sur *Hugging Face Spaces*, ce qui nous permet d'intégrer la démo ci-dessus. + +La prochaine fois, nous couvrirons d'autres façons dont *Gradio* peut être utilisé avec l'écosystème d'*Hugging Face* ! \ No newline at end of file diff --git a/chapters/fr/chapter9/5.mdx b/chapters/fr/chapter9/5.mdx new file mode 100644 index 000000000..18f1b9c67 --- /dev/null +++ b/chapters/fr/chapter9/5.mdx @@ -0,0 +1,66 @@ +# Intégrations avec le Hub d'Hugging Face + +Pour vous rendre la vie encore plus facile, *Gradio* s'intègre directement avec *Hub* et *Spaces*. +Vous pouvez charger des démos depuis le *Hub* et les *Spaces* avec seulement *une ligne de code*. + +### Chargement de modèles depuis lle Hub d'Hugging Face +Pour commencer, choisissez un des milliers de modèles qu'*Hugging Face* offre à travers le *Hub*, comme décrit dans le [chapitre 4](/course/fr/chapter4/2). + +En utilisant la méthode spéciale `Interface.load()`, vous passez `"model/"` (ou, de manière équivalente, `"huggingface/"`) suivi du nom du modèle. +Par exemple, voici le code pour construire une démo pour le [GPT-J](https://huggingface.co/EleutherAI/gpt-j-6B), un grand modèle de langue, ajouter quelques exemples d'entrées : + +```py +import gradio as gr + +title = "GPT-J-6B" +description = "Gradio Demo for GPT-J 6B, a transformer model trained using Ben Wang's Mesh Transformer JAX. 'GPT-J' refers to the class of model, while '6B' represents the number of trainable parameters. To use it, simply add your text, or click one of the examples to load them. Read more at the links below." +# Démo Gradio pour GPT-J 6B, un modèle de transformer entraîné avec le Mesh Transformer JAX de Ben Wang. GPT-J fait référence à la classe du modèle, tandis que '6B' représente le nombre de paramètres entraînables. Pour l'utiliser, il suffit d'ajouter votre texte, ou de cliquer sur l'un des exemples pour le charger. Pour en savoir plus, consultez les liens ci-dessous. +article = "GPT-J-6B: A 6 Billion Parameter Autoregressive Language Model
" +# GPT-J-6B : Un modèle linguistique autorégressif à 6 milliards de paramètres +examples = [ + ["The tower is 324 metres (1,063 ft) tall,"], + # La tour mesure 324 mètres (1 063 pieds) de haut, + ["The Moon's orbit around Earth has"], + # L'orbite de la Lune autour de la Terre a + ["The smooth Borealis basin in the Northern Hemisphere covers 40%"], + # Le bassin de Borealis dans l'hémisphère nord couvre 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() +``` + +Le code ci-dessus produira l'interface ci-dessous : + + + +Le chargement d'un modèle de cette manière utilise l'[API d'Inference] (https://huggingface.co/inference-api) de *Hugging Face* au lieu de charger le modèle en mémoire. C'est idéal pour les modèles énormes comme GPT-J ou T0pp qui nécessitent beaucoup de RAM. + +### Chargement depuis Hugging Face Spaces +Pour charger n'importe quel *Space* depuis le *Hub* et le recréer localement, vous pouvez passer `spaces/` à l'`Interface`, suivi du nom du *Space*. + +Vous vous souvenez de la démo de la section 1 qui supprime le fond d'une image ? Chargeons-la à partir de *Hugging Face Spaces* : + +```py +gr.Interface.load("spaces/abidlabs/remove-bg").launch() +``` + + + +L'un des avantages du chargement de démos à partir du *Hub* ou de *Spaces* est que vous pouvez les personnaliser en remplaçant n'importe lequel des paramètres. Ici, nous ajoutons un titre et faisons en sorte qu'elle fonctionne avec une webcam à la place : + +```py +gr.Interface.load( + "spaces/abidlabs/remove-bg", inputs="webcam", title="Remove your webcam background!" +).launch() +``` + + + +Maintenant que nous avons exploré quelques façons d'intégrer *Gradio* avec le *Hub*, jetons un coup d'oeil à certaines fonctionnalités avancées de la classe `Interface`. C'est le sujet de la prochaine section ! \ No newline at end of file diff --git a/chapters/fr/chapter9/6.mdx b/chapters/fr/chapter9/6.mdx new file mode 100644 index 000000000..6a3413fb9 --- /dev/null +++ b/chapters/fr/chapter9/6.mdx @@ -0,0 +1,132 @@ +# Fonctionnalités avancées de l'interface + +Maintenant que nous pouvons construire et partager une interface de base, explorons quelques fonctionnalités plus avancées comme l'état, l'interprétation et l'authentification. + +### Utilisation de l'état pour faire persister les données + +*Gradio* supporte *l'état de session* où les données persistent à travers plusieurs soumissions dans un chargement de page. L'état de session est utile pour construire des démos où vous souhaitez faire persister les données au fur et à mesure que l'utilisateur interagit avec le modèle (par exemple des chatbots). Notez que l'état de session ne partage pas les données entre les différents utilisateurs de votre modèle. + +Pour stocker des données dans un état de session, vous devez faire trois choses : + +- Passez un *paramètre supplémentaire* dans votre fonction, qui représente l'état de l'interface. +- A la fin de la fonction, renvoyer la valeur mise à jour de l'état comme une *valeur de retour supplémentaire*. +- Ajoutez les composants "state" input et "state" output lors de la création de votre `Interface`. + +Voir l'exemple de chatbot ci-dessous : + +```py +import random + +import gradio as gr + + +def chat(message, history): + history = history or [] + if message.startswith("How many"): + response = random.randint(1, 10) + elif message.startswith("How"): + response = random.choice(["Great", "Good", "Okay", "Bad"]) + elif message.startswith("Where"): + response = random.choice(["Here", "There", "Somewhere"]) + else: + response = "I don't know" + history.append((message, response)) + return history, history + + +iface = gr.Interface( + chat, + ["text", "state"], + ["chatbot", "state"], + allow_screenshot=False, + allow_flagging="never", +) +iface.launch() +``` + + + +Remarquez comment l'état du composant de sortie persiste entre les soumissions. +Remarque : vous pouvez transmettre une valeur par défaut au paramètre state, qui est utilisée comme valeur initiale de l'état. + +### Utilisation de l'interprétation pour comprendre les prédictions + +La plupart des modèles d'apprentissage automatique sont des boîtes noires et la logique interne de la fonction est cachée à l'utilisateur final. Pour encourager la transparence, nous avons fait en sorte qu'il soit très facile d'ajouter l'interprétation à votre modèle en définissant simplement le mot-clé interprétation dans la classe Interface par défaut. Cela permet à vos utilisateurs de comprendre quelles parties de l'entrée sont responsables de la sortie. Jetez un coup d'œil à l'interface simple ci-dessous qui montre un classificateur d'images incluant l'interprétation : + +```py +import requests +import tensorflow as tf + +import gradio as gr + +inception_net = tf.keras.applications.MobileNetV2() # charger le modèle + +# Télécharger des étiquettes lisibles par l'homme pour ImageNet +response = requests.get("https://git.io/JJkYN") +labels = response.text.split("\n") + + +def classify_image(inp): + inp = inp.reshape((-1, 224, 224, 3)) + inp = tf.keras.applications.mobilenet_v2.preprocess_input(inp) + prediction = inception_net.predict(inp).flatten() + return {labels[i]: float(prediction[i]) for i in range(1000)} + + +image = gr.Image(shape=(224, 224)) +label = gr.Label(num_top_classes=3) + +title = "Gradio Image Classifiction + Interpretation Example" +gr.Interface( + fn=classify_image, inputs=image, outputs=label, interpretation="default", title=title +).launch() +``` + +Testez la fonction d'interprétation en soumettant une entrée puis en cliquant sur « Interpréter » sous le composant de sortie. + + + +En plus de la méthode d'interprétation par défaut fournie par *Gradio*, vous pouvez également spécifier `shap` pour le paramètre `interpretation` et définir le paramètre `num_shap`. Ceci utilise l'interprétation basée sur Shapley, dont vous pouvez lire plus sur [ici](https://christophm.github.io/interpretable-ml-book/shap.html). +Enfin, vous pouvez aussi passer votre propre fonction d'interprétation dans le paramètre `interpretation`. Vous trouverez un exemple dans la page de démarrage de *Gradio* [ici](https://gradio.app/getting_started/). + + +### Ajouter l'authentification + +Vous pouvez vouloir ajouter une authentification à votre interface *Gradio* afin de contrôler qui peut accéder et utiliser votre démo. + +L'authentification peut être ajoutée en fournissant une liste de tuples de nom d'utilisateur/mot de passe au paramètre `auth` de la méthode `launch()`. Pour une gestion plus complexe de l'authentification, vous pouvez passer une fonction qui prend un nom d'utilisateur et un mot de passe comme arguments, et retourne `True` pour permettre l'authentification, `False` sinon. + +Prenons la démo de classification d'images ci-dessus et ajoutons l'authentification : + +```py +import requests +import tensorflow as tf + +import gradio as gr + +inception_net = tf.keras.applications.MobileNetV2() # charger le modèle + +# Télécharger des étiquettes lisibles par l'homme pour ImageNet +response = requests.get("https://git.io/JJkYN") +labels = response.text.split("\n") + + +def classify_image(inp): + inp = inp.reshape((-1, 224, 224, 3)) + inp = tf.keras.applications.mobilenet_v2.preprocess_input(inp) + prediction = inception_net.predict(inp).flatten() + return {labels[i]: float(prediction[i]) for i in range(1000)} + + +image = gr.Image(shape=(224, 224)) +label = gr.Label(num_top_classes=3) + +title = "Gradio Image Classifiction + Interpretation Example" +gr.Interface( + fn=classify_image, inputs=image, outputs=label, interpretation="default", title=title +).launch(auth=("admin", "pass1234")) +``` + + + +Ceci conclut notre plongée dans la classe `Interface` de *Gradio*. Comme nous l'avons vu, cette classe permet de créer facilement des démos d'apprentissage automatique en quelques lignes de code Python. Cependant, vous voudrez parfois personnaliser votre démo en changeant la mise en page ou en enchaînant plusieurs fonctions de prédiction. Ne serait-il pas agréable de pouvoir diviser l'interface en blocs personnalisables ? Heureusement, c'est possible ! C'est le sujet de la dernière section. \ No newline at end of file diff --git a/chapters/fr/chapter9/7.mdx b/chapters/fr/chapter9/7.mdx new file mode 100644 index 000000000..edf7c91df --- /dev/null +++ b/chapters/fr/chapter9/7.mdx @@ -0,0 +1,233 @@ +# Introduction à la classe Blocks + +Dans les sections précédentes, nous avons exploré et créé des démos en utilisant la classe `Interface`. Dans cette section, nous allons présenter une **nouvelle** API de bas niveau appelée `gradio.Blocks`. + +Quelle est la différence entre `Interface` et `Blocks` ? + +- ⚡ `Interface` : une API de haut niveau qui vous permet de créer une démo complète d'apprentissage automatique simplement en fournissant une liste d'entrées et de sorties. + +- 🧱 `Blocks` : une API de bas niveau qui vous permet d'avoir un contrôle total sur les flux de données et la disposition de votre application. Vous pouvez construire des applications très complexes, en plusieurs étapes, en utilisant `Blocks`. + + +### Pourquoi Blocks 🧱 ? + +Comme nous l'avons vu dans les sections précédentes, la classe `Interface` vous permet de créer facilement des démos d'apprentissage automatique à part entière avec seulement quelques lignes de code. L'API `Interface` est extrêmement facile à utiliser, mais elle n'a pas la flexibilité qu'offre l'API `Blocks`. Par exemple, vous pourriez vouloir : + +- regrouper des démos connexes sous forme d'onglets multiples dans une application web, +- modifier la mise en page de votre démo, par exemple pour spécifier l'emplacement des entrées et des sorties, +- disposer d'interfaces multi-étapes dans lesquelles la sortie d'un modèle devient l'entrée du modèle suivant ou avoir des flux de données plus flexibles en général, +- modifier les propriétés d'un composant (par exemple, les choix dans une liste déroulante) ou sa visibilité en fonction des entrées de l'utilisateur. + +Nous allons explorer tous ces concepts ci-dessous. + +### Création d'une démo simple en utilisant Blocks + +Après avoir installé *Gradio*, exécutez le code ci-dessous sous forme de script Python, de *notebook* Jupyter ou de *notebook* Colab. + +```py +import gradio as gr + + +def flip_text(x): + return x[::-1] + + +demo = gr.Blocks() + +with demo: + gr.Markdown( + """ + # Flip Text! + Start typing below to see the output. + """ + ) + input = gr.Textbox(placeholder="Flip this text") + output = gr.Textbox() + + input.change(fn=flip_text, inputs=input, outputs=output) + +demo.launch() +``` + + + +Ce simple exemple ci-dessus introduit 4 concepts qui sous-tendent les *Blocks* : + +1. Les *Blocks* vous permettent de construire des applications web qui combinent Markdown, HTML, boutons et composants interactifs simplement en instanciant des objets en Python dans un contexte `with gradio.Blocks`. + +gr.Interface.load().",
+ correct: true
+ }
+ ]}
+/>
+
+### 6. Lesquelles des méthodes suivantes sont valides pour charger un modèle à partir du Hub ou de Space ?
+
+gr.Interface.load('model/{user}/{model_name}')",
+ explain: "Il s'agit d'une méthode valide de chargement d'un modèle à partir du Hub.",
+ correct: true
+ },
+ {
+ text: "gr.Interface.load('demos/{user}/{model_name}')",
+ explain: "Vous ne pouvez pas charger un modèle en utilisant le préfixe demos."
+ },
+ {
+ text: "gr.Interface.load('spaces/{user}/{model_name}')",
+ explain: "Il s'agit d'une méthode valide de chargement d'un modèle à partir de Space.",
+ correct: true
+ }
+ ]}
+/>
+
+### 7. Sélectionnez toutes les étapes nécessaires pour ajouter un état à votre interface Gradio
+
+Textbox.",
+ correct: true
+ },
+ {
+ text: "Graph.",
+ explain: "Il n'y a actuellement aucun composant Graph.",
+ },
+ {
+ text: "Image.",
+ explain: "Oui, vous pouvez créer un widget de téléchargement d'images avec le composant Image.",
+ correct: true
+ },
+ {
+ text: "Audio.",
+ explain: "Oui, vous pouvez créer un widget de téléchargement audio avec le composant Audio.",
+ correct: true
+ },
+ ]}
+/>
+
+### 9. Qu'est-ce que les `Blocks` vous permet de faire ?
+
+Blocks.",
+ explain: "Lorsque vous assignez un événement, vous passez trois paramètres : fn qui est la fonction qui doit être appelée, inputs qui est la (liste) des composants d'entrée, et outputs qui est la (liste) des composants de sortie qui doivent être appelés.",
+ correct: true
+ },
+ {
+ text: "Déterminer automatiquement quel composant Blocks doit être interactif ou statique.",
+ explain: "En fonction des déclencheurs d'événements que vous définissez, Blocks détermine automatiquement si un composant doit accepter ou non les entrées de l'utilisateur..",
+ correct: true
+ },
+ {
+ text: "Créer des démos en plusieurs étapes, c'est-à-dire vous permettre de réutiliser la sortie d'un composant comme entrée pour le suivant.",
+ explain: "Vous pouvez utiliser un composant pour l'entrée d'un déclencheur d'événement mais la sortie d'un autre.",
+ correct: true
+ },
+ ]}
+/>
+
+### 10. Vous pouvez partager un lien public vers une démo Blocks et accueillir une démo Blocks sur Space
+
+Blocks !",
+ correct: true
+ },
+ {
+ text: "False",
+ explain: "Tout comme Interface, toutes les capacités de partage et d'hébergement sont les mêmes pour les démos basées sur Blocks !",
+ correct: false
+ }
+ ]}
+/>
\ No newline at end of file
diff --git a/chapters/fr/event/1.mdx b/chapters/fr/event/1.mdx
index ab52d0489..e6d766bd7 100644
--- a/chapters/fr/event/1.mdx
+++ b/chapters/fr/event/1.mdx
@@ -1,170 +1,170 @@
-# Événement pour le lancement de la partie 2
-
-Pour la sortie de la deuxième partie du cours, nous avons organisé un événement en direct consistant en deux jours de conférences suivies d’un *sprint* de *finetuning*. Si vous l'avez manqué, vous pouvez rattraper les présentations qui sont toutes listées ci-dessous !
-
-## Jour 1 : Une vue d'ensemble des *transformers* et comment les entraîner
-
-
-**Thomas Wolf :** *L'apprentissage par transfert et la naissance de la bibliothèque 🤗 Transformers*
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+gr.Interface.load().",
- correct: true
- }
- ]}
-/>
-
-### 6. Lesquelles des méthodes suivantes sont valides pour charger un modèle à partir du Hub ou de Space ?
-
-gr.Interface.load('model/{user}/{model_name}')",
- explain: "Il s'agit d'une méthode valide de chargement d'un modèle à partir du Hub.",
- correct: true
- },
- {
- text: "gr.Interface.load('demos/{user}/{model_name}')",
- explain: "Vous ne pouvez pas charger un modèle en utilisant le préfixe demos."
- },
- {
- text: "gr.Interface.load('spaces/{user}/{model_name}')",
- explain: "Il s'agit d'une méthode valide de chargement d'un modèle à partir de Space.",
- correct: true
- }
- ]}
-/>
-
-### 7. Sélectionnez toutes les étapes nécessaires pour ajouter un état à votre interface Gradio
-
-Textbox.",
- correct: true
- },
- {
- text: "Graph.",
- explain: "Il n'y a actuellement aucun composant Graph.",
- },
- {
- text: "Image.",
- explain: "Oui, vous pouvez créer un widget de téléchargement d'images avec le composant Image.",
- correct: true
- },
- {
- text: "Audio.",
- explain: "Oui, vous pouvez créer un widget de téléchargement audio avec le composant Audio.",
- correct: true
- },
- ]}
-/>
-
-### 9. Qu'est-ce que les `Blocks` vous permet de faire ?
-
-Blocks.",
- explain: "Lorsque vous assignez un événement, vous passez trois paramètres : fn qui est la fonction qui doit être appelée, inputs qui est la (liste) des composants d'entrée, et outputs qui est la (liste) des composants de sortie qui doivent être appelés.",
- correct: true
- },
- {
- text: "Déterminer automatiquement quel composant Blocks doit être interactif ou statique.",
- explain: "En fonction des déclencheurs d'événements que vous définissez, Blocks détermine automatiquement si un composant doit accepter ou non les entrées de l'utilisateur..",
- correct: true
- },
- {
- text: "Créer des démos en plusieurs étapes, c'est-à-dire vous permettre de réutiliser la sortie d'un composant comme entrée pour le suivant.",
- explain: "Vous pouvez utiliser un composant pour l'entrée d'un déclencheur d'événement mais la sortie d'un autre.",
- correct: true
- },
- ]}
-/>
-
-### 10. Vous pouvez partager un lien public vers une démo Blocks et accueillir une démo Blocks sur Space
-
-Blocks !",
- correct: true
- },
- {
- text: "False",
- explain: "Tout comme Interface, toutes les capacités de partage et d'hébergement sont les mêmes pour les démos basées sur Blocks !",
- correct: false
- }
- ]}
-/>
\ No newline at end of file
+Consultez la [description de l'événement](https://github.com/AK391/community-events/blob/main/gradio-blocks/README.md) pour savoir comment participer. Nous sommes impatients de voir ce que vous allez construire 🤗 !
\ No newline at end of file
diff --git a/chapters/fr/chapter9/9.mdx b/chapters/fr/chapter9/9.mdx
new file mode 100644
index 000000000..2b6e859a2
--- /dev/null
+++ b/chapters/fr/chapter9/9.mdx
@@ -0,0 +1,233 @@
+
+
+# Quiz de fin de chapitre
+
+Testons ce que vous avez appris dans ce chapitre !
+
+### 1. Que pouvez-vous faire avec Gradio ?
+
+gr.Interface.load().",
+ correct: true
+ }
+ ]}
+/>
+
+### 6. Lesquelles des méthodes suivantes sont valides pour charger un modèle à partir du Hub ou de Space ?
+
+gr.Interface.load('model/{user}/{model_name}')",
+ explain: "Il s'agit d'une méthode valide de chargement d'un modèle à partir du Hub.",
+ correct: true
+ },
+ {
+ text: "gr.Interface.load('demos/{user}/{model_name}')",
+ explain: "Vous ne pouvez pas charger un modèle en utilisant le préfixe demos."
+ },
+ {
+ text: "gr.Interface.load('spaces/{user}/{model_name}')",
+ explain: "Il s'agit d'une méthode valide de chargement d'un modèle à partir de Space.",
+ correct: true
+ }
+ ]}
+/>
+
+### 7. Sélectionnez toutes les étapes nécessaires pour ajouter un état à votre interface Gradio
+
+Textbox.",
+ correct: true
+ },
+ {
+ text: "Graph.",
+ explain: "Il n'y a actuellement aucun composant Graph.",
+ },
+ {
+ text: "Image.",
+ explain: "Oui, vous pouvez créer un widget de téléchargement d'images avec le composant Image.",
+ correct: true
+ },
+ {
+ text: "Audio.",
+ explain: "Oui, vous pouvez créer un widget de téléchargement audio avec le composant Audio.",
+ correct: true
+ },
+ ]}
+/>
+
+### 9. Qu'est-ce que les `Blocks` vous permet de faire ?
+
+Blocks.",
+ explain: "Lorsque vous assignez un événement, vous passez trois paramètres : fn qui est la fonction qui doit être appelée, inputs qui est la (liste) des composants d'entrée, et outputs qui est la (liste) des composants de sortie qui doivent être appelés.",
+ correct: true
+ },
+ {
+ text: "Déterminer automatiquement quel composant Blocks doit être interactif ou statique.",
+ explain: "En fonction des déclencheurs d'événements que vous définissez, Blocks détermine automatiquement si un composant doit accepter ou non les entrées de l'utilisateur..",
+ correct: true
+ },
+ {
+ text: "Créer des démos en plusieurs étapes, c'est-à-dire vous permettre de réutiliser la sortie d'un composant comme entrée pour le suivant.",
+ explain: "Vous pouvez utiliser un composant pour l'entrée d'un déclencheur d'événement mais la sortie d'un autre.",
+ correct: true
+ },
+ ]}
+/>
+
+### 10. Vous pouvez partager un lien public vers une démo Blocks et accueillir une démo Blocks sur Space
+
+Blocks !",
+ correct: true
+ },
+ {
+ text: "Faux",
+ explain: "Tout comme Interface, toutes les capacités de partage et d'hébergement sont les mêmes pour les démos basées sur Blocks !",
+ }
+ ]}
+/>
\ No newline at end of file
From 822691848cafed350b5a5ab519ceb3daefcc1015 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jo=C3=A3o=20Gustavo=20A=2E=20Amorim?=
@@ -75,15 +75,15 @@ classifier(
## پیشپردازش با توکِنایزر
-مثل شبکههای عصبی دیگر، مدلهای ترنسفورمر هم نمیتوانند نوشته خام را پردازش کنند. پس اولین قدم در خط تولید ما تبدیل نوشته خام ورودی به اعدادی است که مدل میفهمد. برای این کار از یک *توکِنایزر* استفاده میکنیم، که مسئولیتهای زیر را بر عهده دارد:
+مثل شبکههای عصبی دیگر، مدلهای ترنسفورمر هم نمیتوانند نوشته خام را پردازش کنند. پس اولین قدم در خط تولید ما، تبدیل نوشته خام ورودی به اعدادی است که مدل قادر به فهم آنها باشد. برای این کار از یک *توکِنایزر* استفاده میکنیم، که مسئولیتهای زیر را بر عهده دارد:
-- شکستن نوشته به کلمات، قطعات کوچکتر کلمه و علامتها(مانند علائم نگارشی) که به آنها *توکِن* میگوییم.
-- انتخاب یک عدد صحیح معادل برای هر توکِن.
+- شکستن نوشته به کلمات، زیرکلمات و علامتها (مانند علائم نگارشی) که به آنها *توکِن* میگوییم.
+- انتخاب عدد صحیح معادل برای هر توکِن.
- اضافهکردن ورودیهای دیگری که ممکن است برای مدل مفید باشند.
-همه مراحل این پیشپردازش باید دقیقا همانطور انجام شوند که قبلا هنگام تعلیم مدل انجام شده است. این اطلاعات در [Model Hub](https://huggingface.co/models) موجود است و توسط تابع `from_pretrained()` از کلاس `AutoTokenizer` دانلود میشود. با استفاده از نام کامل مدل که شامل نقطه تعلیم است، این تابع به صورت خودکار دادههای توکِنایزر مدل را دریافت نموده و در سیستم شما ذخیره میکند. به این ترتیب این دادهها فقط بار اولی که کد زیر را اجرا میکنید دانلود میشوند.
+همه مراحل این پیشپردازش باید دقیقا همان طور که قبلا هنگام تعلیم مدل انجام شده، دنبال شوند. این اطلاعات در [هاب مدلها](https://huggingface.co/models) موجود است و توسط تابع `from_pretrained()` از کلاس `AutoTokenizer` دانلود میشود. با استفاده از نام کامل مدل که شامل نقطه تعلیم است، این تابع به صورت خودکار دادههای توکِنایزر مدل را دریافت نموده و در سیستم شما ذخیره میکند. به این ترتیب این دادهها فقط بار اولی که کد زیر را اجرا میکنید دانلود میشوند.
-نقطه تعلیم پیشفرض برای خطتولید `تحلیل احساسات` `distilbert-base-uncased-finetuned-sst-2-english` نام دارد. صفحه توضیحات این مدل را می توانید در [اینجا مشاهده کنید](https://huggingface.co/distilbert-base-uncased-finetuned-sst-2-english). با اجرای کد زیر آن را دانلود می کنیم:
+خط تولید `تحلیل احساسات` نقطه تعلیم پیشفرضی به نام `distilbert-base-uncased-finetuned-sst-2-english` دارد. صفحه توضیحات این مدل را میتوانید در [اینجا مشاهده کنید](https://huggingface.co/distilbert-base-uncased-finetuned-sst-2-english). با اجرای کد زیر آن را دانلود میکنیم:
@@ -99,9 +99,11 @@ tokenizer = AutoTokenizer.from_pretrained(checkpoint)
[CLS] विशेष टोकन की आवश्यकता होती है, लेकिन केवल यही एक चीज नहीं है!"
+ },
+ {
+ text: "[CLS] वाक्य_के_टोकन_1 [SEP] वाक्य_के_टोकन_2 [SEP]",
+ explain: "यह सही है!",
+ correct: true
+ },
+ {
+ text: "[CLS] वाक्य_के_टोकन_1 [SEP] वाक्य_के_टोकन_2",
+ explain: "शुरुआत में एक [CLS] विशेष टोकन की आवश्यकता होती है और साथ ही साथ दो वाक्यों को अलग करने के लिए एक [SEP] विशेष टोकन की आवश्यकता होती है, लेकिन यही सब नहीं है!"
+ }
+ ]}
+/>
+
+{#if fw === 'pt'}
+### 4. `Dataset.map()` विधि के क्या लाभ हैं?
+
+DataLoader के वितर्क के रूप में पास कर सकते हैं। हमने DataCollatorWithPadding फ़ंक्शन का उपयोग किया है, जो एक बैच में सभी आइटम्स को पैड करता है ताकि उनकी लंबाई समान हो।",
+ correct: true
+ },
+ {
+ text: "यह पूरे डेटासेट को पूर्व प्रसंस्करण यानि प्रीप्रोसेस करता है।",
+ explain: "यह एक प्रीप्रोसेसिंग फ़ंक्शन होगा, न कि कोलेट फ़ंक्शन।"
+ },
+ {
+ text: "यह डेटासेट में अनुक्रमों को छोटा कर देता है।",
+ explain: "एक कोलेट फ़ंक्शन अलग-अलग बैचों को संभालने में शामिल होता है, संपूर्ण डेटासेट नहीं। यदि आप काट-छाँट करने में रुचि रखते हैं, तो आप tokenizer के truncate वितर्क का उपयोग कर सकते हैं।"
+ }
+ ]}
+/>
+
+### 7. क्या होता है जब आप `AutoModelForXxx` कक्षाओं में से एक को पूर्व-प्रशिक्षित भाषा मॉडल (जैसे कि `बर्ट-बेस-अनकेस्ड`) के साथ इन्स्टैन्शीऐट करते हैं, जो भिन्न कार्य से मेल खाता है बजाये उसके जिसके लिए उसे प्रशिक्षित किया गया ?
+
+bert-base-uncased के साथ किया, तो मॉडल को इन्स्टैन्शीऐट करते समय हमें चेतावनियां मिलीं। अनुक्रम वर्गीकरण कार्य के लिए पूर्व-प्रशिक्षित के प्रमुख का उपयोग नहीं किया जाता है, इसलिए इसे त्याग दिया जाता है और क्रमरहित भार के साथ एक नये प्रमुख को इन्स्टैन्शीऐट किया जाता है।",
+ correct: true
+ },
+ {
+ text: "पूर्व-प्रशिक्षित मॉडल के प्रमुख को त्याग दिया जाता है ।",
+ explain: "कुछ और होना चाहिए। पुनः प्रयास करें!"
+ },
+ {
+ text: "कुछ भी नहीं, चूंकि मॉडल को अभी भी भिन्न कार्य के लिए ठीक यानि फाइन-ट्यून किया जा सकता है।",
+ explain: "इस कार्य को हल करने के लिए पूर्व-प्रशिक्षित मॉडल के प्रमुख को प्रशिक्षित नहीं किया गया था, इसलिए हमें प्रमुख को त्याग देना चाहिए!"
+ }
+ ]}
+/>
+
+### 8. `TrainingArguments` का क्या उद्देश्य है?
+
+TrainingArguments द्वारा।"
+ },
+ {
+ text: "इसमें केवल मूल्यांकन के लिए उपयोग किए जाने वाले हाइपरपैरामीटर शामिल हैं।",
+ explain: "उदाहरण में, हमने निर्दिष्ट किया कि मॉडल और उसकी चौकियों को कहाँ सहेजा जाएगा। पुनः प्रयास करें!"
+ },
+ {
+ text: "इसमें सिर्फ प्रशिक्षण के लिए उपयोग किए जाने वाले हाइपरपैरामीटर शामिल हैं।",
+ explain: "उदाहरण में, हमने evaluation_strategy का भी इस्तेमाल किया है, इसलिए यह मूल्यांकन को प्रभावित करता है। पुनः प्रयास करें!"
+ }
+ ]}
+/>
+
+### 9. आपको 🤗 Accelerate लाइब्रेरी का उपयोग क्यों करना चाहिए?
+
+bert-base-uncased के साथ किया, तो मॉडल को इन्स्टैन्शीऐट करते समय हमें चेतावनियां मिलीं। अनुक्रम वर्गीकरण कार्य के लिए पूर्व-प्रशिक्षित के प्रमुख का उपयोग नहीं किया जाता है, इसलिए इसे त्याग दिया जाता है और क्रमरहित भार के साथ एक नये प्रमुख को इन्स्टैन्शीऐट किया जाता है।",
+ correct: true
+ },
+ {
+ text: "पूर्व-प्रशिक्षित मॉडल के प्रमुख को त्याग दिया जाता है ।",
+ explain: "कुछ और होना चाहिए। पुनः प्रयास करें!"
+ },
+ {
+ text: "कुछ भी नहीं, चूंकि मॉडल को अभी भी भिन्न कार्य के लिए ठीक यानि फाइन-ट्यून किया जा सकता है।",
+ explain: "इस कार्य को हल करने के लिए पूर्व-प्रशिक्षित मॉडल के प्रमुख को प्रशिक्षित नहीं किया गया था, इसलिए हमें प्रमुख को त्याग देना चाहिए!"
+ }
+ ]}
+/>
+
+### 5. `ट्रांसफॉर्मर` से TensorFlow मॉडल पहले से ही Keras मॉडल हैं। यह क्या लाभ प्रदान करता है?
+
+compile(), fit(), और predict() जैसी मौजूदा विधियों का लाभ उठा सकते हैं।",
+ explain: "सही! एक बार आपके पास डेटा हो जाने के बाद, उस पर प्रशिक्षण के लिए बहुत कम काम की आवश्यकता होती है।",
+ correct: true
+ },
+ {
+ text: "आपको Keras के साथ-साथ ट्रांसफार्मरस भी सीखने को मिलते हैं।",
+ explain: "सही है, लेकिन हम कुछ और ढूंढ रहे हैं :)",
+ correct: true
+ },
+ {
+ text: "आप डेटासेट से संबंधित मेट्रिक्स की आसानी से गणना कर सकते हैं।",
+ explain: "आप डेटासेट से संबंधित मेट्रिक्स की आसानी से गणना कर सकते हैं।"
+ }
+ ]}
+/>
+
+### 6. आप अपनी खुद की कस्टम मीट्रिक कैसे परिभाषित कर सकते हैं?
+
+metric_fn(y_true, y_pred) के साथ प्रतिदेय का उपयोग करना।",
+ explain: "सही!",
+ correct: true
+ },
+ {
+ text: "इसे गुगल करके।",
+ explain: "यह वह उत्तर नहीं है जिसकी हम तलाश कर रहे हैं, लेकिन इससे आपको उसे खोजने में मदद मिलेगी।",
+ correct: true
+ }
+ ]}
+/>
+
+{/if}
From 42d203089919dad32385f76500914336a8e35ee7 Mon Sep 17 00:00:00 2001
From: Batuhan Ayhan push_to_hub, e usá-la enviara todas para um determinado repositório. O que mais você pode compartilhar?",
+ correct: true
+ },
+ {
+ text: "Um modelo",
+ explain: "Correto! Todos modelos possuem o método push_to_hub, e usá-la enviara ele e suas configurações para um determinado repositório. Embora essa não seja a única resposta correta!",
+ correct: true
+ },
+ {
+ text: "Um Trainer",
+ explain: "Está certa — o Trainer também implementa o método push_to_hub, e usa-lo ira enviar os arquivos do modelo, sua configuração, o tokenizer, eo rascunho do cartão de modelo para um repositório. Porém, não é a única resposta correta!",
+ correct: true
+ }
+ ]}
+/>
+{:else}
+push_to_hub, e usá-la enviara todas para um determinado repositório. O que mais você pode compartilhar?",
+ correct: true
+ },
+ {
+ text: "Um modelo",
+ explain: "Correto! Todos modelos possuem o método push_to_hub, e usá-la enviara ele e suas configurações para um determinado repositório. Embora essa não seja a única resposta correta!",
+ correct: true
+ },
+ {
+ text: "Todas as opções com uma callback dedicado",
+ explain: "Está certa — o PushToHubCallback ira enviar regularmente os arquivos do modelo, sua configuração, e o tokenizer durante o treinamento para um repositório. Porém, não é a única resposta correta!",
+ correct: true
+ }
+ ]}
+/>
+{/if}
+
+### 6. Qual é o primeiro passo ao utilizar o método `push_to_hub()` ou as ferramentas CLI?
+
+huggingface_hub utilidades: não há necessidade de wrappers adicionais!"
+ },
+ {
+ text: "Salvando eles em disco e chamando transformers-cli upload-model",
+ explain: "O comando upload-model não existe."
+ }
+ ]}
+/>
+
+### 8. Que operações de git você pode fazer com a classe `Repository`?
+
+git_pull().",
+ correct: true
+ },
+ {
+ text: "Um push",
+ explain: "O método git_push() realiza isto.",
+ correct: true
+ },
+ {
+ text: "Um merge",
+ explain: "Não, esta operação nunca será permitida nessa API."
+ }
+ ]}
+/>
From 751d0690d3480224fb160c3a552e5b28376a313a Mon Sep 17 00:00:00 2001
From: Vedant Pandya
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 库？
+
+
+
+
+| + | 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 | +
"""
@@ -38,7 +44,7 @@ gr.Interface(
title=title,
description=description,
article=article,
- examples=[["What are you doing?"], ["Where should we time travel to?"]]
+ examples=[["What are you doing?"], ["Where should we time travel to?"]],
).launch()
```
@@ -111,6 +117,7 @@ def predict(im):
```
Now that we have a `predict()` function. The next step is to define and launch our gradio interface:
+
```py
interface = gr.Interface(
predict,
diff --git a/chapters/en/chapter9/5.mdx b/chapters/en/chapter9/5.mdx
index e2355dac0..31c796ce6 100644
--- a/chapters/en/chapter9/5.mdx
+++ b/chapters/en/chapter9/5.mdx
@@ -1,5 +1,12 @@
# Integrations with the Hugging Face Hub
+
+
+[🤗 ट्रांसफॉर्मर्स लाइब्रेरी](https://github.com/huggingface/transformers) उन साझा मॉडलों को बनाने और उपयोग करने की कार्यक्षमता प्रदान करती है। [मॉडल हब](https://huggingface.co/models) में हजारों पूर्व-प्रशिक्षित मॉडल हैं जिन्हें कोई भी डाउनलोड और उपयोग कर सकता है। आप हब पर अपने स्वयं के मॉडल भी अपलोड कर सकते हैं!
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-`` et '' avec " et toute séquence de deux espaces ou plus par un seul espace, ainsi que la suppression des accents dans les textes à catégoriser.
-
-Le pré-*tokenizer* à utiliser pour tout *tokenizer SentencePiece* est `Metaspace` :
-
-```python
-tokenizer.pre_tokenizer = pre_tokenizers.Metaspace()
-```
-
-Nous pouvons jeter un coup d'oeil à la pré-tokénisation d'un exemple de texte comme précédemment :
-
-```python
-tokenizer.pre_tokenizer.pre_tokenize_str("Let's test the pre-tokenizer!")
-```
-
-```python out
-[("▁Let's", (0, 5)), ('▁test', (5, 10)), ('▁the', (10, 14)), ('▁pre-tokenizer!', (14, 29))]
-```
-
-Vient ensuite le modèle, qui doit être entraîné. XLNet possède un certain nombre de *tokens* spéciaux :
-
-```python
-special_tokens = ["
+
+`` et '' par " et toute séquence de deux espaces ou plus par un seul espace, de plus il supprime les accents.
+
+Le prétokenizer à utiliser pour tout *tokenizer SentencePiece* est `Metaspace` :
+
+```python
+tokenizer.pre_tokenizer = pre_tokenizers.Metaspace()
+```
+
+Nous pouvons jeter un coup d'oeil à la prétokénisation sur le même exemple de texte que précédemment :
+
+```python
+tokenizer.pre_tokenizer.pre_tokenize_str("Let's test the pre-tokenizer!")
+```
+
+```python out
+[("▁Let's", (0, 5)), ('▁test', (5, 10)), ('▁the', (10, 14)), ('▁pre-tokenizer!', (14, 29))]
+```
+
+Vient ensuite le modèle, qui doit être entraîné. XLNet possède un certain nombre de *tokens* spéciaux :
+
+```python
+special_tokens = ["
-
-
-
-Vous pouvez trouver le modèle que nous allons entraîner et télécharger sur le *Hub* et vérifier ses prédictions [ici](https://huggingface.co/huggingface-course/bert-finetuned-ner?text=My+nom+est+Sylvain+et+je+travaille+à+Hugging+Face+in+Brooklyn).
-
-## Préparation des données
-
-Tout d'abord, nous avons besoin d'un jeu de données adapté à la classification des *tokens*. Dans cette section, nous utiliserons le jeu de données [CoNLL-2003](https://huggingface.co/datasets/conll2003), qui contient des articles de presse de Reuters.
-
-
+
+
+
+Vous pouvez trouver le modèle que nous allons entraîner et télécharger sur le *Hub* et vérifier ses prédictions [ici](https://huggingface.co/huggingface-course/bert-finetuned-ner?text=My+nom+est+Sylvain+et+je+travaille+à+Hugging+Face+in+Brooklyn).
+
+## Préparation des données
+
+Tout d'abord, nous avons besoin d'un jeu de données adapté à la classification des *tokens*. Dans cette section, nous utiliserons le jeu de données [CoNLL-2003](https://huggingface.co/datasets/conll2003), qui contient des articles de presse de Reuters.
+
+
-
-
-
-Comme dans les sections précédentes, vous pouvez trouver le modèle réel que nous allons entraîner et télécharger sur le *Hub* en utilisant le code ci-dessous et vérifier ses prédictions [ici](https://huggingface.co/huggingface-course/marian-finetuned-kde4-en-to-fr?text=This+plugin+allows+you+to+automatically+translate+web+pages+between+several+languages.).
-
-## Préparation des données
-
-Pour affiner ou entraîner un modèle de traduction à partir de zéro, nous avons besoin d'un jeu de données adapté à cette tâche. Comme mentionné précédemment, nous utiliserons le jeu de données [KDE4](https://huggingface.co/datasets/kde4) dans cette section, mais vous pouvez adapter le code pour utiliser vos propres données assez facilement, tant que vous avez des paires de phrases dans les deux langues que vous voulez traduire de et vers. Reportez-vous au [Chapitre 5](/course/fr/chapter5) si vous avez besoin d'un rappel sur la façon de charger vos données personnalisées dans un `Dataset`.
-
-### Le jeu de données KDE4
-
-Comme d'habitude, nous téléchargeons notre jeu de données en utilisant la fonction `load_dataset()` :
-
-```py
-from datasets import load_dataset, load_metric
-
-raw_datasets = load_dataset("kde4", lang1="en", lang2="fr")
-```
-
-Si vous souhaitez travailler avec une autre paire de langues, vous pouvez les spécifier par leurs codes. Au total, 92 langues sont disponibles pour cet ensemble de données ; vous pouvez les voir toutes en développant les étiquettes de langue sur sa [fiche](https://huggingface.co/datasets/kde4).
-
-
-
-Jetons un coup d'œil au jeu de données :
-
-```py
-raw_datasets
-```
-
-```python out
-DatasetDict({
- train: Dataset({
- features: ['id', 'translation'],
- num_rows: 210173
- })
-})
-```
-
-Nous avons 210 173 paires de phrases, mais dans un seul split, donc nous devrons créer notre propre ensemble de validation. Comme nous l'avons vu dans le [Chapitre 5](/course/fr/chapter5), un `Dataset` possède une méthode `train_test_split()` qui peut nous aider. Nous allons fournir une graine pour la reproductibilité :
-
-```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
- })
-})
-```
-
-Nous pouvons renommer la clé "test" en "validation" comme ceci :
-
-```py
-split_datasets["validation"] = split_datasets.pop("test")
-```
-
-Examinons maintenant un élément de ce jeu de données :
-
-```py
-split_datasets["train"][1]["translation"]
-```
-
-```python out
-{'en': 'Default to expanded threads',
- 'fr': 'Par défaut, développer les fils de discussion'}
-```
-
-Nous obtenons un dictionnaire contenant deux phrases dans la paire de langues demandée.
-Une particularité de ce jeu de données rempli de termes techniques informatiques est qu'ils sont tous entièrement traduits en français. Cependant, les ingénieurs français sont souvent paresseux et laissent la plupart des mots spécifiques à l'informatique en anglais lorsqu'ils parlent. Ici, par exemple, le mot "threads" pourrait très bien apparaître dans une phrase française, surtout dans une conversation technique. Mais dans ce jeu de données, il a été traduit par le plus correct "fils de discussion". Le modèle pré-entraîné que nous utilisons, qui a été pré-entraîné sur un plus grand corpus de phrases françaises et anglaises, prend l'option la plus facile de laisser le mot tel quel :
-
-```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'}]
-```
-
-Un autre exemple de ce comportement peut être observé avec le mot "*plugin*", qui n'est pas officiellement un mot français mais que la plupart des locuteurs natifs comprendront et ne prendront pas la peine de traduire.
-Dans le jeu de données KDE4, ce mot a été traduit en français par le plus officiel "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."}
-```
-
-Notre modèle pré-entraîné, cependant, s'en tient au mot anglais compact et familier :
-
-```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."}]
-```
-
-Il sera intéressant de voir si notre modèle *finetuné* tient compte de ces particularités de l'ensemble de données (alerte *spoiler* : il le fera).
-
-
+
+
+
+Comme dans les sections précédentes, vous pouvez trouver le modèle réel que nous allons entraîner et télécharger sur le *Hub* en utilisant le code ci-dessous et vérifier ses prédictions [ici](https://huggingface.co/huggingface-course/marian-finetuned-kde4-en-to-fr?text=This+plugin+allows+you+to+automatically+translate+web+pages+between+several+languages.).
+
+## Préparation des données
+
+Pour affiner ou entraîner un modèle de traduction à partir de zéro, nous avons besoin d'un jeu de données adapté à cette tâche. Comme mentionné précédemment, nous utiliserons le jeu de données [KDE4](https://huggingface.co/datasets/kde4) dans cette section, mais vous pouvez adapter le code pour utiliser vos propres données assez facilement, tant que vous avez des paires de phrases dans les deux langues que vous voulez traduire de et vers. Reportez-vous au [Chapitre 5](/course/fr/chapter5) si vous avez besoin d'un rappel sur la façon de charger vos données personnalisées dans un `Dataset`.
+
+### Le jeu de données KDE4
+
+Comme d'habitude, nous téléchargeons notre jeu de données en utilisant la fonction `load_dataset()` :
+
+```py
+from datasets import load_dataset, load_metric
+
+raw_datasets = load_dataset("kde4", lang1="en", lang2="fr")
+```
+
+Si vous souhaitez travailler avec une autre paire de langues, vous pouvez les spécifier par leurs codes. Au total, 92 langues sont disponibles pour cet ensemble de données ; vous pouvez les voir toutes en développant les étiquettes de langue sur sa [fiche](https://huggingface.co/datasets/kde4).
+
+
+
+Jetons un coup d'œil au jeu de données :
+
+```py
+raw_datasets
+```
+
+```python out
+DatasetDict({
+ train: Dataset({
+ features: ['id', 'translation'],
+ num_rows: 210173
+ })
+})
+```
+
+Nous avons 210 173 paires de phrases, mais dans un seul split, donc nous devrons créer notre propre ensemble de validation. Comme nous l'avons vu dans le [Chapitre 5](/course/fr/chapter5), un `Dataset` possède une méthode `train_test_split()` qui peut nous aider. Nous allons fournir une graine pour la reproductibilité :
+
+```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
+ })
+})
+```
+
+Nous pouvons renommer la clé "test" en "validation" comme ceci :
+
+```py
+split_datasets["validation"] = split_datasets.pop("test")
+```
+
+Examinons maintenant un élément de ce jeu de données :
+
+```py
+split_datasets["train"][1]["translation"]
+```
+
+```python out
+{'en': 'Default to expanded threads',
+ 'fr': 'Par défaut, développer les fils de discussion'}
+```
+
+Nous obtenons un dictionnaire contenant deux phrases dans la paire de langues demandée.
+Une particularité de ce jeu de données rempli de termes techniques informatiques est qu'ils sont tous entièrement traduits en français. Cependant, les ingénieurs français sont souvent paresseux et laissent la plupart des mots spécifiques à l'informatique en anglais lorsqu'ils parlent. Ici, par exemple, le mot "threads" pourrait très bien apparaître dans une phrase française, surtout dans une conversation technique. Mais dans ce jeu de données, il a été traduit par le plus correct "fils de discussion". Le modèle pré-entraîné que nous utilisons, qui a été pré-entraîné sur un plus grand corpus de phrases françaises et anglaises, prend l'option la plus facile de laisser le mot tel quel :
+
+```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'}]
+```
+
+Un autre exemple de ce comportement peut être observé avec le mot "*plugin*", qui n'est pas officiellement un mot français mais que la plupart des locuteurs natifs comprendront et ne prendront pas la peine de traduire.
+Dans le jeu de données KDE4, ce mot a été traduit en français par le plus officiel "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."}
+```
+
+Notre modèle pré-entraîné, cependant, s'en tient au mot anglais compact et familier :
+
+```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."}]
+```
+
+Il sera intéressant de voir si notre modèle *finetuné* tient compte de ces particularités de l'ensemble de données (alerte *spoiler* : il le fera).
+
+
-
-
-
-
+
+
+
+
-
-
+
+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 库？
+
+
+
+
+
+
+
-Vous pouvez trouver le modèle que nous allons entraîner et télécharger sur le *Hub* et vérifier ses prédictions [ici](https://huggingface.co/huggingface-course/bert-finetuned-ner?text=My+nom+est+Sylvain+et+je+travaille+à+Hugging+Face+in+Brooklyn).
+Vous pouvez trouver, télécharger et vérifier les précisions de ce modèle sur le [*Hub*](https://huggingface.co/huggingface-course/bert-finetuned-ner?text=My+nom+est+Sylvain+et+je+travaille+à+Hugging+Face+in+Brooklyn) les prédictions du modèle que nous allons entraîner.
## Préparation des données
@@ -48,7 +48,7 @@ Tout d'abord, nous avons besoin d'un jeu de données adapté à la classificatio
@@ -38,26 +38,25 @@ Ce processus d'ajustement fin d'un modèle de langage pré-entraîné sur des do
-Plongeons-y !
+Allons-y !
-Comme dans les sections précédentes, vous pouvez trouver le modèle réel que nous allons entraîner et télécharger sur le *Hub* en utilisant le code ci-dessous et vérifier ses prédictions [ici](https://huggingface.co/huggingface-course/marian-finetuned-kde4-en-to-fr?text=This+plugin+allows+you+to+automatically+translate+web+pages+between+several+languages.).
+Comme dans les sections précédentes, vous pouvez trouver, télécharger et vérifier les précisions de ce modèle sur le [*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.).
## Préparation des données
-Pour affiner ou entraîner un modèle de traduction à partir de zéro, nous avons besoin d'un jeu de données adapté à cette tâche. Comme mentionné précédemment, nous utiliserons le jeu de données [KDE4](https://huggingface.co/datasets/kde4) dans cette section, mais vous pouvez adapter le code pour utiliser vos propres données assez facilement, tant que vous avez des paires de phrases dans les deux langues que vous voulez traduire de et vers. Reportez-vous au [Chapitre 5](/course/fr/chapter5) si vous avez besoin d'un rappel sur la façon de charger vos données personnalisées dans un `Dataset`.
+Pour *finetuner* ou entraîner un modèle de traduction à partir de zéro, nous avons besoin d'un jeu de données adapté à cette tâche. Comme mentionné précédemment, nous utiliserons le jeu de données [KDE4](https://huggingface.co/datasets/kde4) dans cette section. Notez que vous pouvez adapter assez facilement le code pour utiliser vos propres données du moment que vous disposez de paires de phrases dans les deux langues que vous voulez traduire. Reportez-vous au [chapitre 5](/course/fr/chapter5) si vous avez besoin d'un rappel sur la façon de charger vos données personnalisées dans un `Dataset`.
### Le jeu de données KDE4
@@ -59,11 +59,11 @@ from datasets import load_dataset, load_metric
raw_datasets = load_dataset("kde4", lang1="en", lang2="fr")
```
-Si vous souhaitez travailler avec une autre paire de langues, vous pouvez les spécifier par leurs codes. Au total, 92 langues sont disponibles pour cet ensemble de données ; vous pouvez les voir toutes en développant les étiquettes de langue sur sa [fiche](https://huggingface.co/datasets/kde4).
+Si vous souhaitez travailler avec une autre paire de langues, 92 langues sont disponibles au total pour ce jeu de données. Vous pouvez les voir dans la [carte du jeu de données](https://huggingface.co/datasets/kde4).
-Jetons un coup d'œil au jeu de données :
+Jetons un coup d'œil au jeu de données :
```py
raw_datasets
@@ -78,7 +78,7 @@ DatasetDict({
})
```
-Nous avons 210 173 paires de phrases, mais dans un seul split, donc nous devrons créer notre propre ensemble de validation. Comme nous l'avons vu dans le [Chapitre 5](/course/fr/chapter5), un `Dataset` possède une méthode `train_test_split()` qui peut nous aider. Nous allons fournir une graine pour la reproductibilité :
+Nous avons 210 173 paires de phrases. Cependant regroupées dans un seul échantillon. Nous devrons donc créer notre propre jeu de validation. Comme nous l'avons vu dans le [chapitre 5](/course/fr/chapter5), un `Dataset` possède une méthode `train_test_split()` qui peut nous aider. Nous allons fournir une graine pour la reproductibilité :
```py
split_datasets = raw_datasets["train"].train_test_split(train_size=0.9, seed=20)
@@ -98,7 +98,7 @@ DatasetDict({
})
```
-Nous pouvons renommer la clé "test" en "validation" comme ceci :
+Nous pouvons renommer la clé `test` en `validation` comme ceci :
```py
split_datasets["validation"] = split_datasets.pop("test")
@@ -115,8 +115,8 @@ split_datasets["train"][1]["translation"]
'fr': 'Par défaut, développer les fils de discussion'}
```
-Nous obtenons un dictionnaire contenant deux phrases dans la paire de langues demandée.
-Une particularité de ce jeu de données rempli de termes techniques informatiques est qu'ils sont tous entièrement traduits en français. Cependant, les ingénieurs français sont souvent paresseux et laissent la plupart des mots spécifiques à l'informatique en anglais lorsqu'ils parlent. Ici, par exemple, le mot "threads" pourrait très bien apparaître dans une phrase française, surtout dans une conversation technique. Mais dans ce jeu de données, il a été traduit par le plus correct "fils de discussion". Le modèle pré-entraîné que nous utilisons, qui a été pré-entraîné sur un plus grand corpus de phrases françaises et anglaises, prend l'option la plus facile de laisser le mot tel quel :
+Nous obtenons un dictionnaire contenant deux phrases dans la paire de langues qui nous intéresse.
+Une particularité de ce jeu de données rempli de termes techniques informatiques est qu'ils sont tous entièrement traduits en français. Cependant, les ingénieurs français sont souvent paresseux et laissent la plupart des mots spécifiques à l'informatique en anglais lorsqu'ils parlent. Ici, par exemple, le mot « *threads* » pourrait très bien apparaître dans une phrase française, surtout dans une conversation technique. Mais dans ce jeu de données, il a été traduit en « fils de discussion ». Le modèle pré-entraîné que nous utilisons (qui a été pré-entraîné sur un plus grand corpus de phrases françaises et anglaises) prend l'option de laisser le mot tel quel :
```py
from transformers import pipeline
@@ -130,8 +130,8 @@ translator("Default to expanded threads")
[{'translation_text': 'Par défaut pour les threads élargis'}]
```
-Un autre exemple de ce comportement peut être observé avec le mot "*plugin*", qui n'est pas officiellement un mot français mais que la plupart des locuteurs natifs comprendront et ne prendront pas la peine de traduire.
-Dans le jeu de données KDE4, ce mot a été traduit en français par le plus officiel "module d'extension" :
+Un autre exemple de ce comportement peut être observé avec le mot « *plugin* » qui n'est pas officiellement un mot français mais que la plupart des francophones comprendront et ne prendront pas la peine de traduire.
+Dans le jeu de données KDE4, ce mot a été traduit en français par le plus officiel « module d'extension » :
```py
split_datasets["train"][172]["translation"]
@@ -142,7 +142,7 @@ split_datasets["train"][172]["translation"]
'fr': "Impossible d'importer %1 en utilisant le module d'extension d'importation OFX. Ce fichier n'a pas un format correct."}
```
-Notre modèle pré-entraîné, cependant, s'en tient au mot anglais compact et familier :
+Notre modèle pré-entraîné, lui, s'en tient au mot anglais :
```py
translator(
@@ -154,13 +154,13 @@ translator(
[{'translation_text': "Impossible d'importer %1 en utilisant le plugin d'importateur OFX. Ce fichier n'est pas le bon format."}]
```
-Il sera intéressant de voir si notre modèle *finetuné* tient compte de ces particularités de l'ensemble de données (alerte *spoiler* : il le fera).
+Il sera intéressant de voir si notre modèle *finetuné* tient compte de ces particularités (alerte *spoiler* : il le fera).