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) 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.

Collateur de données par défaut

transformers.default_data_collator

< source >

( features: listreturn_tensors = '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'utilisation.

DefaultDataCollator

classe transformers.DefaultDataCollator

< source >

( return_tensors: str = 'pt' )

Paramètres

return_tensors (str, facultatif, 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

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 avez besoin de définir une valeur de return_tensors à l’initialisation.

DataCollatorWithPadding

classe transformers.DataCollatorWithPadding

< source >

( tokenizer: PreTrainedTokenizerBasepadding: bool | str | transformers.utils.generic.PaddingStrategy = Truemax_length: int | None = Nonepad_to_multiple_of: int | None = Nonereturn_tensors: str = 'pt' )

Paramètres

tokenizer (PreTrainedTokenizer ou PreTrainedTokenizerFast) — Le tokenizer utilisé pour encoder les données.
padding (bool, str ou PaddingStrategy, facultatif, 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) : Rembourrer jusqu'à la séquence la plus longue du lot (ou aucun rembourrage si une seule séquence est fournie).
- 'max_length' : Remplir jusqu'à une longueur maximale spécifiée par 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 produire 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 est rembourrée jusqu'à un multiple de la valeur fournie.
C'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, 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

classe transformers.DataCollatorForTokenClassification

< source >

Paramètres

tokenizer (PreTrainedTokenizer ou PreTrainedTokenizerFast) — Le tokenizer utilisé pour encoder les données.
padding (bool, str ou PaddingStrategy, facultatif, 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) : Rembourrer jusqu'à la séquence la plus longue du lot (ou aucun rembourrage si une seule séquence est fournie).
- 'max_length' : Remplir jusqu'à une longueur maximale spécifiée par 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 produire 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 est rembourrée jusqu'à un multiple de la valeur fournie.
C'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 rembourrage aux étiquettes (-100 sera automatiquement ignoré par les fonctions de perte de PyTorch).
return_tensors (str, facultatif, 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

classe transformers.DataCollatorForSeq2Seq

< source >

( tokenizer: PreTrainedTokenizerBasemodel: typing.Any | None = Nonepadding: bool | str | transformers.utils.generic.PaddingStrategy = Truemax_length: int | None = Nonepad_to_multiple_of: int | None = Nonelabel_pad_token_id: int = -100return_tensors: str = 'pt' )

Paramètres

tokenizer (PreTrainedTokenizer ou PreTrainedTokenizerFast) — Le tokenizer utilisé pour encoder les données.
model (PreTrainedModel, facultatif) — Le modèle qui est en cours d'entraînement. S'il est défini et possède la méthode prepare_decoder_input_ids_from_labels, utilisez-la pour préparer les decoder_input_ids
Cela est utile lors de l'utilisation de label_smoothing pour éviter de calculer la perte deux fois.
padding (bool, str ou PaddingStrategy, facultatif, 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) : Rembourrer jusqu'à la séquence la plus longue du lot (ou aucun rembourrage si une seule séquence est fournie).
- 'max_length' : Remplir jusqu'à une longueur maximale spécifiée par 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 produire 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 est rembourrée jusqu'à un multiple de la valeur fournie.
C'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 rembourrage aux étiquettes (-100 sera automatiquement ignoré par les fonctions de perte de PyTorch).
return_tensors (str, facultatif, 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

classe transformers.DataCollatorForLanguageModeling

< source >

( tokenizer: PreTrainedTokenizerBasemlm: bool = Truewhole_word_mask: bool = Falsemlm_probability: float | None = 0.15mask_replace_prob: float = 0.8random_replace_prob: float = 0.1pad_to_multiple_of: int | None = Nonereturn_tensors: str = 'pt'seed: int | None = None )

Paramètres

tokenizer (PreTrainedTokenizer ou PreTrainedTokenizerFast) — Le tokenizer utilisé pour encoder les données.
mlm (bool, facultatif, par défaut True) — Indique s'il faut utiliser le modélisation de langage masquée. Si défini sur 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, 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]. Fonctionne uniquement lorsque mlm est défini sur True.
random_replace_prob (float, facultatif, valeur 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. Fonctionne uniquement 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) — La graine à utiliser pour le générateur de nombres aléatoires de 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 de langage. Les entrées sont dynamiquement remplies jusqu'à la longueur maximale d'un lot si elles ne sont pas toutes de la même longueur.

Pour une performance optimale, 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 ou un PreTrainedTokenizerFast avec l'argument return_special_tokens_mask=True.
<Example Options and Expectations>
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.

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.

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é.

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 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

< source >

( inputs: Anyspecial_tokens_mask: typing.Any | None = Noneoffset_mapping: typing.Any | None = None )

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

torch_mask_tokens

< source >

( inputs: Anyspecial_tokens_mask: typing.Any | None = Noneoffset_mapping: typing.Any | None = None )

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

DataCollatorForPermutationLanguageModeling

classe transformers.DataCollatorForPermutationLanguageModeling

< source >

( tokenizer: PreTrainedTokenizerBaseplm_probability: float = 0.16666666666666666max_span_length: int = 5return_tensors: str = 'pt' )

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

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

numpy_mask_tokens

< source >

( inputs: Any )

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

Commencez par le début de la séquence en définissant cur_len = 0 (nombre de jetons traités jusqu'à présent).
Échantillonner un span_length à partir de l'intervalle [1, max_span_length] (longueur de la séquence de jetons à masquer)
Réservez un contexte de longueur context_length = span_length / plm_probability pour entourer la portion à masquer
É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
Définissez cur_len = cur_len + context_length. Si cur_len < max_len (c’est-à-dire s’il reste des jetons dans la séquence à traiter), répétez depuis l’étape 1.

torch_mask_tokens

< source >

( inputs: Any )

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

Commencez par le début de la séquence en définissant cur_len = 0 (nombre de jetons traités jusqu'à présent).
Échantillonner un span_length à partir de l'intervalle [1, max_span_length] (longueur de la séquence de jetons à masquer)
Réservez un contexte de longueur context_length = span_length / plm_probability pour entourer la portion à masquer
É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
Définissez cur_len = cur_len + context_length. Si cur_len < max_len (c’est-à-dire s’il reste des jetons dans la séquence à traiter), répétez depuis l’étape 1.

DataCollatorWithFlattening

classe transformers.DataCollatorWithFlattening

< source >

( *argsreturn_position_ids = Trueseparator_id = -100return_flash_attn_kwargs = Falsereturn_seq_idx = Falseposition_ids_start = 0**kwargs )

Paramètres

return_position_ids (bool, facultatif, 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, par défaut False) — Indique s'il faut retourner seq_idx, qui précise 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 (parmi lesquelles roberta, xlm_roberta, camembert, mpnet et esm avec des embeddings de position absolus) commencent à padding_idx + 1, ce 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 et leurs sorties se dégradent ; il convient donc de définir position_ids_start en conséquence pour ces modèles.

DataCollatorForMultipleChoice

classe transformers.DataCollatorForMultipleChoice

< source >

Paramètres

tokenizer (PreTrainedTokenizer ou PreTrainedTokenizerFast) — Le tokenizer utilisé pour encoder les données.
padding (bool, str ou PaddingStrategy, facultatif, 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' : Ajuster à la séquence la plus longue du lot (ou aucun ajustement si une seule séquence est fournie).
- 'max_length' : Remplir jusqu'à une longueur maximale spécifiée par 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 produire 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) — Remplit la séquence jusqu'à un multiple de la valeur fournie.
C'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, par défaut "pt") — Le type de Tensor à retourner. Les valeurs autorisées sont « np » ou « pt ».

Collateur de données qui remplit dynamiquement 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.

Update on GitHub

Transformers

Collateur de données