# Collateur de données

Les collateurs de données sont des objets qui forment un lot en utilisant une liste d'éléments de jeu de données en entrée. Ces éléments sont du même type que les éléments de `train_dataset` ou `eval_dataset`.

Afin de pouvoir constituer des lots, les collateurs de données peuvent appliquer certains traitements (comme le bourrage). Certains d’entre eux (comme [DataCollatorForLanguageModeling](/docs/transformers/v5.23.0/fr/main_classes/data_collator#transformers.DataCollatorForLanguageModeling)) appliquent également une augmentation aléatoire des données (comme le masquage aléatoire) sur le lot formé.

Des exemples d'utilisation peuvent être trouvés dans les [notebooks d'exemples](https://github.com/huggingface/notebooks/tree/main/examples).

## Collateur de données par défaut[[transformers.default_data_collator]]

#### transformers.default_data_collator[[transformers.default_data_collator]]

```python
transformers.default_data_collator(features: list[typing.Any], return_tensors = 'pt')
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/data/data_collator.py#L71)

Collateur de données très simple qui assemble simplement des lots d'objets de type dictionnaire et effectue un traitement spécial pour les clés potentielles nommées :

- `label` : gère une seule valeur (int ou float) par objet
- `label_ids` : gère une liste de valeurs par objet

N’effectue aucun prétraitement supplémentaire : les noms de propriétés de l’objet d’entrée seront utilisés comme entrées correspondantes pour le modèle. Consultez glue et ner pour des exemples d’utilité.

## DefaultDataCollator[[transformers.DefaultDataCollator]]

#### transformers.DefaultDataCollator[[transformers.DefaultDataCollator]]

```python
transformers.DefaultDataCollator(return_tensors: str = 'pt')
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/data/data_collator.py#L95)

**Paramètres :**

return_tensors (`str`, *facultatif*, valeur par défaut `"pt"`) : Le type de Tensor à retourner. Les valeurs autorisées sont "np" ou "pt".

Collateur de données très simple qui assemble simplement des lots d'objets de type dictionnaire et effectue un traitement spécial pour les clés potentielles nommées :

- `label` : gère une seule valeur (int ou float) par objet
- `label_ids` : gère une liste de valeurs par objet

N’effectue aucun prétraitement supplémentaire : les noms de propriétés de l’objet d’entrée seront utilisés comme entrées correspondantes pour le modèle. Consultez glue et ner pour des exemples d’utilité.

Il s'agit d'un objet (comme les autres data collators) plutôt que d'une fonction pure comme default_data_collator. Cela peut être utile si vous devez définir une valeur de return_tensors lors de l'initialisation.

## DataCollatorWithPadding[[transformers.DataCollatorWithPadding]]

#### transformers.DataCollatorWithPadding[[transformers.DataCollatorWithPadding]]

```python
transformers.DataCollatorWithPadding(tokenizer: PreTrainedTokenizerBase, padding: bool | str | transformers.utils.generic.PaddingStrategy = True, max_length: int | None = None, pad_to_multiple_of: int | None = None, return_tensors: str = 'pt')
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/data/data_collator.py#L191)

**Paramètres :**

tokenizer ([PreTrainedTokenizer](/docs/transformers/v5.23.0/fr/main_classes/tokenizer#transformers.PythonBackend) ou [PreTrainedTokenizerFast](/docs/transformers/v5.23.0/fr/main_classes/tokenizer#transformers.TokenizersBackend)) : le tokenizer utilisé pour encoder les données.

padding (`bool`, `str` ou [PaddingStrategy](/docs/transformers/v5.23.0/fr/internal/file_utils#transformers.utils.PaddingStrategy), *facultatif*, par défaut `True`) : Sélectionne une stratégie pour mettre en place le padding des séquences renvoyées (selon le côté de padding et l'index de padding du modèle) parmi :  - `True` ou `'longest'` (par défaut) : Met en place le padding jusqu'à la séquence la plus longue du lot (ou aucun padding si une seule séquence est fournie). - `'max_length'` : Met en place le padding jusqu'à une longueur maximale spécifiée avec l'argument `max_length` ou jusqu'à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. - `False` ou `'do_not_pad'` : Aucun padding (c'est-à-dire, peut renvoyer un lot avec des séquences de longueurs différentes).

max_length (`int`, *facultatif*) : Longueur maximale de la liste renvoyée et, le cas échéant, longueur du bourrage (voir ci-dessus).

pad_to_multiple_of (`int`, *facultatif*) : Si défini, la séquence sera rembourdée jusqu'à un multiple de la valeur fournie. Cela est particulièrement utile pour permettre l'utilisation des Tensor Cores sur le matériel NVIDIA avec une capacité de calcul >= 7.0 (Volta).

return_tensors (`str`, *facultatif*, valeur par défaut `"pt"`) : Le type de Tensor à retourner. Les valeurs autorisées sont "np" ou "pt".

Collateur de données qui rembourra dynamiquement les entrées reçues.

## DataCollatorForTokenClassification[[transformers.DataCollatorForTokenClassification]]

#### transformers.DataCollatorForTokenClassification[[transformers.DataCollatorForTokenClassification]]

```python
transformers.DataCollatorForTokenClassification(tokenizer: PreTrainedTokenizerBase, padding: bool | str | transformers.utils.generic.PaddingStrategy = True, max_length: int | None = None, pad_to_multiple_of: int | None = None, label_pad_token_id: int = -100, return_tensors: str = 'pt')
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/data/data_collator.py#L243)

**Paramètres :**

tokenizer ([PreTrainedTokenizer](/docs/transformers/v5.23.0/fr/main_classes/tokenizer#transformers.PythonBackend) ou [PreTrainedTokenizerFast](/docs/transformers/v5.23.0/fr/main_classes/tokenizer#transformers.TokenizersBackend)) : le tokenizer utilisé pour encoder les données.

padding (`bool`, `str` ou [PaddingStrategy](/docs/transformers/v5.23.0/fr/internal/file_utils#transformers.utils.PaddingStrategy), *facultatif*, par défaut `True`) : Sélectionne une stratégie pour mettre en place le padding des séquences renvoyées (selon le côté de padding et l'index de padding du modèle) parmi :  - `True` ou `'longest'` (par défaut) : Met en place le padding jusqu'à la séquence la plus longue du lot (ou aucun padding si une seule séquence est fournie). - `'max_length'` : Met en place le padding jusqu'à une longueur maximale spécifiée avec l'argument `max_length` ou jusqu'à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. - `False` ou `'do_not_pad'` : Aucun padding (c'est-à-dire, peut renvoyer un lot avec des séquences de longueurs différentes).

max_length (`int`, *facultatif*) : Longueur maximale de la liste renvoyée et, le cas échéant, longueur du bourrage (voir ci-dessus).

pad_to_multiple_of (`int`, *facultatif*) : Si défini, la séquence sera rembourdée jusqu'à un multiple de la valeur fournie. Cela est particulièrement utile pour permettre l'utilisation des Tensor Cores sur le matériel NVIDIA avec une capacité de calcul >= 7.0 (Volta).

label_pad_token_id (`int`, *facultatif*, valeur par défaut -100) : l'identifiant à utiliser lors de l'ajout de bourrage aux étiquettes (-100 sera automatiquement ignoré par les fonctions de perte de PyTorch).

return_tensors (`str`, *facultatif*, valeur par défaut `"pt"`) : Le type de Tensor à retourner. Les valeurs autorisées sont "np" ou "pt".

Collateur de données qui rembourra dynamiquement les entrées reçues, ainsi que les étiquettes.

## DataCollatorForSeq2Seq[[transformers.DataCollatorForSeq2Seq]]

#### transformers.DataCollatorForSeq2Seq[[transformers.DataCollatorForSeq2Seq]]

```python
transformers.DataCollatorForSeq2Seq(tokenizer: PreTrainedTokenizerBase, model: typing.Any | None = None, padding: bool | str | transformers.utils.generic.PaddingStrategy = True, max_length: int | None = None, pad_to_multiple_of: int | None = None, label_pad_token_id: int = -100, return_tensors: str = 'pt')
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/data/data_collator.py#L491)

**Paramètres :**

tokenizer ([PreTrainedTokenizer](/docs/transformers/v5.23.0/fr/main_classes/tokenizer#transformers.PythonBackend) ou [PreTrainedTokenizerFast](/docs/transformers/v5.23.0/fr/main_classes/tokenizer#transformers.TokenizersBackend)) : le tokenizer utilisé pour encoder les données.

model ([PreTrainedModel](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel), *facultatif*) : Le modèle qui est en cours d'entraînement. S'il est défini et possède *prepare_decoder_input_ids_from_labels*, utilisez-le pour préparer *decoder_input_ids*. Cela est utile lors de l'utilisation de *label_smoothing* afin d'éviter de calculer la perte deux fois.

padding (`bool`, `str` ou [PaddingStrategy](/docs/transformers/v5.23.0/fr/internal/file_utils#transformers.utils.PaddingStrategy), *facultatif*, par défaut `True`) : Sélectionne une stratégie pour mettre en place le padding des séquences renvoyées (selon le côté de padding et l'index de padding du modèle) parmi :  - `True` ou `'longest'` (par défaut) : Met en place le padding jusqu'à la séquence la plus longue du lot (ou aucun padding si une seule séquence est fournie). - `'max_length'` : Met en place le padding jusqu'à une longueur maximale spécifiée avec l'argument `max_length` ou jusqu'à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. - `False` ou `'do_not_pad'` : Aucun padding (c'est-à-dire, peut renvoyer un lot avec des séquences de longueurs différentes).

max_length (`int`, *facultatif*) : Longueur maximale de la liste renvoyée et, le cas échéant, longueur du bourrage (voir ci-dessus).

pad_to_multiple_of (`int`, *facultatif*) : Si défini, la séquence sera rembourdée jusqu'à un multiple de la valeur fournie. Cela est particulièrement utile pour permettre l'utilisation des Tensor Cores sur le matériel NVIDIA avec une capacité de calcul >= 7.0 (Volta).

label_pad_token_id (`int`, *facultatif*, valeur par défaut -100) : l'identifiant à utiliser lors de l'ajout de bourrage aux étiquettes (-100 sera automatiquement ignoré par les fonctions de perte de PyTorch).

return_tensors (`str`, *facultatif*, valeur par défaut `"pt"`) : Le type de Tensor à retourner. Les valeurs autorisées sont "np" ou "pt".

Collateur de données qui rembourra dynamiquement les entrées reçues, ainsi que les étiquettes.

## DataCollatorForLanguageModeling[[transformers.DataCollatorForLanguageModeling]]

#### transformers.DataCollatorForLanguageModeling[[transformers.DataCollatorForLanguageModeling]]

```python
transformers.DataCollatorForLanguageModeling(tokenizer: PreTrainedTokenizerBase, mlm: bool = True, whole_word_mask: bool = False, mlm_probability: float | None = 0.15, mask_replace_prob: float = 0.8, random_replace_prob: float = 0.1, pad_to_multiple_of: int | None = None, return_tensors: str = 'pt', seed: int | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/data/data_collator.py#L623)

**Paramètres :**

tokenizer ([PreTrainedTokenizer](/docs/transformers/v5.23.0/fr/main_classes/tokenizer#transformers.PythonBackend) ou [PreTrainedTokenizerFast](/docs/transformers/v5.23.0/fr/main_classes/tokenizer#transformers.TokenizersBackend)) : le tokenizer utilisé pour encoder les données.

mlm (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut utiliser le masked language modeling. Si la valeur est `False`, les étiquettes sont identiques aux entrées, les jetons de bourrage étant ignorés (en les définissant à -100). Sinon, les étiquettes sont -100 pour les jetons non masqués et la valeur à prédire pour le jeton masqué.

whole_word_mask (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut masquer des mots entiers plutôt que des jetons individuels.

mlm_probability (`float`, *facultatif*, valeur par défaut 0.15) : La probabilité avec laquelle masquer (aléatoirement) les jetons de l'entrée, lorsque `mlm` est défini sur `True`.

mask_replace_prob (`float`, *facultatif*, valeur par défaut 0.8) : La probabilité avec laquelle les jetons masqués sont remplacés par le jeton de masque du tokeniseur (par exemple, `[MASK]`). La valeur par défaut est 0.8, ce qui signifie que 80 % des jetons masqués seront remplacés par `[MASK]`. Ne fonctionne que lorsque `mlm` est défini sur `True`.

random_replace_prob (`float`, *facultatif*, par défaut 0.1) : La probabilité avec laquelle les jetons masqués sont remplacés par des jetons aléatoires issus du vocabulaire du tokeniseur. La valeur par défaut est 0.1, ce qui signifie que 10 % des jetons masqués seront remplacés par des jetons aléatoires. Les jetons masqués restants (1 - mask_replace_prob - random_replace_prob) sont laissés inchangés. Ne fonctionne que lorsque `mlm` est défini sur `True`.

pad_to_multiple_of (`int`, *facultatif*) : Si défini, la séquence sera rembourdée jusqu'à un multiple de la valeur fournie.

return_tensors (`str`) : Le type de Tensor à retourner. Les valeurs autorisées sont "np" ou "pt".

seed (`int`, *facultatif*) : Graine à utiliser pour le générateur de nombres aléatoires servant au masquage. Si elle n'est pas fournie, le générateur aléatoire global sera utilisé.

Collateur de données utilisé pour le modélisation du langage. Les entrées sont dynamiquement rembourrées jusqu'à la longueur maximale d'un lot si elles ne sont pas toutes de la même longueur.

Pour de meilleures performances, ce collateur de données doit être utilisé avec un jeu de données dont les éléments sont des dictionnaires ou des BatchEncoding, avec la clé `"special_tokens_mask"`, comme renvoyé par un [PreTrainedTokenizer](/docs/transformers/v5.23.0/fr/main_classes/tokenizer#transformers.PythonBackend) ou un [PreTrainedTokenizerFast](/docs/transformers/v5.23.0/fr/main_classes/tokenizer#transformers.TokenizersBackend) avec l'argument `return_special_tokens_mask=True`.

1. Comportement par défaut :
   - `mask_replace_prob=0.8`, `random_replace_prob=0.1`.
   - Attendez-vous à ce que 80 % des masqués soient remplacés par `[MASK]`, 10 % par des jetons aléatoires et 10 % restent inchangés.

2. Tous les jetons masqués remplacés par `[MASK]` :
   - `mask_replace_prob=1.0`, `random_replace_prob=0.0`.
   - Tous les jetons masqués doivent être remplacés par `[MASK]`. Aucun jeton n'est laissé inchangé ou remplacé par des jetons aléatoires.

3. Aucun remplacement par `[MASK]`, uniquement des jetons aléatoires :
   - `mask_replace_prob=0.0`, `random_replace_prob=1.0`.
   - Attendez-vous à ce que tous les jetons masqués soient remplacés par des jetons aléatoires. Aucun remplacement par `[MASK]` ni jeton inchangé.

4. Remplacement équilibré :
   - `mask_replace_prob=0.5`, `random_replace_prob=0.4`.
   - Attendez-vous à ce que 50 % des masqués soient remplacés par `[MASK]`, 40 % par des jetons aléatoires et 10 % restent inchangés.

Note : la somme de `mask_replace_prob` et de `random_replace_prob` ne doit pas dépasser 1. Si leur somme est inférieure à 1, la proportion restante sera constituée de jetons masqués laissés inchangés.

#### numpy_mask_tokens[[transformers.DataCollatorForLanguageModeling.numpy_mask_tokens]]

```python
numpy_mask_tokens(inputs: Any, special_tokens_mask: typing.Any | None = None, offset_mapping: typing.Any | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/data/data_collator.py#L894)

Prépare les entrées/étiquettes des jetons masqués pour le modélisation de langage masquée.

#### torch_mask_tokens[[transformers.DataCollatorForLanguageModeling.torch_mask_tokens]]

```python
torch_mask_tokens(inputs: Any, special_tokens_mask: typing.Any | None = None, offset_mapping: typing.Any | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/data/data_collator.py#L800)

Prépare les entrées/étiquettes des jetons masqués pour le modélisation de langage masquée.

## DataCollatorForPermutationLanguageModeling[[transformers.DataCollatorForPermutationLanguageModeling]]

#### transformers.DataCollatorForPermutationLanguageModeling[[transformers.DataCollatorForPermutationLanguageModeling]]

```python
transformers.DataCollatorForPermutationLanguageModeling(tokenizer: PreTrainedTokenizerBase, plm_probability: float = 0.16666666666666666, max_span_length: int = 5, return_tensors: str = 'pt')
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/data/data_collator.py#L1032)

Collateur de données utilisé pour le modélisation de langage par permutation.

- regroupe des lots de tenseurs en respectant le pad_token du tokeniseur
- prétraite les lots pour la modélisation de langage par permutation avec des procédures spécifiques à XLNet

#### numpy_mask_tokens[[transformers.DataCollatorForPermutationLanguageModeling.numpy_mask_tokens]]

```python
numpy_mask_tokens(inputs: Any)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/data/data_collator.py#L1158)

Les jetons masqués à prédire pour une séquence donnée sont déterminés par l'algorithme suivant :

0. Commencez par le début de la séquence en définissant `cur_len = 0` (nombre de jetons traités jusqu'à présent).
1. Échantillonner un `span_length` à partir de l'intervalle `[1, max_span_length]` (longueur de la séquence de jetons à masquer)
2. Réserver un contexte de longueur `context_length = span_length / plm_probability` pour entourer l'espacement à masquer
3. Échantillonner un point de départ `start_index` à partir de l'intervalle `[cur_len, cur_len + context_length - span_length]` et masquer les jetons `start_index:start_index + span_length`
4. Définir `cur_len = cur_len + context_length`. Si `cur_len < max_len` (c.-à-d. qu'il reste des jetons dans la séquence à traiter), répéter depuis l'étape 1.

#### torch_mask_tokens[[transformers.DataCollatorForPermutationLanguageModeling.torch_mask_tokens]]

```python
torch_mask_tokens(inputs: Any)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/data/data_collator.py#L1059)

Les jetons masqués à prédire pour une séquence donnée sont déterminés par l'algorithme suivant :

0. Commencez par le début de la séquence en définissant `cur_len = 0` (nombre de jetons traités jusqu'à présent).
1. Échantillonner un `span_length` à partir de l'intervalle `[1, max_span_length]` (longueur de la séquence de jetons à masquer)
2. Réserver un contexte de longueur `context_length = span_length / plm_probability` pour entourer l'espacement à masquer
3. Échantillonner un point de départ `start_index` à partir de l'intervalle `[cur_len, cur_len + context_length - span_length]` et masquer les jetons `start_index:start_index + span_length`
4. Définir `cur_len = cur_len + context_length`. Si `cur_len < max_len` (c.-à-d. qu'il reste des jetons dans la séquence à traiter), répéter depuis l'étape 1.

## DataCollatorWithFlattening[[transformers.DataCollatorWithFlattening]]

#### transformers.DataCollatorWithFlattening[[transformers.DataCollatorWithFlattening]]

```python
transformers.DataCollatorWithFlattening(*args, return_position_ids = True, separator_id = -100, return_flash_attn_kwargs = False, return_seq_idx = False, position_ids_start = 0, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/data/data_collator.py#L1257)

**Paramètres :**

return_position_ids (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut retourner `position_ids`, qui repartent de `position_ids_start` pour chaque séquence aplatie.

separator_id (`int`, *facultatif*, valeur par défaut : -100) : La valeur utilisée pour séparer les séquences au sein des `labels` concaténés.

return_flash_attn_kwargs (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut retourner les kwargs de limites de séquence utilisés par FlashAttention (`cu_seq_lens_q`, `cu_seq_lens_k`, `max_length_q` et `max_length_k`).

return_seq_idx (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut retourner `seq_idx`, qui indique la séquence à laquelle appartient chaque jeton.

position_ids_start (`int`, *facultatif*, valeur par défaut 0) : l'identifiant de position attribué au premier jeton de chaque séquence.

Collateur de données utilisé pour l'approche sans bourrage. Effectue les opérations suivantes :

- concatène l'ensemble du mini-lot en une seule longue séquence de forme [1, total_tokens]
- utilise `separator_id` pour séparer les séquences au sein des `labels` concaténés, la valeur par défaut est -100
- aucun padding ne sera ajouté, renvoie par défaut `input_ids`, `labels` et `position_ids`
- retourne éventuellement les kwargs contenus dans FlashAttentionKwargs
- retourne éventuellement seq_idx indiquant à quelle séquence chaque jeton appartient

L'utilisation de `DataCollatorWithFlattening` aplatit l'ensemble du mini-lot en une seule longue séquence. Assurez-vous que votre calcul d'attention est en mesure de le gérer !

Tous les modèles ne numérotent pas les positions à partir de 0 lorsqu’ils calculent eux-mêmes les identifiants de position. Les architectures de type RoBERTa (dont `roberta`, `xlm_roberta`, `camembert`, `mpnet` et `esm` avec des embeddings de position absolus) commencent à `padding_idx + 1`, qui est généralement 2. Si l’on transmet à ces modèles les `position_ids` par défaut basées sur 0, les embeddings de position sont décalés silencieusement, ce qui dégrade leurs sorties ; il convient donc de définir `position_ids_start` en conséquence pour ces modèles.

## DataCollatorForMultipleChoice[[transformers.DataCollatorForMultipleChoice]]

#### transformers.DataCollatorForMultipleChoice[[transformers.DataCollatorForMultipleChoice]]

```python
transformers.DataCollatorForMultipleChoice(tokenizer: PreTrainedTokenizerBase, padding: bool | str | transformers.utils.generic.PaddingStrategy = True, max_length: int | None = None, pad_to_multiple_of: int | None = None, return_tensors: str = 'pt')
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/data/data_collator.py#L422)

**Paramètres :**

tokenizer ([PreTrainedTokenizer](/docs/transformers/v5.23.0/fr/main_classes/tokenizer#transformers.PythonBackend) ou [PreTrainedTokenizerFast](/docs/transformers/v5.23.0/fr/main_classes/tokenizer#transformers.TokenizersBackend)) : le tokenizer utilisé pour encoder les données.

padding (`bool`, `str` ou [PaddingStrategy](/docs/transformers/v5.23.0/fr/internal/file_utils#transformers.utils.PaddingStrategy), *facultatif*, valeur par défaut `True`) : Sélectionne une stratégie pour mettre en place le padding des séquences renvoyées en fonction du côté de padding et de l'index de padding du modèle, parmi :  - `True` ou `'longest'` : Padding jusqu'à la séquence la plus longue du lot (ou aucun padding si une seule séquence est fournie). - `'max_length'` : Padding jusqu'à une longueur maximale spécifiée avec l'argument `max_length` ou jusqu'à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. - `False` ou `'do_not_pad'` (par défaut) : Aucun padding (c'est-à-dire, peut renvoyer un lot avec des séquences de longueurs différentes).

max_length (`int`, *facultatif*) : Longueur maximale de la liste renvoyée et, le cas échéant, longueur du bourrage (voir ci-dessus).

pad_to_multiple_of (`int`, *facultatif*) : Rembourrer la séquence jusqu'à un multiple de la valeur fournie. Cela est particulièrement utile pour permettre l'utilisation des Tensor Cores sur le matériel NVIDIA avec une capacité de calcul >= 7.5 (Volta).

return_tensors (`str`, *facultatif*, valeur par défaut `"pt"`) : Le type de Tensor à retourner. Les valeurs autorisées sont "np" ou "pt".

Collateur de données qui effectue un bourrage dynamique d'un lot d'exemples imbriqués pour le choix multiple, de sorte que tous les choix de tous les exemples aient la même longueur.