# Glossaire

Ce glossaire définit les termes généraux du machine learning et de 🤗 Transformers afin de vous aider à mieux comprendre la documentation.

## A

### masque d'attention

Le masque d'attention est un argument facultatif utilisé lors du regroupement de séquences en lots.

Cet argument indique au modèle quels jetons doivent être pris en compte et lesquels doivent être ignorés.

Par exemple, considérons ces deux séquences :

```python
>>> from transformers import BertTokenizer

>>> tokenizer = BertTokenizer.from_pretrained("google-bert/bert-base-cased")

>>> sequence_a = "This is a short sequence."
>>> sequence_b = "This is a rather long sequence. It is at least longer than the sequence A."

>>> encoded_sequence_a = tokenizer(sequence_a)["input_ids"]
>>> encoded_sequence_b = tokenizer(sequence_b)["input_ids"]
```

Les versions encodées ont des longueurs différentes :

```python
>>> len(encoded_sequence_a), len(encoded_sequence_b)
(8, 19)
```

Par conséquent, nous ne pouvons pas les regrouper dans le même tenseur en l'état. La première séquence doit être complétée (padding) jusqu'à la longueur de la seconde, ou bien la seconde doit être tronquée jusqu'à la longueur de la première.

Dans le premier cas, la liste d’identifiants sera complétée par les indices de bourrage. Nous pouvons passer une liste au tokeniseur et lui demander d’ajouter du bourrage de la manière suivante :

```python
>>> padded_sequences = tokenizer([sequence_a, sequence_b], padding=True)
```

Nous pouvons voir que des 0 ont été ajoutés à droite de la première phrase pour lui donner la même longueur que la seconde :

```python
>>> padded_sequences["input_ids"]
[[101, 1188, 1110, 170, 1603, 4954, 119, 102, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [101, 1188, 1110, 170, 1897, 1263, 4954, 119, 1135, 1110, 1120, 1655, 2039, 1190, 1103, 4954, 138, 119, 102]]
```

