Transformers documentation
UMT5
Ce modèle a été publié dans HF papers le 2023-04-18 et contribué à Hugging Face Transformers le 2023-07-03.
UMT5
Aperçu
Le modèle UMT5 a été proposé dans UniMax: Fairer and More Effective Language Sampling for Large-Scale Multilingual Pretraining par Hyung Won Chung, Xavier Garcia, Adam Roberts, Yi Tay, Orhan Firat, Sharan Narang, Noah Constant.
L'abstract de l'article est le suivant :
Les grands modèles de langage multilingues préentraînés ont généralement recours à un échantillonnage heuristique basé sur la température pour équilibrer les différentes langues. Toutefois, les travaux antérieurs n’ont pas évalué de manière systématique l’efficacité des différentes distributions de langues de préentraînement selon l’échelle des modèles. Dans cet article, nous proposons une nouvelle méthode d’échantillonnage, UniMax, qui offre une couverture plus uniforme des langues principales tout en limitant le surapprentissage sur les langues secondaires en plafonnant explicitement le nombre de répétitions sur le corpus de chaque langue. Nous réalisons une série exhaustive d’ablations testant un éventail de stratégies d’échantillonnage sur une suite de benchmarks multilingues, en faisant varier l’échelle du modèle. Nous constatons que UniMax surpasse l’échantillonnage standard basé sur la température, et que ces avantages persistent à mesure que l’échelle augmente. Dans le cadre de notre contribution, nous publions : (i) un corpus multilingue mC4 amélioré et actualisé, composé de 29 billions de caractères répartis sur 107 langues, et (ii) une suite de points de contrôle de modèles umT5 préentraînés avec l’échantillonnage UniMax.
Google a publié les variantes suivantes :
Ce modèle a été contribué par agemagician et stefan-it. Le code d'origine peut être trouvé ici.
Conseils d'utilisation
- UMT5 n’a été pré-entraîné que sur une version actualisée du corpus mC4 (107 langues ; le mC4 d’origine correspond à la configuration
multilingualdeallenai/c4), sans aucun entraînement supervisé. Par conséquent, ce modèle doit être affiné avant d’être utilisable sur une tâche en aval, contrairement au modèle T5 d’origine. - Étant donné que umT5 a été pré-entraîné de manière non supervisée, l’utilisation d’un préfixe de tâche n’apporte pas de réel avantage lors de l’ajustement fin sur une tâche unique. En revanche, si vous effectuez un ajustement fin multi-tâches, vous devez utiliser un préfixe.
Différences avec mT5 ?
UmT5 est basé sur mT5, avec un biais positionnel relatif non partagé qui est calculé pour chaque couche. Cela signifie que le modèle définit has_relative_bias pour chaque couche.
Le script de conversion est également différent, car le modèle a été enregistré dans le dernier format de checkpoint de t5x.
Exemple d'utilisation
from transformers import AutoModelForSeq2SeqLM, AutoTokenizer
model = AutoModelForSeq2SeqLM.from_pretrained("google/umt5-small", device_map="auto")
tokenizer = AutoTokenizer.from_pretrained("google/umt5-small")
inputs = tokenizer(
"A <extra_id_0> walks into a bar and orders a <extra_id_1> with <extra_id_2> pinch of <extra_id_3>.",
return_tensors="pt",
)
outputs = model.generate(**inputs)
print(tokenizer.batch_decode(outputs))
['<pad><extra_id_0>nyone who<extra_id_1> drink<extra_id_2> a<extra_id_3> alcohol<extra_id_4> A<extra_id_5> A. This<extra_id_6> I<extra_id_7><extra_id_52><extra_id_53></s>']Reportez-vous à la page de documentation de T5 pour obtenir des conseils supplémentaires, des exemples de code et des notebooks.
UMT5Config
classe transformers.UMT5Config
< source >( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0id2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Noneis_encoder_decoder: bool = Truevocab_size: int = 250112d_model: int = 512d_kv: int = 64d_ff: int = 1024num_layers: int = 8num_decoder_layers: int | None = Nonenum_heads: int = 6relative_attention_num_buckets: int = 32relative_attention_max_distance: int = 128dropout_rate: float | int = 0.1layer_norm_epsilon: float = 1e-06initializer_factor: float = 1.0feed_forward_proj: str = 'gated-gelu'use_cache: bool = Truepad_token_id: int | None = 0eos_token_id: int | list[int] | None = 1decoder_start_token_id: int | None = 0classifier_dropout: float | int = 0.0is_decoder: bool = False )
Paramètres
- is_encoder_decoder (
bool, facultatif, valeur par défautTrue) — Indique si le modèle est utilisé comme encodeur/décodeur ou non. - vocab_size (
int, facultatif, par défaut250112) — Taille du vocabulaire du modèle. Définit le nombre de jetons différents qui peuvent être représentés parinput_ids. - d_model (
int, facultatif, par défaut512) — Taille des couches encodeur et de la couche pooler. - d_kv (
int, facultatif, par défaut64) — Taille des projections clé, requête et valeur par tête d'attention. Leinner_dimde la couche de projection sera défini commenum_heads * d_kv. - d_ff (
int, facultatif, par défaut1024) — Dimension des représentations du MLP. - num_layers (
int, facultatif, par défaut8) — Nombre de couches cachées dans le décodeur Transformer. - num_decoder_layers (
int, facultatif) — Nombre de couches cachées dans le décodeur Transformer. Utilise la même valeur quenum_layerssi non défini. - num_heads (
int, facultatif, par défaut6) — Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer. - relative_attention_num_buckets (
int, facultatif, valeur par défaut 32) — Le nombre de buckets à utiliser pour chaque couche d'attention. - relative_attention_max_distance (
int, facultatif, valeur par défaut 128) — La distance maximale des séquences plus longues pour la séparation par lots. - dropout_rate (
Union[float, int], facultatif, par défaut0.1) — Le taux appliqué à toutes les couches de dropout. - layer_norm_epsilon (
float, facultatif, valeur par défaut1e-06) — L'épsilon utilisé par les couches de normalisation de couche. - initializer_factor (
float, facultatif, par défaut1.0) — Un facteur pour l'initialisation de toutes les matrices de poids (doit être maintenu à 1, utilisé en interne pour les tests d'initialisation). - feed_forward_proj (
str, facultatif, par défaut"gated-gelu") — Type de couche feed forward à utiliser. Doit être l’un des"relu"ou"gated-gelu". - use_cache (
bool, facultatif, valeur par défautTrue) — Indique si le modèle doit retourner les dernières attentions clés/valeurs (non utilisé par tous les modèles). N’est pertinent que siconfig.is_decoder=Trueou si le modèle est un modèle génératif uniquement décodeur. - pad_token_id (
int, facultatif, par défaut0) — Identifiant du jeton utilisé pour le bourrage dans le vocabulaire. - eos_token_id (
Union[int, list[int]], facultatif, par défaut1) — Identifiant du jeton utilisé pour la fin de flux dans le vocabulaire. - decoder_start_token_id (
int, facultatif, valeur par défaut0) — Si un modèle encodeur-décodeur commence le décodage avec un jeton différent debos, l’identifiant de ce jeton. - classifier_dropout (
Union[float, int], facultatif, valeur par défaut0.0) — Le taux de dropout pour le classifieur. - is_decoder (
bool, facultatif, par défautFalse) — Indique si le modèle est utilisé comme décodeur ou non. SiFalse, le modèle est utilisé comme encodeur.
Ceci est la classe de configuration destinée à stocker la configuration d'un UMT5Model. Elle est utilisée pour instancier un modèle Umt5 en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de google/umt5-small
Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.
UMT5Model
classe transformers.UMT5Model
< source >( config: UMT5Config )
Paramètres
- config (UMT5Config) — Classe de configuration du modèle contenant tous les paramètres du modèle. L'initialisation à partir d'un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.
Le modèle Umt5 brut, qui produit des états cachés bruts sans aucune tête spécifique au sommet.
Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)
Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.FloatTensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_attention_mask: typing.Optional[torch.BoolTensor] = Noneencoder_outputs: tuple[tuple[torch.FloatTensor]] | None = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonedecoder_inputs_embeds: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Seq2SeqModelOutput or tuple(torch.FloatTensor)
Paramètres
- input_ids (
torch.LongTensorde forme(batch_size, sequence_length)) — Indices des jetons de la séquence d'entrée dans le vocabulaire. UMT5 est un modèle avec des embeddings de position relative, vous pouvez donc rembourrer les entrées à la fois à droite et à gauche.Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
Qu'est-ce que les identifiants d'entrée ?
Pour en savoir plus sur la préparation de
input_idspour le pré-entraînement, consultez UMT5 Training. - attention_mask (
torch.FloatTensorde forme(batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans[0, 1]:- 1 pour les jetons qui ne sont pas masqués,
- 0 pour les jetons masqués.
- decoder_input_ids (
torch.LongTensorde forme(batch_size, target_sequence_length), facultatif) — Indices des jetons de la séquence d'entrée du décodeur dans le vocabulaire. Les indices peuvent être obtenus à l'aide d'AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails. Que sont les IDs d'entrée du décodeur ? UMT5 utilise pad_token_id comme jeton de départ pour la génération de decoder_input_ids. Si past_key_values est utilisé, il est facultatif de n'entrer que les derniers decoder_input_ids (voir past_key_values). Pour en savoir plus sur la préparation de decoder_input_ids pour la préformation, consultez UMT5 Training.Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
Quelles sont les identifiants d'entrée du décodeur ?
UMT5 utilise
pad_token_idcomme jeton de départ pour la génération dedecoder_input_ids. Sipast_key_valuesest utilisé, il est facultatif de n'entrer que les derniersdecoder_input_ids(voirpast_key_values).Pour en savoir plus sur la préparation de
decoder_input_idspour le pré-entraînement, consultez UMT5 Training. - decoder_attention_mask (
torch.BoolTensorde forme(batch_size, target_sequence_length), facultatif) — Comportement par défaut : générer un tenseur qui ignore les jetons de remplissage dansdecoder_input_ids. Un masque causal sera également utilisé par défaut. - encoder_outputs (
tuple[tuple[torch.FloatTensor]], facultatif) — Le tuple est composé de (last_hidden_state, facultatif :hidden_states, facultatif :attentions)last_hidden_statede forme(batch_size, sequence_length, hidden_size), facultatif) est une séquence d'états cachés à la sortie de la dernière couche de l'encodeur. Utilisé dans l'attention croisée du décodeur. - past_key_values (
~cache_utils.Cache, facultatif) — États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Cela consiste généralement en lapast_key_valuesretournée par le modèle à une étape antérieure du décodage, lorsqueuse_cache=Trueouconfig.use_cache=True.Seule une instance de Cache est autorisée en entrée, consultez notre guide du cache kv. Si aucun
past_key_valuesn'est transmis, DynamicCache sera initialisé par défaut.Le modèle produira le même format de cache qui est fourni en entrée.
Si
past_key_valuessont utilisés, l’utilisateur doit fournir uniquement lesinput_idsnon traités (ceux pour lesquels les états de clés et de valeurs passées n’ont pas été fournis à ce modèle) de forme(batch_size, unprocessed_length)au lieu de tous lesinput_idsde forme(batch_size, sequence_length). - inputs_embeds (
torch.Tensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerinput_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indicesinput_idsen vecteurs associés que la matrice de recherche d’intégration interne du modèle. - decoder_inputs_embeds (
torch.Tensorde forme(batch_size, target_sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerdecoder_input_idsvous pouvez choisir de passer directement une représentation intégrée. Sipast_key_valuesest utilisé, facultativement, seules les dernièresdecoder_inputs_embedsdoivent être entrées (voirpast_key_values). Cela est utile si vous souhaitez un meilleur contrôle sur la conversion desdecoder_input_idsindices en vecteurs associés que la matrice de recherche d'intégration interne du modèle.Si
decoder_input_idsetdecoder_inputs_embedssont tous deux non définis,decoder_inputs_embedsprend la valeur deinputs_embeds. - use_cache (
bool, facultatif) — Si défini surTrue, les états clé-valeurpast_key_valuessont renvoyés et peuvent être utilisés pour accélérer le décodage (voirpast_key_values).
Retourne
Seq2SeqModelOutput ou tuple(torch.FloatTensor)
Un Seq2SeqModelOutput ou un tuple de
torch.FloatTensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments selon la configuration (UMT5Config) et les entrées.
La méthode forward de UMT5Model redéfinit la méthode spéciale __call__.
Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance
Moduleplutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.
last_hidden_state (
torch.FloatTensorde forme(batch_size, sequence_length, hidden_size)) — Séquence d'états cachés à la sortie de la dernière couche du décodeur du modèle.Si
past_key_valuesest utilisé, seule la dernière hidden-state des séquences de forme(batch_size, 1, hidden_size)est renvoyée.past_key_values (
EncoderDecoderCache, facultatif, renvoyé lorsqueuse_cache=Trueest passé ou lorsqueconfig.use_cache=True) — Il s’agit d’une instance de EncoderDecoderCache. Pour plus de détails, consultez notre guide sur le cache kv.Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés (voir l'entrée
past_key_values) pour accélérer le décodage séquentiel.decoder_hidden_states (
tuple(torch.FloatTensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.FloatTensor(un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du décodeur à la sortie de chaque couche, plus les sorties d'incorporation initiale facultatives.
decoder_attentions (
tuple(torch.FloatTensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.FloatTensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids d'attention du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
cross_attentions (
tuple(torch.FloatTensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.FloatTensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids d'attention de la couche d'attention croisée du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'attention croisée.
encoder_last_hidden_state (
torch.FloatTensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Séquence d'états cachés à la sortie de la dernière couche de l'encodeur du modèle.encoder_hidden_states (
tuple(torch.FloatTensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.FloatTensor(un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés de l'encodeur à la sortie de chaque couche, plus les sorties d'incorporation initiales facultatives.
encoder_attentions (
tuple(torch.FloatTensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.FloatTensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids d'attention de l'encodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
Exemple :
>>> from transformers import AutoTokenizer, UMT5Model
>>> tokenizer = AutoTokenizer.from_pretrained("google/umt5-small")
>>> model = UMT5Model.from_pretrained("google/umt5-small")
>>> input_ids = tokenizer(
... "Studies have been shown that owning a dog is good for you", return_tensors="pt"
... ).input_ids # Batch size 1
>>> decoder_input_ids = tokenizer("Studies show that", return_tensors="pt").input_ids # Batch size 1
>>> # preprocess: Prepend decoder_input_ids with start token which is pad token for UMT5Model.
>>> # This is not needed for torch's UMT5ForConditionalGeneration as it does this internally using labels arg.
>>> decoder_input_ids = model._shift_right(decoder_input_ids)
>>> # forward pass
>>> outputs = model(input_ids=input_ids, decoder_input_ids=decoder_input_ids)
>>> last_hidden_states = outputs.last_hidden_stateUMT5ForConditionalGeneration
classe transformers.UMT5ForConditionalGeneration
< source >( config: UMT5Config )
Paramètres
- config (UMT5Config) — Classe de configuration du modèle contenant tous les paramètres du modèle. L'initialisation à partir d'un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.
Modèle UMT5 avec une tête de language modeling au sommet.
Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)
Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.FloatTensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_attention_mask: typing.Optional[torch.BoolTensor] = Noneencoder_outputs: tuple[tuple[torch.Tensor]] | None = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Nonedecoder_inputs_embeds: typing.Optional[torch.FloatTensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Seq2SeqLMOutput or tuple(torch.FloatTensor)
Paramètres
- input_ids (
torch.LongTensorde forme(batch_size, sequence_length)) — Indices des jetons de la séquence d'entrée dans le vocabulaire. UMT5 est un modèle avec des embeddings de position relative, vous pouvez donc rembourrer les entrées à la fois à droite et à gauche.Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
Qu'est-ce que les identifiants d'entrée ?
Pour en savoir plus sur la préparation de
input_idspour le pré-entraînement, consultez UMT5 Training. - attention_mask (
torch.FloatTensorde forme(batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans[0, 1]:- 1 pour les jetons qui ne sont pas masqués,
- 0 pour les jetons masqués.
- decoder_input_ids (
torch.LongTensorde forme(batch_size, target_sequence_length), facultatif) — Indices des jetons de la séquence d'entrée du décodeur dans le vocabulaire. Les indices peuvent être obtenus à l'aide d'AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails. Que sont les IDs d'entrée du décodeur ? UMT5 utilise pad_token_id comme jeton de départ pour la génération de decoder_input_ids. Si past_key_values est utilisé, il est facultatif de n'entrer que les derniers decoder_input_ids (voir past_key_values). Pour en savoir plus sur la préparation de decoder_input_ids pour le pré-entraînement, consultez UMT5 Training.Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
Quelles sont les identifiants d'entrée du décodeur ?
UMT5 utilise
pad_token_idcomme jeton de départ pour la génération dedecoder_input_ids. Sipast_key_valuesest utilisé, il est facultatif de n'entrer que le dernierdecoder_input_ids(voirpast_key_values).Pour en savoir plus sur la préparation de
decoder_input_idspour le pré-entraînement, consultez UMT5 Training. - decoder_attention_mask (
torch.BoolTensorde forme(batch_size, target_sequence_length), facultatif) — Comportement par défaut : générer un tenseur qui ignore les jetons de remplissage dansdecoder_input_ids. Un masque causal sera également utilisé par défaut. - encoder_outputs (
tuple[tuple[torch.Tensor]], facultatif) — Le tuple est composé de (last_hidden_state, facultatif :hidden_states, facultatif :attentions)last_hidden_statede forme(batch_size, sequence_length, hidden_size), facultatif) est une séquence d'états cachés à la sortie de la dernière couche de l'encodeur. Utilisé dans l'attention croisée du décodeur. - past_key_values (
~cache_utils.Cache, facultatif) — États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Cela consiste généralement en lapast_key_valuesretournée par le modèle à une étape antérieure du décodage, lorsqueuse_cache=Trueouconfig.use_cache=True.Seule une instance de Cache est autorisée en entrée, consultez notre guide du cache kv. Si aucun
past_key_valuesn'est transmis, DynamicCache sera initialisé par défaut.Le modèle produira le même format de cache qui est fourni en entrée.
Si
past_key_valuessont utilisés, l’utilisateur doit fournir uniquement lesinput_idsnon traités (ceux pour lesquels les états de clés et de valeurs passées n’ont pas été fournis à ce modèle) de forme(batch_size, unprocessed_length)au lieu de tous lesinput_idsde forme(batch_size, sequence_length). - inputs_embeds (
torch.FloatTensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerinput_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indicesinput_idsen vecteurs associés que la matrice de recherche d’intégration interne du modèle. - decoder_inputs_embeds (
torch.FloatTensorde forme(batch_size, target_sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerdecoder_input_idsvous pouvez choisir de passer directement une représentation intégrée. Sipast_key_valuesest utilisé, facultativement, seules les dernièresdecoder_inputs_embedsdoivent être entrées (voirpast_key_values). Cela est utile si vous souhaitez un meilleur contrôle sur la conversion desdecoder_input_idsindices en vecteurs associés que la matrice de recherche d'intégration interne du modèle.Si
decoder_input_idsetdecoder_inputs_embedssont tous deux non définis,decoder_inputs_embedsprend la valeur deinputs_embeds. - labels (
torch.LongTensorde forme(batch_size,), facultatif) — Étiquettes pour le calcul de la perte de classification/régression de séquence. Les indices doivent être dans[-100, 0, ..., config.vocab_size - 1]. Toutes les étiquettes définies à-100sont ignorées (masquées), la perte n'est calculée que pour les étiquettes dans[0, ..., config.vocab_size] - use_cache (
bool, facultatif) — Si défini surTrue, les états clé-valeurpast_key_valuessont renvoyés et peuvent être utilisés pour accélérer le décodage (voirpast_key_values).
Retourne
Seq2SeqLMOutput ou tuple(torch.FloatTensor)
Un Seq2SeqLMOutput ou un tuple de
torch.FloatTensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (UMT5Config) et des entrées.
La méthode forward de UMT5ForConditionalGeneration redéfinit la méthode spéciale __call__.
Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance
Moduleplutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.
loss (
torch.FloatTensorde forme(1,), facultatif, renvoyé lorsquelabelsest fourni) — Perte de modélisation du langage.logits (
torch.FloatTensorde forme(batch_size, sequence_length, config.vocab_size)) — Scores de prédiction de la tête de modélisation du langage (scores pour chaque jeton du vocabulaire avant SoftMax).past_key_values (
EncoderDecoderCache, facultatif, renvoyé lorsqueuse_cache=Trueest passé ou lorsqueconfig.use_cache=True) — Il s’agit d’une instance de EncoderDecoderCache. Pour plus de détails, consultez notre guide sur le cache kv.Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés (voir l'entrée
past_key_values) pour accélérer le décodage séquentiel.decoder_hidden_states (
tuple(torch.FloatTensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.FloatTensor(un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du décodeur à la sortie de chaque couche, plus les sorties de l'intégration initiale.
decoder_attentions (
tuple(torch.FloatTensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.FloatTensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids d'attention du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
cross_attentions (
tuple(torch.FloatTensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.FloatTensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids d'attention de la couche d'attention croisée du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'attention croisée.
encoder_last_hidden_state (
torch.FloatTensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Séquence d'états cachés à la sortie de la dernière couche de l'encodeur du modèle.encoder_hidden_states (
tuple(torch.FloatTensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.FloatTensor(un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés de l'encodeur à la sortie de chaque couche, plus les sorties des embeddings initiaux.
encoder_attentions (
tuple(torch.FloatTensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.FloatTensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids d'attention de l'encodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
Exemples :
>>> from transformers import AutoTokenizer, UMT5ForConditionalGeneration
>>> tokenizer = AutoTokenizer.from_pretrained("google/umt5-small")
>>> model = UMT5ForConditionalGeneration.from_pretrained("google/umt5-small")
>>> # training
>>> input_ids = tokenizer("The <extra_id_0> walks in <extra_id_1> park", return_tensors="pt").input_ids
>>> labels = tokenizer("<extra_id_0> cute dog <extra_id_1> the <extra_id_2>", return_tensors="pt").input_ids
>>> outputs = model(input_ids=input_ids, labels=labels)
>>> loss = outputs.loss
>>> logits = outputs.logits
>>> # inference
>>> input_ids = tokenizer("Studies have shown that <extra_id_0> good for you", return_tensors="pt").input_ids
>>> outputs = model.generate(input_ids)
>>> tokenizer.decode(outputs[0], skip_special_tokens=True)UMT5EncoderModel
classe transformers.UMT5EncoderModel
< source >( config: UMT5Config )
Paramètres
- config (UMT5Config) — Classe de configuration du modèle contenant tous les paramètres du modèle. L'initialisation à partir d'un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.
Le modèle Umt5 brut, qui produit des états cachés bruts sans aucune tête spécifique au sommet.
Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)
Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.FloatTensor] = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutput or tuple(torch.FloatTensor)
Paramètres
- input_ids (
torch.LongTensorde forme(batch_size, sequence_length)) — Indices des jetons de la séquence d'entrée dans le vocabulaire. UMT5 est un modèle avec des embeddings de position relative, vous pouvez donc rembourrer les entrées à la fois à droite et à gauche.Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
Pour en savoir plus sur la préparation de
input_idspour le pré-entraînement, consultez UMT5 Training. - attention_mask (
torch.FloatTensorde forme(batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans[0, 1]:- 1 pour les jetons qui ne sont pas masqués,
- 0 pour les jetons masqués.
- inputs_embeds (
torch.FloatTensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerinput_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indicesinput_idsen vecteurs associés que la matrice de recherche d’intégration interne du modèle.
Retourne
BaseModelOutput ou tuple(torch.FloatTensor)
Un BaseModelOutput ou un tuple de
torch.FloatTensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (UMT5Config) et des entrées.
La méthode forward de UMT5EncoderModel redéfinit la méthode spéciale __call__.
Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance
Moduleplutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.
last_hidden_state (
torch.FloatTensorde forme(batch_size, sequence_length, hidden_size)) — Séquence d'états cachés à la sortie de la dernière couche du modèle.hidden_states (
tuple(torch.FloatTensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.FloatTensor(un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
attentions (
tuple(torch.FloatTensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.FloatTensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
Exemple :
>>> from transformers import AutoTokenizer, UMT5EncoderModel
>>> tokenizer = AutoTokenizer.from_pretrained("google/umt5-small")
>>> model = UMT5EncoderModel.from_pretrained("google/umt5-small")
>>> input_ids = tokenizer(
... "Studies have been shown that owning a dog is good for you", return_tensors="pt"
... ).input_ids # Batch size 1
>>> outputs = model(input_ids=input_ids)
>>> last_hidden_states = outputs.last_hidden_stateUMT5ForSequenceClassification
classe transformers.UMT5ForSequenceClassification
< source >( config: UMT5Config )
Paramètres
- config (UMT5Config) — Classe de configuration du modèle contenant tous les paramètres du modèle. L'initialisation à partir d'un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.
Modèle UMT5 avec une tête de classification de séquence au sommet (une couche linéaire au-dessus de la sortie agrégée), par exemple pour les tâches GLUE.
Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)
Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_attention_mask: typing.Optional[torch.LongTensor] = Noneencoder_outputs: list[torch.FloatTensor] | None = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Nonedecoder_inputs_embeds: typing.Optional[torch.FloatTensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Seq2SeqSequenceClassifierOutput or tuple(torch.FloatTensor)
Paramètres
- input_ids (
torch.LongTensorde forme(batch_size, sequence_length)) — Indices des jetons de la séquence d'entrée dans le vocabulaire. UMT5 est un modèle avec des embeddings de position relative, vous pouvez donc rembourrer les entrées à la fois à droite et à gauche.Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
Qu'est-ce que les identifiants d'entrée ?
Pour en savoir plus sur la préparation de
input_idspour le pré-entraînement, consultez UMT5 Training. - attention_mask (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans[0, 1]:- 1 pour les jetons qui ne sont pas masqués,
- 0 pour les jetons masqués.
- decoder_input_ids (
torch.LongTensorde forme(batch_size, target_sequence_length), facultatif) — Indices des jetons de la séquence d'entrée du décodeur dans le vocabulaire. Les indices peuvent être obtenus à l'aide d'AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails. Que sont les IDs d'entrée du décodeur ? UMT5 utilise pad_token_id comme jeton de départ pour la génération de decoder_input_ids. Si past_key_values est utilisé, il est facultatif de n'entrer que les derniers decoder_input_ids (voir past_key_values). Pour en savoir plus sur la préparation de decoder_input_ids pour la préformation, consultez UMT5 Training.Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
Quelles sont les identifiants d'entrée du décodeur ?
UMT5 utilise
pad_token_idcomme jeton de départ pour la génération dedecoder_input_ids. Sipast_key_valuesest utilisé, il est facultatif de n'entrer que le dernierdecoder_input_ids(voirpast_key_values).Pour en savoir plus sur la préparation de
decoder_input_idspour le pré-entraînement, consultez UMT5 Training. - decoder_attention_mask (
torch.BoolTensorde forme(batch_size, target_sequence_length), facultatif) — Comportement par défaut : générer un tenseur qui ignore les jetons de remplissage dansdecoder_input_ids. Un masque causal sera également utilisé par défaut. - encoder_outputs (
list[torch.FloatTensor], facultatif) — Tuple composé de (last_hidden_state, facultatif :hidden_states, facultatif :attentions)last_hidden_statede forme(batch_size, sequence_length, hidden_size), facultatif) est une séquence d’états cachés à la sortie de la dernière couche de l’encodeur. Utilisé dans l’attention croisée du décodeur. - inputs_embeds (
torch.FloatTensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerinput_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indicesinput_idsen vecteurs associés que la matrice de recherche d’intégration interne du modèle. - decoder_inputs_embeds (
torch.FloatTensorde forme(batch_size, target_sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerdecoder_input_idsvous pouvez choisir de passer directement une représentation intégrée. Sipast_key_valuesest utilisé, facultativement, seules les dernièresdecoder_inputs_embedsdoivent être entrées (voirpast_key_values). Cela est utile si vous souhaitez un meilleur contrôle sur la conversion desdecoder_input_idsindices en vecteurs associés que la matrice de recherche d'intégration interne du modèle.Si
decoder_input_idsetdecoder_inputs_embedssont tous deux non définis,decoder_inputs_embedsprend la valeur deinputs_embeds. - labels (
torch.LongTensorde forme(batch_size,), facultatif) — Étiquettes pour le calcul de la perte de classification/régression de séquence. Les indices doivent être dans[0, ..., config.num_labels - 1]. Siconfig.num_labels == 1, une perte de régression est calculée (perte du carré moyen). Siconfig.num_labels > 1, une perte de classification est calculée (entropie croisée). - use_cache (
bool, facultatif) — Si défini surTrue, les états clé-valeurpast_key_valuessont renvoyés et peuvent être utilisés pour accélérer le décodage (voirpast_key_values).
Retourne
Seq2SeqSequenceClassifierOutput ou tuple(torch.FloatTensor)
Un Seq2SeqSequenceClassifierOutput ou un tuple de
torch.FloatTensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (UMT5Config) et des entrées.
La méthode forward de UMT5ForSequenceClassification redéfinit la méthode spéciale __call__.
Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance
Moduleplutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.
loss (
torch.FloatTensorde forme(1,), facultatif, renvoyé lorsquelabelest fourni) — Perte de classification (ou de régression si config.num_labels==1).logits (
torch.FloatTensorde forme(batch_size, config.num_labels)) — Scores de classification (ou de régression si config.num_labels==1) (avant SoftMax).past_key_values (
EncoderDecoderCache, facultatif, renvoyé lorsqueuse_cache=Trueest passé ou lorsqueconfig.use_cache=True) — Il s’agit d’une instance de EncoderDecoderCache. Pour plus de détails, consultez notre guide sur le cache kv.Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés (voir l'entrée
past_key_values) pour accélérer le décodage séquentiel.decoder_hidden_states (
tuple(torch.FloatTensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.FloatTensor(un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du décodeur à la sortie de chaque couche, plus les sorties de l'intégration initiale.
decoder_attentions (
tuple(torch.FloatTensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.FloatTensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids d'attention du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
cross_attentions (
tuple(torch.FloatTensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.FloatTensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids d'attention de la couche d'attention croisée du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'attention croisée.
encoder_last_hidden_state (
torch.FloatTensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Séquence d'états cachés à la sortie de la dernière couche de l'encodeur du modèle.encoder_hidden_states (
tuple(torch.FloatTensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.FloatTensor(un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés de l'encodeur à la sortie de chaque couche, plus les sorties des embeddings initiaux.
encoder_attentions (
tuple(torch.FloatTensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.FloatTensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids d'attention de l'encodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
Exemple de classification mono-étiquette :
>>> import torch
>>> from transformers import AutoTokenizer, UMT5ForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("google/umt5-small")
>>> model = UMT5ForSequenceClassification.from_pretrained("google/umt5-small")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> predicted_class_id = logits.argmax().item()
>>> model.config.id2label[predicted_class_id]
...
>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = UMT5ForSequenceClassification.from_pretrained("google/umt5-small", num_labels=num_labels)
>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...Exemple de classification multi-étiquettes :
>>> import torch
>>> from transformers import AutoTokenizer, UMT5ForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("google/umt5-small")
>>> model = UMT5ForSequenceClassification.from_pretrained("google/umt5-small", problem_type="multi_label_classification")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> predicted_class_ids = torch.arange(0, logits.shape[-1])[torch.sigmoid(logits).squeeze(dim=0) > 0.5]
>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = UMT5ForSequenceClassification.from_pretrained(
... "google/umt5-small", num_labels=num_labels, problem_type="multi_label_classification"
... )
>>> labels = torch.sum(
... torch.nn.functional.one_hot(predicted_class_ids[None, :].clone(), num_classes=num_labels), dim=1
... ).to(torch.float)
>>> loss = model(**inputs, labels=labels).lossUMT5ForTokenClassification
classe transformers.UMT5ForTokenClassification
< source >( config: UMT5Config )
Paramètres
- config (UMT5Config) — Classe de configuration du modèle contenant tous les paramètres du modèle. L'initialisation à partir d'un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.
Le transformeur Umt5 avec une tête de classification de jetons au sommet (une couche linéaire au-dessus de la sortie des états cachés), par exemple pour des tâches de reconnaissance d’entités nommées (NER).
Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)
Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.
forward
< source >( input_ids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → TokenClassifierOutput or tuple(torch.FloatTensor)
Paramètres
- input_ids (
torch.LongTensorde forme(batch_size, sequence_length)) — Indices des jetons de la séquence d'entrée dans le vocabulaire. UMT5 est un modèle avec des embeddings de position relative, vous pouvez donc rembourrer les entrées à la fois à droite et à gauche.Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
Qu'est-ce que les identifiants d'entrée ?
Pour en savoir plus sur la préparation de
input_idspour le pré-entraînement, consultez UMT5 Training. - attention_mask (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans[0, 1]:- 1 pour les jetons qui ne sont pas masqués,
- 0 pour les jetons masqués.
- inputs_embeds (
torch.Tensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerinput_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indicesinput_idsen vecteurs associés que la matrice de recherche d’intégration interne du modèle. - labels (
torch.LongTensorde forme(batch_size, sequence_length), facultatif) — Étiquettes pour le calcul de la perte de classification de jetons. Les indices doivent être dans[0, ..., config.num_labels - 1].
Retourne
TokenClassifierOutput ou tuple(torch.FloatTensor)
Un TokenClassifierOutput ou un tuple de
torch.FloatTensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (UMT5Config) et des entrées.
La méthode forward de UMT5ForTokenClassification redéfinit la méthode spéciale __call__.
Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance
Moduleplutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.
loss (
torch.FloatTensorde forme(1,), facultatif, renvoyé lorsquelabelsest fourni) — Perte de classification.logits (
torch.FloatTensorde forme(batch_size, sequence_length, config.num_labels)) — Scores de classification (avant SoftMax).hidden_states (
tuple(torch.FloatTensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.FloatTensor(un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
attentions (
tuple(torch.FloatTensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.FloatTensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
Exemple :
>>> from transformers import AutoTokenizer, UMT5ForTokenClassification
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("google/umt5-small")
>>> model = UMT5ForTokenClassification.from_pretrained("google/umt5-small")
>>> inputs = tokenizer(
... "HuggingFace is a company based in Paris and New York", add_special_tokens=False, return_tensors="pt"
... )
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> predicted_token_class_ids = logits.argmax(-1)
>>> # Note that tokens are classified rather then input words which means that
>>> # there might be more predicted token classes than words.
>>> # Multiple token classes might account for the same word
>>> predicted_tokens_classes = [model.config.id2label[t.item()] for t in predicted_token_class_ids[0]]
>>> predicted_tokens_classes
...
>>> labels = predicted_token_class_ids
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...UMT5ForQuestionAnswering
classe transformers.UMT5ForQuestionAnswering
< source >( config: UMT5Config )
Paramètres
- config (UMT5Config) — Classe de configuration du modèle contenant tous les paramètres du modèle. L'initialisation à partir d'un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.
Le transformeur Umt5 avec une tête de classification d’intervalles en tête pour les tâches de question-réponse extractives comme
SQuAD (une couche linéaire en tête de la sortie des états cachés pour calculer les span start logits et les span end logits).
Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)
Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.FloatTensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_attention_mask: typing.Optional[torch.BoolTensor] = Noneencoder_outputs: tuple[tuple[torch.Tensor]] | None = Nonestart_positions: typing.Optional[torch.LongTensor] = Noneend_positions: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Nonedecoder_inputs_embeds: typing.Optional[torch.FloatTensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Seq2SeqQuestionAnsweringModelOutput or tuple(torch.FloatTensor)
Paramètres
- input_ids (
torch.LongTensorde forme(batch_size, sequence_length)) — Indices des jetons de la séquence d'entrée dans le vocabulaire. UMT5 est un modèle avec des embeddings de position relative, vous pouvez donc rembourrer les entrées à la fois à droite et à gauche.Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
Qu'est-ce que les identifiants d'entrée ?
Pour en savoir plus sur la préparation de
input_idspour le pré-entraînement, consultez UMT5 Training. - attention_mask (
torch.FloatTensorde forme(batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans[0, 1]:- 1 pour les jetons qui ne sont pas masqués,
- 0 pour les jetons masqués.
- decoder_input_ids (
torch.LongTensorde forme(batch_size, target_sequence_length), facultatif) — Indices des jetons de la séquence d'entrée du décodeur dans le vocabulaire. Les indices peuvent être obtenus à l'aide d'AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails. Que sont les IDs d'entrée du décodeur ? UMT5 utilise pad_token_id comme jeton de départ pour la génération de decoder_input_ids. Si past_key_values est utilisé, il est facultatif de n'entrer que les derniers decoder_input_ids (voir past_key_values). Pour en savoir plus sur la préparation de decoder_input_ids pour le pré-entraînement, consultez UMT5 Training.Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
Quelles sont les identifiants d'entrée du décodeur ?
UMT5 utilise
pad_token_idcomme jeton de départ pour la génération dedecoder_input_ids. Sipast_key_valuesest utilisé, il est facultatif de n'entrer que le dernierdecoder_input_ids(voirpast_key_values).Pour en savoir plus sur la préparation de
decoder_input_idspour le pré-entraînement, consultez UMT5 Training. - decoder_attention_mask (
torch.BoolTensorde forme(batch_size, target_sequence_length), facultatif) — Comportement par défaut : générer un tenseur qui ignore les jetons de remplissage dansdecoder_input_ids. Un masque causal sera également utilisé par défaut. - encoder_outputs (
tuple[tuple[torch.Tensor]], facultatif) — Le tuple est composé de (last_hidden_state, facultatif :hidden_states, facultatif :attentions)last_hidden_statede forme(batch_size, sequence_length, hidden_size), facultatif) est une séquence d'états cachés à la sortie de la dernière couche de l'encodeur. Utilisé dans l'attention croisée du décodeur. - start_positions (
torch.LongTensorde forme(batch_size,), facultatif) — Étiquettes pour la position (index) du début de l'interval étiqueté, utilisées pour le calcul de la perte de classification de jetons. Les positions sont bornées à la longueur de la séquence (sequence_length). Les positions situées en dehors de la séquence ne sont pas prises en compte pour le calcul de la perte. - end_positions (
torch.LongTensorde forme(batch_size,), facultatif) — Étiquettes pour la position (index) de fin de l'intervalle étiqueté, utilisées pour le calcul de la perte de classification de jetons. Les positions sont bornées à la longueur de la séquence (sequence_length). Les positions situées en dehors de la séquence ne sont pas prises en compte pour le calcul de la perte. - inputs_embeds (
torch.FloatTensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerinput_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indicesinput_idsen vecteurs associés que la matrice de recherche d’intégration interne du modèle. - decoder_inputs_embeds (
torch.FloatTensorde forme(batch_size, target_sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerdecoder_input_idsvous pouvez choisir de passer directement une représentation intégrée. Sipast_key_valuesest utilisé, facultativement, seules les dernièresdecoder_inputs_embedsdoivent être entrées (voirpast_key_values). Cela est utile si vous souhaitez un meilleur contrôle sur la conversion desdecoder_input_idsindices en vecteurs associés que la matrice de recherche d'intégration interne du modèle.Si
decoder_input_idsetdecoder_inputs_embedssont tous deux non définis,decoder_inputs_embedsprend la valeur deinputs_embeds. - use_cache (
bool, facultatif) — Si défini surTrue, les états clé-valeurpast_key_valuessont renvoyés et peuvent être utilisés pour accélérer le décodage (voirpast_key_values).
Retourne
Seq2SeqQuestionAnsweringModelOutput ou tuple(torch.FloatTensor)
Un Seq2SeqQuestionAnsweringModelOutput ou un tuple de
torch.FloatTensor (si return_dict=False est passé ou si config.return_dict=False) comprenant divers
éléments selon la configuration (UMT5Config) et les entrées.
La méthode forward de UMT5ForQuestionAnswering redéfinit la méthode spéciale __call__.
Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance
Moduleplutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.
loss (
torch.FloatTensorde forme(1,), facultatif, renvoyé lorsquelabelsest fourni) — La perte totale d'extraction de segments est la somme d'une entropie croisée pour les positions de début et de fin.start_logits (
torch.FloatTensorde forme(batch_size, sequence_length)) — Scores de début de segment (avant SoftMax).end_logits (
torch.FloatTensorde forme(batch_size, sequence_length)) — Scores de fin de segment (avant SoftMax).past_key_values (
EncoderDecoderCache, facultatif, renvoyé lorsqueuse_cache=Trueest passé ou lorsqueconfig.use_cache=True) — Il s’agit d’une instance de EncoderDecoderCache. Pour plus de détails, consultez notre guide sur le cache kv.Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés (voir l'entrée
past_key_values) pour accélérer le décodage séquentiel.decoder_hidden_states (
tuple(torch.FloatTensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.FloatTensor(un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du décodeur à la sortie de chaque couche, plus les sorties de l'intégration initiale.
decoder_attentions (
tuple(torch.FloatTensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.FloatTensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids d'attention du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
cross_attentions (
tuple(torch.FloatTensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.FloatTensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids d'attention de la couche d'attention croisée du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'attention croisée.
encoder_last_hidden_state (
torch.FloatTensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Séquence d'états cachés à la sortie de la dernière couche de l'encodeur du modèle.encoder_hidden_states (
tuple(torch.FloatTensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.FloatTensor(un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés de l'encodeur à la sortie de chaque couche, plus les sorties des embeddings initiaux.
encoder_attentions (
tuple(torch.FloatTensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.FloatTensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids d'attention de l'encodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
Exemple :
>>> from transformers import AutoTokenizer, UMT5ForQuestionAnswering
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("google/umt5-small")
>>> model = UMT5ForQuestionAnswering.from_pretrained("google/umt5-small")
>>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"
>>> inputs = tokenizer(question, text, return_tensors="pt")
>>> with torch.no_grad():
... outputs = model(**inputs)
>>> answer_start_index = outputs.start_logits.argmax()
>>> answer_end_index = outputs.end_logits.argmax()
>>> predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1]
>>> tokenizer.decode(predict_answer_tokens, skip_special_tokens=True)
...
>>> # target is "nice puppet"
>>> target_start_index = torch.tensor([14])
>>> target_end_index = torch.tensor([15])
>>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)
>>> loss = outputs.loss
>>> round(loss.item(), 2)
...