On peut ensuite convertir cela en tenseur dans PyTorch. Le masque d'attention est un tenseur binaire indiquant la position des indices rembourrés, afin que le modèle ne leur accorde pas d'attention. Pour le [BertTokenizer](/docs/transformers/main/fr/model_doc/lxmert#transformers.BertTokenizer), `1` indique une valeur à laquelle il faut prêter attention, tandis que `0` indique une valeur rembourrée. Ce masque d'attention se trouve dans le dictionnaire renvoyé par le tokeniseur, sous la clé "attention_mask" :

```python
>>> padded_sequences["attention_mask"]
[[1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]
```

### modèles d'auto-encodage

Voir les [modèles encodeurs](#encoder-models) et le [masked language modeling](#masked-language-modeling-mlm)

### modèles autorégressifs

Voir [le modélisation de langage causale](#causal-language-modeling) et [les modèles décodeurs](#decoder-models)

## B

### backbone

Le backbone est le réseau (embeddings et couches) qui produit les états cachés bruts ou les caractéristiques. Il est généralement connecté à un [head](#head) qui reçoit ces caractéristiques en entrée pour effectuer une prédiction. Par exemple, [ViTModel](/docs/transformers/main/fr/model_doc/vit#transformers.ViTModel) est un backbone sans head spécifique au sommet. D'autres modèles peuvent également utiliser [ViTModel](/docs/transformers/main/fr/model_doc/vit#transformers.ViTModel) comme backbone, tels que [DPT](./model_doc/dpt).

## C

### modélisation de langage causale

Tâche de pré-entraînement dans laquelle le modèle lit les textes dans l'ordre et doit prédire le mot suivant. Elle est généralement réalisée en lisant la phrase entière, mais en utilisant un masque à l'intérieur du modèle pour masquer les jetons futurs à un certain pas de temps.

### channel

Les images en couleur sont composées d’une combinaison de valeurs sur trois canaux : rouge, vert et bleu (RGB), tandis que les images en niveaux de gris ne possèdent qu’un seul canal. Dans 🤗 Transformers, le canal peut être la première ou la dernière dimension du tenseur d’une image : [`n_channels`, `height`, `width`] ou [`height`, `width`, `n_channels`].

### classification temporelle connexionniste (CTC)

Un algorithme qui permet à un modèle d'apprendre sans connaître exactement l'alignement entre l'entrée et la sortie ; CTC calcule la distribution de toutes les sorties possibles pour une entrée donnée et choisit la sortie la plus probable parmi elles. CTC est couramment utilisé dans les tâches de reconnaissance vocale, car la parole ne s'aligne pas toujours proprement sur la transcription, pour diverses raisons telles que les différents rythmes de parole d'un locuteur.

### convolution

Un type de couche dans un réseau de neurones où la matrice d'entrée est multipliée élément par élément par une matrice plus petite (noyau ou filtre) et les valeurs sont additionnées dans une nouvelle matrice. Il s'agit d'une opération de convolution qui est répétée sur l'ensemble de la matrice d'entrée. Chaque opération est appliquée à un segment différent de la matrice d'entrée. Les réseaux de neurones convolutifs (CNN) sont couramment utilisés en vision par ordinateur.

## D

### DataParallel (DP)

Technique de parallélisme pour l’entraînement sur plusieurs GPU, dans laquelle la même configuration est répliquée plusieurs fois, chaque instance recevant une tranche de données distincte. Le traitement est effectué en parallèle et toutes les configurations sont synchronisées à la fin de chaque étape d’entraînement.

En savoir plus sur [DataParallel](./perf_train_gpu_many#dataparallel).

### identifiants d'entrée du décodeur

Cette entrée est spécifique aux modèles encodeur-décodeur et contient les identifiants d’entrée qui seront transmis au décodeur. Ces entrées doivent être utilisées pour les tâches de séquence à séquence, telles que la traduction ou la résumation, et sont généralement construites de manière spécifique à chaque modèle.

La plupart des modèles encodeur-décodeur (BART, T5) créent eux-mêmes leurs `decoder_input_ids` à partir des `labels`. Pour ce type de modèles, passer les `labels` est la méthode recommandée pour gérer l’entraînement.

Veuillez consulter la documentation de chaque modèle pour voir comment ils gèrent ces identifiants d’entrée pour l’entraînement séquence à séquence.

### modèles décodeurs

Aussi appelés modèles autorégressifs, les modèles décodeur reposent sur une tâche de pré-entraînement (appelée modélisation causale du langage) dans laquelle le modèle lit les textes dans l'ordre et doit prédire le mot suivant. Cela se fait généralement en lisant la phrase entière avec un masque pour cacher les jetons futurs à un certain pas de temps.

### deep learning (DL)

Algorithmes d'apprentissage automatique qui utilisent des réseaux de neurones à plusieurs couches.

## E

### modèles encodeurs

Aussi appelés modèles d'auto-encodage, les modèles encodeurs prennent une entrée (telle que du texte ou des images) et la transforment en une représentation numérique condensée appelée embedding. Souvent, les modèles encodeurs sont pré-entraînés à l'aide de techniques telles que le [masked language modeling](#masked-language-modeling-mlm), qui masque des parties de la séquence d'entrée et force le modèle à créer des représentations plus significatives.

## F

### extraction de caractéristiques

Le processus de sélection et de transformation de données brutes en un ensemble de caractéristiques plus informatives et utiles pour les algorithmes d'apprentissage automatique. Certains exemples d'extraction de caractéristiques incluent la transformation de texte brut en embeddings de mots et l'extraction de caractéristiques importantes telles que les contours ou les formes à partir de données d'images/vidéos.

### chunking de feed forward

Dans chaque bloc d'attention résiduelle de Transformers, la couche d'auto-attention est généralement suivie de deux couches feed forward. La taille d'incorporation intermédiaire des couches feed forward est souvent supérieure à la taille cachée du modèle (par exemple, pour `google-bert/bert-base-uncased`).

Pour une entrée de taille `[batch_size, sequence_length]`, la mémoire nécessaire pour stocker les embeddings intermédiaires du feed forward `[batch_size, sequence_length, config.intermediate_size]` peut représenter une part importante de l'utilisation mémoire. Les auteurs de [Reformer: The Efficient Transformer](https://huggingface.co/papers/2001.04451) ont constaté que, comme le calcul est indépendant de la dimension `sequence_length`, il est mathématiquement équivalent de calculer individuellement les embeddings de sortie des deux couches feed forward `[batch_size, config.hidden_size]_0, ..., [batch_size, config.hidden_size]_n` puis de les concaténer ensuite en `[batch_size, sequence_length, config.hidden_size]` avec `n = sequence_length`, ce qui échange un temps de calcul accru contre une réduction de l'utilisation mémoire, tout en produisant un résultat mathématiquement **équivalent**.

Pour les modèles utilisant la fonction [apply_chunking_to_forward()](/docs/transformers/main/fr/internal/modeling_utils#transformers.apply_chunking_to_forward), le `chunk_size` définit le nombre d'embeddings de sortie calculés en parallèle et détermine ainsi le compromis entre la complexité mémoire et la complexité temporelle. Si `chunk_size` est défini sur 0, aucun fractionnement du feed forward n'est effectué.

### modèles affinés

Le fine-tuning est une forme d'apprentissage par transfert qui consiste à prendre un modèle pré-entraîné, à geler ses poids et à remplacer la couche de sortie par une [tête de modèle](#head) nouvellement ajoutée. La tête de modèle est entraînée sur votre jeu de données cible.

Consultez le tutoriel [Fine-tune a pretrained model](./training) pour plus de détails et découvrez comment effectuer le fine-tuning de modèles avec 🤗 Transformers.

## H

### tête

La tête de modèle désigne la dernière couche d'un réseau de neurones qui accepte les états cachés bruts et les projette sur une dimension différente. Il existe une tête de modèle distincte pour chaque tâche. Par exemple :

* [GPT2ForSequenceClassification](/docs/transformers/main/fr/model_doc/gpt2#transformers.GPT2ForSequenceClassification) est une tête de classification de séquences – une couche linéaire – placée au-dessus du modèle de base [GPT2Model](/docs/transformers/main/fr/model_doc/gpt2#transformers.GPT2Model).
* [ViTForImageClassification](/docs/transformers/main/fr/model_doc/vit#transformers.ViTForImageClassification) est une tête de classification d’images, c’est-à-dire une couche linéaire appliquée à l’état caché final du jeton `CLS`, posée sur le modèle de base [ViTModel](/docs/transformers/main/fr/model_doc/vit#transformers.ViTModel).
* [Wav2Vec2ForCTC](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2ForCTC) est une tête de modélisation de langage avec [CTC](#connectionist-temporal-classification-ctc) au-dessus du modèle de base [Wav2Vec2Model](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2Model).

## I

### patch d'image

Les modèles Transformers basés sur la vision découpent une image en patches plus petits, qui sont ensuite linéairement intégrés et transmis au modèle sous forme de séquence. Vous pouvez trouver la `patch_size` — ou résolution — du modèle dans sa configuration.

### inférence

L'inférence est le processus d'évaluation d'un modèle sur de nouvelles données une fois l'entraînement terminé. Consultez le tutoriel [Pipeline for inference](./pipeline_tutorial) pour apprendre à effectuer de l'inférence avec 🤗 Transformers.

### IDs d'entrée

Les identifiants d’entrée sont souvent les seuls paramètres obligatoires à transmettre au modèle. Il s’agit d’indices de jetons, c’est-à-dire des représentations numériques des jetons qui composent les séquences utilisées en entrée par le modèle.

Chaque tokeniseur fonctionne différemment, mais le mécanisme sous-jacent reste le même. Voici un exemple utilisant le tokeniseur BERT, qui est un tokeniseur [WordPiece](https://huggingface.co/papers/1609.08144) :

```python
>>> from transformers import BertTokenizer

>>> tokenizer = BertTokenizer.from_pretrained("google-bert/bert-base-cased")

>>> sequence = "A Titan RTX has 24GB of VRAM"
```

Le tokenizer s'occupe de diviser la séquence en tokens disponibles dans le vocabulaire du tokenizer.

```python
>>> tokenized_sequence = tokenizer.tokenize(sequence)
```

Les jetons sont des mots ou des sous-mots. Ici, par exemple, « VRAM » n’était pas dans le vocabulaire du modèle, il a donc été découpé en « V », « RA » et « M ». Pour indiquer que ces jetons ne sont pas des mots distincts mais des parties du même mot, un préfixe double-dièse est ajouté à « RA » et « M » :

```python
>>> print(tokenized_sequence)
['A', 'Titan', 'R', '##T', '##X', 'has', '24', '##GB', 'of', 'V', '##RA', '##M']
```

Ces jetons peuvent ensuite être convertis en identifiants compréhensibles par le modèle. Il est possible de le faire en transmettant directement la phrase au tokeniseur, qui exploite l’implémentation Rust de [🤗 Tokenizers](https://github.com/huggingface/tokenizers) pour des performances optimales.

```python
>>> inputs = tokenizer(sequence)
```

Le tokeniseur renvoie un dictionnaire contenant tous les arguments nécessaires au bon fonctionnement de son modèle associé. Les indices des jetons se trouvent sous la clé `input_ids` :

```python
>>> encoded_sequence = inputs["input_ids"]
>>> print(encoded_sequence)
[101, 138, 18696, 155, 1942, 3190, 1144, 1572, 13745, 1104, 159, 9664, 2107, 102]
```

Notez que le tokenizer ajoute automatiquement des « tokens spéciaux » (si le modèle associé en dépend), qui sont des identifiants spéciaux que le modèle utilise parfois.

Si nous décodons la séquence d'identifiants précédente,

```python
>>> decoded_sequence = tokenizer.decode(encoded_sequence)
```

nous le verrons

```python
>>> print(decoded_sequence)
[CLS] A Titan RTX has 24GB of VRAM [SEP]
```

car c'est ainsi qu'un [BertModel](/docs/transformers/main/fr/model_doc/bert#transformers.BertModel) s'attend à recevoir ses entrées.

## L

### labels

Les étiquettes sont un argument facultatif qui peut être transmis afin que le modèle calcule lui-même la perte. Ces étiquettes doivent correspondre à la prédiction attendue du modèle : celui-ci utilisera la perte standard pour calculer l'écart entre ses prédictions et la valeur attendue (l'étiquette).

Ces étiquettes varient selon la tête du modèle, par exemple :

- Pour les modèles de classification de séquences ([BertForSequenceClassification](/docs/transformers/main/fr/model_doc/bert#transformers.BertForSequenceClassification)), le modèle s’attend à un tenseur de dimension `(batch_size)` où chaque valeur du lot correspond à l’étiquette attendue pour l’ensemble de la séquence.
- Pour les modèles de classification de jetons ([BertForTokenClassification](/docs/transformers/main/fr/model_doc/bert#transformers.BertForTokenClassification)), le modèle s’attend à un tenseur de dimension `(batch_size, seq_length)` où chaque valeur correspond à l’étiquette attendue pour chaque jeton individuel.
- Pour le langage masqué, ([BertForMaskedLM](/docs/transformers/main/fr/model_doc/bert#transformers.BertForMaskedLM)), le modèle s'attend à un tenseur de dimension `(batch_size, seq_length)` où chaque valeur correspond à l'étiquette attendue de chaque jeton individuel : les étiquettes étant l'identifiant du jeton pour le jeton masqué, et des valeurs à ignorer pour le reste (généralement -100).
- Pour les tâches de séquence à séquence ([BartForConditionalGeneration](/docs/transformers/main/fr/model_doc/bart#transformers.BartForConditionalGeneration), [MBartForConditionalGeneration](/docs/transformers/main/fr/model_doc/mbart#transformers.MBartForConditionalGeneration)), le modèle s'attend à un tenseur de dimension `(batch_size, tgt_seq_length)` où chaque valeur correspond aux séquences cibles associées à chaque séquence d'entrée. Lors de l'entraînement, BART et T5 génèrent en interne les `decoder_input_ids` et les masques d'attention du décodeur appropriés. Il n'est généralement pas nécessaire de les fournir. Cela ne s'applique pas aux modèles qui exploitent le framework Encoder-Decoder.
- Pour les modèles de classification d’images ([ViTForImageClassification](/docs/transformers/main/fr/model_doc/vit#transformers.ViTForImageClassification)), le modèle s’attend à un tenseur de dimension `(batch_size)` où chaque valeur du lot correspond à l’étiquette attendue pour chaque image individuelle.
- Pour les modèles de segmentation sémantique ([SegformerForSemanticSegmentation](/docs/transformers/main/fr/model_doc/segformer#transformers.SegformerForSemanticSegmentation)), le modèle s'attend à un tenseur de dimension `(batch_size, height, width)` où chaque valeur du lot correspond à l'étiquette attendue pour chaque pixel individuel.
- Pour les modèles de détection d'objets ([DetrForObjectDetection](/docs/transformers/main/fr/model_doc/detr#transformers.DetrForObjectDetection)), le modèle s'attend à une liste de dictionnaires avec les clés `class_labels` et `boxes`, où chaque valeur du lot correspond à l'étiquette attendue et au nombre de boîtes englobantes de chaque image individuelle.
- Pour les modèles de reconnaissance vocale automatique, ([Wav2Vec2ForCTC](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2ForCTC)), le modèle s'attend à un tenseur de dimension `(batch_size, target_length)` où chaque valeur correspond à l'étiquette attendue de chaque jeton individuel.

Les étiquettes de chaque modèle peuvent différer, il est donc essentiel de consulter systématiquement la documentation de chaque modèle pour obtenir des informations plus détaillées sur leurs étiquettes spécifiques !

Les modèles de base ([BertModel](/docs/transformers/main/fr/model_doc/bert#transformers.BertModel)) n’acceptent pas d’étiquettes, car il s’agit de modèles transformers de base qui se contentent de produire des caractéristiques.

### les grands modèles de langage (LLM)

Terme générique désignant les modèles de langage de type transformer (GPT-3, BLOOM, OPT) entraînés sur une grande quantité de données. Ces modèles ont également tendance à posséder un grand nombre de paramètres apprenables (par exemple, 175 milliards pour GPT-3).

## M

### modélisation de langage masquée (MLM)

Tâche de pré-entraînement dans laquelle le modèle observe une version corrompue des textes, généralement en masquant aléatoirement certains jetons, et doit prédire le texte d'origine.

### multimodal

Une tâche qui combine des textes avec un autre type d'entrées (par exemple des images).

## N

### Génération de langage naturel (NLG)

Toutes les tâches liées à la génération de texte (par exemple, [Write With Transformers](https://transformer.huggingface.co/), la traduction).

### Traitement du langage naturel (NLP)

Une manière générique de dire « traiter des textes ».

### Compréhension du langage naturel (NLU)

Toutes les tâches liées à la compréhension du contenu d'un texte (par exemple, la classification du texte entier ou de mots individuels).

## P

### pipeline

Un pipeline dans 🤗 Transformers est une abstraction désignant une série d'étapes exécutées dans un ordre spécifique afin de prétraiter et de transformer des données, puis de retourner une prédiction issue d'un modèle. Parmi les étapes d'un pipeline, on peut citer le prétraitement des données, l'extraction de caractéristiques et la normalisation.

Pour plus de détails, voir [Pipelines for inference](./pipeline_tutorial).

### PipelineParallel (PP)

Technique de parallélisme dans laquelle le modèle est découpé verticalement (au niveau des couches) sur plusieurs GPU, de sorte qu'une seule couche ou plusieurs couches du modèle sont placées sur un seul GPU. Chaque GPU traite en parallèle différentes étapes du pipeline et opère sur un petit fragment du lot. En savoir plus sur [PipelineParallel](./perf_train_gpu_many#pipeline-parallelism).

### valeurs de pixels

Un tenseur des représentations numériques d'une image qui est transmis à un modèle. Les valeurs de pixels ont une forme de [`batch_size`, `num_channels`, `height`, `width`] et sont générées par un processeur d'images.

### pooling

Une opération qui réduit une matrice en une matrice plus petite, en prenant le maximum ou la moyenne des dimensions agrégées. Les couches de pooling sont couramment utilisées entre les couches de convolution pour réduire l'échelle de la représentation des caractéristiques.

### identifiants de position

Contrairement aux RNN, dans lesquels la position de chaque jeton est intégrée, les transformers ne connaissent pas la position de chaque jeton. Les identifiants de position (`position_ids`) sont donc utilisés par le modèle pour identifier la position de chaque jeton dans la liste des jetons.

Ce sont des paramètres facultatifs. Si aucun `position_ids` n’est transmis au modèle, les identifiants sont automatiquement créés sous forme d’incrustations positionnelles absolues.

Les plongements positionnels absolus sont sélectionnés dans l'intervalle `[0, config.max_position_embeddings - 1]`. Certains modèles utilisent d'autres types de plongements positionnels, tels que les plongements positionnels sinusoïdaux ou les plongements de position relative.

### prétraitement

La tâche de préparation des données brutes dans un format facilement exploitable par les modèles d'apprentissage automatique. Par exemple, le texte est généralement prétraité par tokenization. Pour mieux comprendre à quoi ressemble le prétraitement pour d'autres types d'entrée, consultez le tutoriel [Preprocess](https://huggingface.co/docs/transformers/preprocessing).

### modèle pré-entraîné

Un modèle qui a été pré-entraîné sur certains données (par exemple, l’intégralité de Wikipédia). Les méthodes de pré-entraînement reposent sur un objectif auto-supervisé, qui peut consister à lire le texte et à prédire le mot suivant (voir [modélisation causale du langage](#causal-language-modeling)) ou à masquer certains mots et à tenter de les prédire (voir [modélisation du langage masqué](#masked-language-modeling-mlm)).

Les modèles de parole et de vision ont leurs propres objectifs de pré-entraînement. Par exemple, Wav2Vec2 est un modèle de parole pré-entraîné sur une tâche contrastive qui exige du modèle qu'il identifie la représentation « vraie » de la parole parmi un ensemble de représentations « fausses ». En revanche, BEiT est un modèle de vision pré-entraîné sur une tâche de modélisation d'image masquée qui masque certains patches de l'image et exige du modèle qu'il prédise les patches masqués (de manière similaire à l'objectif de modélisation de langage masquée).

## R

### réseau de neurones récurrent (RNN)

Un type de modèle qui utilise une boucle sur une couche pour traiter les textes.

### apprentissage de représentations

Un sous-domaine de l'apprentissage automatique qui se concentre sur l'apprentissage de représentations significatives de données brutes. Certains exemples de techniques d'apprentissage de représentations incluent les plongements de mots, les auto-encodeurs et les réseaux antagonistes génératifs (GAN).

## S

### taux d'échantillonnage

Mesure en hertz du nombre d'échantillons (du signal audio) pris par seconde. Le taux d'échantillonnage est le résultat de la discrétisation d'un signal continu tel que la parole.

### auto-attention

Chaque élément de l'entrée détermine à quels autres éléments de l'entrée il doit prêter attention.

### apprentissage auto-supervisé

Une catégorie de techniques d'apprentissage automatique dans laquelle un modèle crée son propre objectif d'apprentissage à partir de données non étiquetées. Elle diffère de l'[apprentissage non supervisé](#unsupervised-learning) et de l'[apprentissage supervisé](#supervised-learning) en ce que le processus d'apprentissage est supervisé, mais non explicitement par l'utilisateur.

Un exemple d'apprentissage auto-supervisé est le [modélisation de langage masquée](#masked-language-modeling-mlm), où un modèle reçoit des phrases dont une proportion de jetons a été supprimée et apprend à prédire les jetons manquants.

### apprentissage semi-supervisé

Une large catégorie de techniques d'entraînement du machine learning qui exploite une petite quantité de données étiquetées avec une plus grande quantité de données non étiquetées pour améliorer la précision d'un modèle, contrairement à l'[apprentissage supervisé](#supervised-learning) et à l'[apprentissage non supervisé](#unsupervised-learning).

Un exemple d’approche d’apprentissage semi-supervisé est le « self-training », dans lequel un modèle est entraîné sur des données étiquetées, puis utilisé pour effectuer des prédictions sur les données non étiquetées. La partie des données non étiquetées sur laquelle le modèle prédit avec la plus grande confiance est ajoutée au jeu de données étiquetées et utilisée pour réentraîner le modèle.

### séquence-à-séquence (seq2seq)

Les modèles qui génèrent une nouvelle séquence à partir d'une entrée, comme les modèles de traduction ou de résumés (tels que [Bart](./model_doc/bart) ou [T5](./model_doc/t5)).

### DDP fragmenté

Autre nom du concept fondamental [ZeRO](#zero-redundancy-optimizer-zero) tel qu'il est utilisé par diverses autres implémentations de ZeRO.

### stride

En [convolution](#convolution) ou [pooling](#pooling), le pas (stride) désigne la distance parcourue par le noyau sur une matrice. Un pas de 1 signifie que le noyau est déplacé d'un pixel à la fois, et un pas de 2 signifie que le noyau est déplacé de deux pixels à la fois.

### apprentissage supervisé

Une forme d’entraînement de modèle qui utilise directement des données étiquetées pour corriger et orienter les performances du modèle. Les données sont fournies au modèle en cours d’entraînement, et ses prédictions sont comparées aux étiquettes connues. Le modèle met à jour ses poids en fonction de l’erreur de ses prédictions, et le processus est répété pour optimiser les performances du modèle.

## T

### Parallélisme de tenseurs (TP)

Technique de parallélisme pour l’entraînement sur plusieurs GPU, dans laquelle chaque tenseur est découpé en plusieurs fragments. Ainsi, au lieu que l’intégralité du tenseur réside sur un seul GPU, chaque fragment du tenseur réside sur le GPU qui lui est assigné. Les fragments sont traités séparément et en parallèle sur différents GPU, et les résultats sont synchronisés à la fin de l’étape de traitement. C’est ce qu’on appelle parfois le parallélisme horizontal, car le découpage s’effectue au niveau horizontal. En savoir plus sur le Tensor Parallelism [ici](./perf_train_gpu_many#tensor-parallelism).

### token

Une partie d'une phrase, généralement un mot, mais qui peut aussi être un sous-mot (les mots peu courants sont souvent découpés en sous-mots) ou un symbole de ponctuation.

### identifiants de type de jeton

Certaines modèles ont pour objectif de réaliser la classification de paires de phrases ou la réponse à des questions.

Ces modèles nécessitent de combiner deux séquences différentes dans une seule entrée « input_ids », ce qui est généralement réalisé à l’aide de jetons spéciaux, tels que le jeton de classification (`[CLS]`) et le jeton séparateur (`[SEP]`). Par exemple, le modèle BERT construit son entrée de deux séquences de la manière suivante :

```python
>>> # [CLS] SEQUENCE_A [SEP] SEQUENCE_B [SEP]
```

Nous pouvons utiliser notre tokenizer pour générer automatiquement une telle phrase en passant les deux séquences à `tokenizer` comme deux arguments (et non comme une liste, comme précédemment) de la manière suivante :

```python
>>> from transformers import BertTokenizer

>>> tokenizer = BertTokenizer.from_pretrained("google-bert/bert-base-cased")
>>> sequence_a = "HuggingFace is based in NYC"
>>> sequence_b = "Where is HuggingFace based?"

>>> encoded_dict = tokenizer(sequence_a, sequence_b)
>>> decoded = tokenizer.decode(encoded_dict["input_ids"])
```

ce qui renverra :

```python
>>> print(decoded)
[CLS] HuggingFace is based in NYC [SEP] Where is HuggingFace based? [SEP]
```

Cela suffit à certains modèles pour comprendre où s’arrête une séquence et où commence une autre. Cependant, d’autres modèles, tels que BERT, utilisent également des identifiants de type de jeton (également appelés identifiants de segment). Ils sont représentés par un masque binaire identifiant les deux types de séquences dans le modèle.

Le tokeniseur renvoie ce masque en tant qu'entrée "token_type_ids" :

```python
>>> encoded_dict["token_type_ids"]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1]
```

La première séquence, le « contexte » utilisé pour la question, a tous ses jetons représentés par un `0`, tandis que la deuxième séquence, correspondant à la « question », a tous ses jetons représentés par un `1`.

Certains modèles, comme [XLNetModel](/docs/transformers/main/fr/model_doc/xlnet#transformers.XLNetModel), utilisent un jeton supplémentaire représenté par un `2`.

### apprentissage par transfert

Une technique qui consiste à prendre un modèle pré-entraîné et à l’adapter à un jeu de données spécifique à votre tâche. Plutôt que d’entraîner un modèle à partir de zéro, vous pouvez exploiter les connaissances acquises par un modèle existant comme point de départ. Cela accélère le processus d’apprentissage et réduit la quantité de données d’entraînement nécessaires.

### transformer

Architecture de modèle d'apprentissage profond basée sur l'auto-attention.

## U

### apprentissage non supervisé

Une forme d’entraînement de modèle dans laquelle les données fournies au modèle ne sont pas étiquetées. Les techniques d’apprentissage non supervisé exploitent les informations statistiques de la distribution des données pour trouver des motifs utiles pour la tâche en cours.

## Z

### Optimiseur sans redondance (ZeRO)

Technique de parallélisme qui effectue le fractionnement des tenseurs de manière quelque peu similaire à [TensorParallel](#tensor-parallelism-tp), à l'exception que le tenseur complet est reconstruit à temps pour un calcul avant ou arrière, de sorte que le modèle n'a pas besoin d'être modifié. Cette méthode prend également en charge diverses techniques de déchargement pour compenser la mémoire GPU limitée. En savoir plus sur ZeRO [ici](./perf_train_gpu_many#zero-data-parallelism).