# Longformer [Longformer](https://huggingface.co/papers/2004.05150) est un modèle de transformer conçu pour le traitement de documents longs. L’opération d’auto-attention évolue généralement de manière quadratique avec la longueur de la séquence, ce qui empêche les transformers de traiter des séquences plus longues. Le mécanisme d’attention de Longformer surmonte cette limitation en évoluant linéairement avec la longueur de la séquence. Il combine une attention locale par fenêtres avec une attention globale spécifique à la tâche, permettant un traitement efficace de documents contenant des milliers de jetons. Vous pouvez trouver tous les points de contrôle originaux de Longformer sous l'organisation [Ai2](https://huggingface.co/allenai?search_models=longformer). > [!TIP] > Cliquez sur les modèles Longformer dans la barre latérale droite pour plus d’exemples sur la façon d’appliquer Longformer à différentes tâches de langage. L'exemple ci-dessous montre comment remplir le jeton `` avec [Pipeline](/docs/transformers/main/fr/main_classes/pipelines#transformers.Pipeline), [AutoModel](/docs/transformers/main/fr/model_doc/auto#transformers.AutoModel) et depuis la ligne de commande. ```python from transformers import pipeline pipeline = pipeline( task="fill-mask", model="allenai/longformer-base-4096", device=0 ) pipeline("""San Francisco 49ers cornerback Shawntae Spencer will miss the rest of the with a torn ligament in his left knee. Spencer, a fifth-year pro, will be placed on injured reserve soon after undergoing surgery Wednesday to repair the ligament. He injured his knee late in the 49ers’ road victory at Seattle on Sept. 14, and missed last week’s victory over Detroit. Tarell Brown and Donald Strickland will compete to replace Spencer with the 49ers, who kept 12 defensive backs on their 53-man roster to start the season. Brown, a second-year pro, got his first career interception last weekend while filling in for Strickland, who also sat out with a knee injury.""") ``` ```python from transformers import AutoModelForMaskedLM, AutoTokenizer tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-base-4096") model = AutoModelForMaskedLM.from_pretrained("allenai/longformer-base-4096", device_map="auto") text = ( """ San Francisco 49ers cornerback Shawntae Spencer will miss the rest of the with a torn ligament in his left knee. Spencer, a fifth-year pro, will be placed on injured reserve soon after undergoing surgery Wednesday to repair the ligament. He injured his knee late in the 49ers’ road victory at Seattle on Sept. 14, and missed last week’s victory over Detroit. Tarell Brown and Donald Strickland will compete to replace Spencer with the 49ers, who kept 12 defensive backs on their 53-man roster to start the season. Brown, a second-year pro, got his first career interception last weekend while filling in for Strickland, who also sat out with a knee injury. """ ) input_ids = tokenizer([text], return_tensors="pt").to(model.device)["input_ids"] logits = model(input_ids).logits masked_index = (input_ids[0] == tokenizer.mask_token_id).nonzero().item() probs = logits[0, masked_index].softmax(dim=0) values, predictions = probs.topk(5) tokenizer.decode(predictions).split() ``` ## Notes - Longformer est basé sur [RoBERTa](./roberta) et ne possède pas de `token_type_ids`. Il n'est pas nécessaire d'indiquer à quel segment appartient chaque jeton. Il suffit de séparer les segments à l'aide du jeton de séparation `` ou `tokenizer.sep_token`. - Vous pouvez définir quels jetons peuvent effectuer une attention locale et quels jetons effectuent une attention globale à l'aide de `global_attention_mask` lors de l'inférence (voir cet [exemple](/docs/transformers/main/fr/model_doc/longformer#transformers.LongformerModel.forward.example) pour plus de détails). Une valeur de `0` signifie qu'un jeton effectue une attention locale, et une valeur de `1` signifie qu'un jeton effectue une attention globale. - [LongformerForMaskedLM](/docs/transformers/main/fr/model_doc/longformer#transformers.LongformerForMaskedLM) est entraîné comme [RobertaForMaskedLM](/docs/transformers/main/fr/model_doc/roberta#transformers.RobertaForMaskedLM) et doit être utilisé comme indiqué ci-dessous. ```py input_ids = tokenizer.encode("This is a sentence from [MASK] training data", return_tensors="pt").to(model.device) mlm_labels = tokenizer.encode("This is a sentence from the training data", return_tensors="pt").to(model.device) loss = model(input_ids, labels=input_ids, masked_lm_labels=mlm_labels)[0] ``` ## LongformerConfig[[transformers.LongformerConfig]] #### transformers.LongformerConfig[[transformers.LongformerConfig]] ```python transformers.LongformerConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, attention_window: list[int] | int = 512, sep_token_id: int | None = 2, pad_token_id: int | None = 1, bos_token_id: int | None = 0, eos_token_id: int | list[int] | None = 2, vocab_size: int = 30522, hidden_size: int = 768, num_hidden_layers: int = 12, num_attention_heads: int = 12, intermediate_size: int = 3072, hidden_act: str = 'gelu', hidden_dropout_prob: float | int = 0.1, attention_probs_dropout_prob: float | int = 0.1, max_position_embeddings: int = 512, type_vocab_size: int = 2, initializer_range: float = 0.02, layer_norm_eps: float = 1e-12, onnx_export: bool = False, tie_word_embeddings: bool = True) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/longformer/configuration_longformer.py#L24) **Paramètres :** attention_window (`int` ou `list[int]`, *facultatif*, valeur par défaut : 512) : Taille d'une fenêtre d'attention autour de chaque jeton. Si c'est un `int`, la même taille est utilisée pour toutes les couches. Pour spécifier une taille de fenêtre différente pour chaque couche, utilisez une `list[int]` où `len(attention_window) == num_hidden_layers`. sep_token_id (`int`, *facultatif*, valeur par défaut `2`) : Identifiant du jeton utilisé comme séparateur dans le vocabulaire. pad_token_id (`int`, *facultatif*, valeur par défaut `1`) : Identifiant du jeton utilisé pour le bourrage dans le vocabulaire. bos_token_id (`int`, *facultatif*, valeur par défaut `0`) : Identifiant du jeton utilisé pour le début de flux dans le vocabulaire. eos_token_id (`Union[int, list[int]]`, *facultatif*, valeur par défaut `2`) : Identifiant de jeton utilisé pour la fin de flux dans le vocabulaire. vocab_size (`int`, *facultatif*, valeur par défaut `30522`) : Taille du vocabulaire du modèle. Définit le nombre de jetons différents qui peuvent être représentés par `input_ids`. hidden_size (`int`, *facultatif*, par défaut `768`) : Dimension des représentations cachées. num_hidden_layers (`int`, *facultatif*, par défaut `12`) : Nombre de couches cachées dans le décodeur Transformer. num_attention_heads (`int`, *facultatif*, valeur par défaut `12`) : Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer. intermediate_size (`int`, *facultatif*, par défaut `3072`) : Dimension des représentations MLP. hidden_act (`str`, *facultatif*, par défaut `gelu`) : La fonction d'activation non linéaire (fonction ou chaîne de caractères) dans le décodeur. Par exemple, `"gelu"`, `"relu"`, `"silu"`, etc. hidden_dropout_prob (`Union[float, int]`, *facultatif*, valeur par défaut `0.1`) : La probabilité de dropout pour toutes les couches entièrement connectées des embeddings, de l'encodeur et du pooler. attention_probs_dropout_prob (`Union[float, int]`, *facultatif*, valeur par défaut `0.1`) : Le taux de dropout appliqué aux probabilités d'attention. max_position_embeddings (`int`, *facultatif*, valeur par défaut `512`) : La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé. type_vocab_size (`int`, *facultatif*, par défaut `2`) : La taille du vocabulaire des `token_type_ids`. initializer_range (`float`, *facultatif*, valeur par défaut `0.02`) : L'écart-type de la truncated_normal_initializer utilisé pour l'initialisation de toutes les matrices de poids. layer_norm_eps (`float`, *facultatif*, par défaut `1e-12`) : L'épsilon utilisé par les couches de normalisation par couche. onnx_export (`bool`, *facultatif*, valeur par défaut : False) : Indique s'il faut créer un modèle exportable en ONNX ou non. tie_word_embeddings (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut lier les embeddings de poids selon la correspondance `tied_weights_keys` du modèle. Ceci est la classe de configuration destinée à stocker la configuration d'un LongformerModel. Elle est utilisée pour instancier un modèle Longformer 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 [allenai/longformer-base-4096](https://huggingface.co/allenai/longformer-base-4096) Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations. Exemple : ```python >>> from transformers import LongformerConfig, LongformerModel >>> # Initializing a Longformer configuration >>> configuration = LongformerConfig() >>> # Initializing a model from the configuration >>> model = LongformerModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## LongformerTokenizer[[transformers.RobertaTokenizer]] #### transformers.RobertaTokenizer[[transformers.RobertaTokenizer]] ```python transformers.RobertaTokenizer(vocab: str | dict[str, int] | None = None, merges: str | list[str] | None = None, errors: str = 'replace', bos_token: str = '', eos_token: str = '', sep_token: str = '', cls_token: str = '', unk_token: str = '', pad_token: str = '', mask_token: str = '', add_prefix_space: bool = False, trim_offsets: bool = True, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/roberta/tokenization_roberta.py#L28) **Paramètres :** vocab (`str`, `dict` ou `list`, *facultatif*) : Dictionnaire de vocabulaire personnalisé. S'il n'est pas fourni, le vocabulaire est chargé depuis vocab_file. merges (`str` ou `list`, *facultatif*) : Liste de fusions personnalisées. Si non fournie, les fusions sont chargées depuis merges_file. errors (`str`, *facultatif*, valeur par défaut `"replace"`) : Paradigme à suivre lors du décodage des octets en UTF-8. Consultez [bytes.decode](https://docs.python.org/3/library/stdtypes.html#bytes.decode) pour plus d'informations. bos_token (`str`, *facultatif*, valeur par défaut `""`) : Jeton de début de séquence utilisé lors de la préformation. Peut être utilisé comme jeton de classifieur de séquence. Lors de la construction d'une séquence à l'aide de jetons spéciaux, ce n'est pas le jeton utilisé pour le début de séquence. Le jeton utilisé est `cls_token`. eos_token (`str`, *facultatif*, par défaut `""`) : Jeton de fin de séquence. Lors de la construction d'une séquence à l'aide de jetons spéciaux, ce n'est pas le jeton utilisé pour la fin de séquence. Le jeton utilisé est le `sep_token`. sep_token (`str`, *facultatif*, valeur par défaut `""`) : le jeton séparateur, utilisé lors de la construction d'une séquence à partir de plusieurs séquences, par exemple deux séquences pour la classification de séquences ou un texte et une question pour le question answering. Il est également utilisé comme dernier jeton d'une séquence construite avec des jetons spéciaux. cls_token (`str`, *facultatif*, valeur par défaut `""`) : le jeton de classifieur utilisé lors de la classification de séquence (classification de la séquence entière plutôt que la classification par jeton). C'est le premier jeton de la séquence lorsqu'elle est construite avec des jetons spéciaux. unk_token (`str`, *facultatif*, par défaut `""`) : Le jeton inconnu. Un jeton qui n'est pas dans le vocabulaire ne peut pas être converti en identifiant et est remplacé par ce jeton. pad_token (`str`, *facultatif*, par défaut `""`) : le jeton utilisé pour le bourrage, par exemple lors du groupement de séquences de longueurs différentes. mask_token (`str`, *facultatif*, valeur par défaut `""`) : Le jeton utilisé pour masquer les valeurs. C'est le jeton utilisé lors de l'entraînement de ce modèle avec le modélisation de langage masquée. C'est le jeton que le modèle cherchera à prédire. add_prefix_space (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut ajouter un espace initial à l'entrée. Cela permet de traiter le mot initial comme n'importe quel autre mot. (Le tokenizer RoBERTa détecte le début des mots par l'espace qui les précède). trim_offsets (`bool`, *facultatif*, par défaut `True`) : Indique si l'étape de post-traitement doit rober les décalages afin d'éviter d'inclure des espaces. Construit un tokenizer RoBERTa (basé sur la bibliothèque tokenizers de HuggingFace). Fondé sur l’encodage par paires de bytes (Byte-Pair-Encoding). Ce tokenizer a été entraîné à traiter les espaces comme des parties des jetons (un peu comme sentencepiece), de sorte qu'un mot sera être encodé différemment selon qu'il se trouve au début de la phrase (sans espace) ou non : ```python >>> from transformers import RobertaTokenizer >>> tokenizer = RobertaTokenizer.from_pretrained("FacebookAI/roberta-base") >>> tokenizer("Hello world")["input_ids"] [0, 31414, 232, 2] >>> tokenizer(" Hello world")["input_ids"] [0, 20920, 232, 2] ``` Vous pouvez contourner ce comportement en passant `add_prefix_space=True` lors de l’instanciation de ce tokenizer ou lors de son appel sur un texte, mais comme le modèle n’a pas été pré-entraîné de cette manière, cela pourrait entraîner une baisse des performances. Lorsqu'il est utilisé avec `is_split_into_words=True`, ce tokenizer doit être instancié avec `add_prefix_space=True`. Ce tokenizer hérite de [TokenizersBackend](/docs/transformers/main/fr/main_classes/tokenizer#transformers.TokenizersBackend), qui contient la plupart des méthodes principales. Les utilisateurs doivent se reporter à cette classe mère pour plus d’informations sur ces méthodes. ## Sorties spécifiques à Longformer[[transformers.models.longformer.modeling_longformer.LongformerBaseModelOutput]] #### transformers.models.longformer.modeling_longformer.LongformerBaseModelOutput[[transformers.models.longformer.modeling_longformer.LongformerBaseModelOutput]] ```python transformers.models.longformer.modeling_longformer.LongformerBaseModelOutput(last_hidden_state: Tensor, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None, global_attentions: tuple[torch.Tensor, ...] | None = None) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/longformer/modeling_longformer.py#L41) **Paramètres :** last_hidden_state (`torch.Tensor` de 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.Tensor, ...]`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) : Tuple de `torch.Tensor` (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’embedding initiales facultatives. attentions (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) : Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, x + attention_window + 1)`, où `x` est le nombre de jetons avec masque d'attention globale. Les poids d'attention locale après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention. Il s'agit des poids d'attention de chaque jeton de la séquence vers chaque jeton avec attention globale (les `x` premières valeurs) et vers chaque jeton de la fenêtre d'attention (les `attention_window + 1` valeurs restantes). Notez que les `x` premières valeurs font référence à des jetons avec des positions fixes dans le texte, mais les `attention_window + 1` valeurs restantes font référence à des jetons avec des positions relatives : le poids d'attention d'un jeton vers lui-même se trouve à l'index `x + attention_window / 2` et les `attention_window / 2` valeurs précédentes (suivantes) sont les poids d'attention vers les `attention_window / 2` jetons précédents (suivants). Si la fenêtre d'attention contient un jeton avec attention globale, le poids d'attention à l'index correspondant est défini à 0 ; la valeur doit être accédée depuis les `x` premiers poids d'attention. Si un jeton a une attention globale, les poids d'attention vers tous les autres jetons dans `attentions` sont définis à 0, les valeurs doivent être accédées depuis `global_attentions`. global_attentions (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) : Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, x)`, où `x` est le nombre de jetons avec masque d'attention global. Poids des attentions globales après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention. Il s'agit des poids d'attention de chaque jeton avec attention globale vers chaque jeton de la séquence. Classe de base pour les sorties de Longformer, avec états cachés potentiels, attentions locales et globales. #### transformers.models.longformer.modeling_longformer.LongformerBaseModelOutputWithPooling[[transformers.models.longformer.modeling_longformer.LongformerBaseModelOutputWithPooling]] ```python transformers.models.longformer.modeling_longformer.LongformerBaseModelOutputWithPooling(last_hidden_state: Tensor, pooler_output: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None, global_attentions: tuple[torch.Tensor, ...] | None = None) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/longformer/modeling_longformer.py#L79) **Paramètres :** last_hidden_state (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) : Séquence d'états cachés à la sortie de la dernière couche du modèle. pooler_output (`torch.Tensor` de forme `(batch_size, hidden_size)`) : État caché de la dernière couche du premier jeton de la séquence (jeton de classification), traité ensuite par une couche linéaire et une fonction d'activation Tanh. Les poids de la couche linéaire sont entraînés à partir de l'objectif de prédiction de la phrase suivante (classification) lors de la préformation. hidden_states (`tuple[torch.Tensor, ...]`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) : Tuple de `torch.Tensor` (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’embedding initiales facultatives. attentions (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) : Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, x + attention_window + 1)`, où `x` est le nombre de jetons avec masque d'attention globale. Les poids d'attention locale après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention. Il s'agit des poids d'attention de chaque jeton de la séquence vers chaque jeton avec attention globale (les `x` premières valeurs) et vers chaque jeton de la fenêtre d'attention (les `attention_window + 1` valeurs restantes). Notez que les `x` premières valeurs font référence à des jetons avec des positions fixes dans le texte, mais les `attention_window + 1` valeurs restantes font référence à des jetons avec des positions relatives : le poids d'attention d'un jeton vers lui-même se trouve à l'index `x + attention_window / 2` et les `attention_window / 2` valeurs précédentes (suivantes) sont les poids d'attention vers les `attention_window / 2` jetons précédents (suivants). Si la fenêtre d'attention contient un jeton avec attention globale, le poids d'attention à l'index correspondant est défini à 0 ; la valeur doit être accédée depuis les `x` premiers poids d'attention. Si un jeton a une attention globale, les poids d'attention vers tous les autres jetons dans `attentions` sont définis à 0, les valeurs doivent être accédées depuis `global_attentions`. global_attentions (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) : Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, x)`, où `x` est le nombre de jetons avec masque d'attention global. Poids des attentions globales après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention. Il s'agit des poids d'attention de chaque jeton avec attention globale vers chaque jeton de la séquence. Classe de base pour les sorties de Longformer, qui contient également un regroupement des derniers états cachés. #### transformers.models.longformer.modeling_longformer.LongformerMaskedLMOutput[[transformers.models.longformer.modeling_longformer.LongformerMaskedLMOutput]] ```python transformers.models.longformer.modeling_longformer.LongformerMaskedLMOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None, global_attentions: tuple[torch.Tensor, ...] | None = None) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/longformer/modeling_longformer.py#L122) **Paramètres :** loss (`torch.Tensor` de forme `(1,)`, *facultatif*, renvoyé lorsque `labels` est fourni) : Perte de modélisation de langage masquée (MLM). logits (`torch.Tensor` de 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). hidden_states (`tuple[torch.Tensor, ...]`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) : Tuple de `torch.Tensor` (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’embedding initiales facultatives. attentions (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) : Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, x + attention_window + 1)`, où `x` est le nombre de jetons avec masque d'attention globale. Les poids d'attention locale après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention. Il s'agit des poids d'attention de chaque jeton de la séquence vers chaque jeton avec attention globale (les `x` premières valeurs) et vers chaque jeton de la fenêtre d'attention (les `attention_window + 1` valeurs restantes). Notez que les `x` premières valeurs font référence à des jetons avec des positions fixes dans le texte, mais les `attention_window + 1` valeurs restantes font référence à des jetons avec des positions relatives : le poids d'attention d'un jeton vers lui-même se trouve à l'index `x + attention_window / 2` et les `attention_window / 2` valeurs précédentes (suivantes) sont les poids d'attention vers les `attention_window / 2` jetons précédents (suivants). Si la fenêtre d'attention contient un jeton avec attention globale, le poids d'attention à l'index correspondant est défini à 0 ; la valeur doit être accédée depuis les `x` premiers poids d'attention. Si un jeton a une attention globale, les poids d'attention vers tous les autres jetons dans `attentions` sont définis à 0, les valeurs doivent être accédées depuis `global_attentions`. global_attentions (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) : Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, x)`, où `x` est le nombre de jetons avec masque d'attention global. Poids des attentions globales après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention. Il s'agit des poids d'attention de chaque jeton avec attention globale vers chaque jeton de la séquence. Classe de base pour les sorties des modèles de langage masqués. #### transformers.models.longformer.modeling_longformer.LongformerQuestionAnsweringModelOutput[[transformers.models.longformer.modeling_longformer.LongformerQuestionAnsweringModelOutput]] ```python transformers.models.longformer.modeling_longformer.LongformerQuestionAnsweringModelOutput(loss: typing.Optional[torch.Tensor] = None, start_logits: typing.Optional[torch.Tensor] = None, end_logits: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None, global_attentions: tuple[torch.Tensor, ...] | None = None) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/longformer/modeling_longformer.py#L165) **Paramètres :** loss (`torch.Tensor` de forme `(1,)`, *facultatif*, renvoyé lorsque `labels` est fourni) : La perte totale d'extraction de portée est la somme d'une entropie croisée pour les positions de début et de fin. start_logits (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Scores de début d'intervalle (avant SoftMax). end_logits (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Scores de fin de segment (avant SoftMax). hidden_states (`tuple[torch.Tensor, ...]`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) : Tuple de `torch.Tensor` (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’embedding initiales facultatives. attentions (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) : Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, x + attention_window + 1)`, où `x` est le nombre de jetons avec masque d'attention globale. Les poids d'attention locale après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention. Il s'agit des poids d'attention de chaque jeton de la séquence vers chaque jeton avec attention globale (les `x` premières valeurs) et vers chaque jeton de la fenêtre d'attention (les `attention_window + 1` valeurs restantes). Notez que les `x` premières valeurs font référence à des jetons avec des positions fixes dans le texte, mais les `attention_window + 1` valeurs restantes font référence à des jetons avec des positions relatives : le poids d'attention d'un jeton vers lui-même se trouve à l'index `x + attention_window / 2` et les `attention_window / 2` valeurs précédentes (suivantes) sont les poids d'attention vers les `attention_window / 2` jetons précédents (suivants). Si la fenêtre d'attention contient un jeton avec attention globale, le poids d'attention à l'index correspondant est défini à 0 ; la valeur doit être accédée depuis les `x` premiers poids d'attention. Si un jeton a une attention globale, les poids d'attention vers tous les autres jetons dans `attentions` sont définis à 0, les valeurs doivent être accédées depuis `global_attentions`. global_attentions (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) : Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, x)`, où `x` est le nombre de jetons avec masque d'attention global. Poids des attentions globales après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention. Il s'agit des poids d'attention de chaque jeton avec attention globale vers chaque jeton de la séquence. Classe de base pour les sorties des modèles Longformer de réponse à des questions. #### transformers.models.longformer.modeling_longformer.LongformerSequenceClassifierOutput[[transformers.models.longformer.modeling_longformer.LongformerSequenceClassifierOutput]] ```python transformers.models.longformer.modeling_longformer.LongformerSequenceClassifierOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None, global_attentions: tuple[torch.Tensor, ...] | None = None) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/longformer/modeling_longformer.py#L207) **Paramètres :** loss (`torch.Tensor` de forme `(1,)`, *facultatif*, renvoyé lorsque `labels` est fourni) : perte de classification (ou de régression si config.num_labels==1). logits (`torch.Tensor` de forme `(batch_size, config.num_labels)`) : Scores de classification (ou de régression si config.num_labels==1) (avant SoftMax). hidden_states (`tuple[torch.Tensor, ...]`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) : Tuple de `torch.Tensor` (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’embedding initiales facultatives. attentions (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) : Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, x + attention_window + 1)`, où `x` est le nombre de jetons avec masque d'attention globale. Les poids d'attention locale après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention. Il s'agit des poids d'attention de chaque jeton de la séquence vers chaque jeton avec attention globale (les `x` premières valeurs) et vers chaque jeton de la fenêtre d'attention (les `attention_window + 1` valeurs restantes). Notez que les `x` premières valeurs font référence à des jetons avec des positions fixes dans le texte, mais les `attention_window + 1` valeurs restantes font référence à des jetons avec des positions relatives : le poids d'attention d'un jeton vers lui-même se trouve à l'index `x + attention_window / 2` et les `attention_window / 2` valeurs précédentes (suivantes) sont les poids d'attention vers les `attention_window / 2` jetons précédents (suivants). Si la fenêtre d'attention contient un jeton avec attention globale, le poids d'attention à l'index correspondant est défini à 0 ; la valeur doit être accédée depuis les `x` premiers poids d'attention. Si un jeton a une attention globale, les poids d'attention vers tous les autres jetons dans `attentions` sont définis à 0, les valeurs doivent être accédées depuis `global_attentions`. global_attentions (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) : Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, x)`, où `x` est le nombre de jetons avec masque d'attention global. Poids des attentions globales après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention. Il s'agit des poids d'attention de chaque jeton avec attention globale vers chaque jeton de la séquence. Classe de base pour les sorties des modèles de classification de phrases. #### transformers.models.longformer.modeling_longformer.LongformerMultipleChoiceModelOutput[[transformers.models.longformer.modeling_longformer.LongformerMultipleChoiceModelOutput]] ```python transformers.models.longformer.modeling_longformer.LongformerMultipleChoiceModelOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None, global_attentions: tuple[torch.Tensor, ...] | None = None) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/longformer/modeling_longformer.py#L250) **Paramètres :** loss (`torch.Tensor` de forme *(1,)*, *facultatif*, renvoyé lorsque `labels` est fourni) : Perte de classification. logits (`torch.Tensor` de forme `(batch_size, num_choices)`) : *num_choices* est la deuxième dimension des tenseurs d'entrée. (voir *input_ids* ci-dessus). Scores de classification (avant SoftMax). hidden_states (`tuple[torch.Tensor, ...]`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) : Tuple de `torch.Tensor` (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’embedding initiales facultatives. attentions (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) : Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, x + attention_window + 1)`, où `x` est le nombre de jetons avec masque d'attention globale. Les poids d'attention locale après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention. Il s'agit des poids d'attention de chaque jeton de la séquence vers chaque jeton avec attention globale (les `x` premières valeurs) et vers chaque jeton de la fenêtre d'attention (les `attention_window + 1` valeurs restantes). Notez que les `x` premières valeurs font référence à des jetons avec des positions fixes dans le texte, mais les `attention_window + 1` valeurs restantes font référence à des jetons avec des positions relatives : le poids d'attention d'un jeton vers lui-même se trouve à l'index `x + attention_window / 2` et les `attention_window / 2` valeurs précédentes (suivantes) sont les poids d'attention vers les `attention_window / 2` jetons précédents (suivants). Si la fenêtre d'attention contient un jeton avec attention globale, le poids d'attention à l'index correspondant est défini à 0 ; la valeur doit être accédée depuis les `x` premiers poids d'attention. Si un jeton a une attention globale, les poids d'attention vers tous les autres jetons dans `attentions` sont définis à 0, les valeurs doivent être accédées depuis `global_attentions`. global_attentions (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) : Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, x)`, où `x` est le nombre de jetons avec masque d'attention global. Poids des attentions globales après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention. Il s'agit des poids d'attention de chaque jeton avec attention globale vers chaque jeton de la séquence. Classe de base pour les sorties des modèles Longformer de choix multiples. #### transformers.models.longformer.modeling_longformer.LongformerTokenClassifierOutput[[transformers.models.longformer.modeling_longformer.LongformerTokenClassifierOutput]] ```python transformers.models.longformer.modeling_longformer.LongformerTokenClassifierOutput(loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None, global_attentions: tuple[torch.Tensor, ...] | None = None) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/longformer/modeling_longformer.py#L295) **Paramètres :** loss (`torch.Tensor` de forme `(1,)`, *facultatif*, renvoyé lorsque `labels` est fourni) : Perte de classification. logits (`torch.Tensor` de forme `(batch_size, sequence_length, config.num_labels)`) : Scores de classification (avant SoftMax). hidden_states (`tuple[torch.Tensor, ...]`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) : Tuple de `torch.Tensor` (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’embedding initiales facultatives. attentions (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) : Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, x + attention_window + 1)`, où `x` est le nombre de jetons avec masque d'attention globale. Les poids d'attention locale après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention. Il s'agit des poids d'attention de chaque jeton de la séquence vers chaque jeton avec attention globale (les `x` premières valeurs) et vers chaque jeton de la fenêtre d'attention (les `attention_window + 1` valeurs restantes). Notez que les `x` premières valeurs font référence à des jetons avec des positions fixes dans le texte, mais les `attention_window + 1` valeurs restantes font référence à des jetons avec des positions relatives : le poids d'attention d'un jeton vers lui-même se trouve à l'index `x + attention_window / 2` et les `attention_window / 2` valeurs précédentes (suivantes) sont les poids d'attention vers les `attention_window / 2` jetons précédents (suivants). Si la fenêtre d'attention contient un jeton avec attention globale, le poids d'attention à l'index correspondant est défini à 0 ; la valeur doit être accédée depuis les `x` premiers poids d'attention. Si un jeton a une attention globale, les poids d'attention vers tous les autres jetons dans `attentions` sont définis à 0, les valeurs doivent être accédées depuis `global_attentions`. global_attentions (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) : Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, x)`, où `x` est le nombre de jetons avec masque d'attention global. Poids des attentions globales après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention. Il s'agit des poids d'attention de chaque jeton avec attention globale vers chaque jeton de la séquence. Classe de base pour les sorties des modèles de classification de jetons. ## LongformerModel[[transformers.LongformerModel]] #### transformers.LongformerModel[[transformers.LongformerModel]] ```python transformers.LongformerModel(config: LongformerConfig, add_pooling_layer = True) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/longformer/modeling_longformer.py#L1276) **Paramètres :** config ([LongformerConfig](/docs/transformers/main/fr/model_doc/longformer#transformers.LongformerConfig)) : 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()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle. add_pooling_layer (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut ajouter une couche de pooling Le modèle Longformer brut, qui produit des états cachés bruts sans aucune tête spécifique au sommet. Ce modèle hérite de [PreTrainedModel](/docs/transformers/main/fr/main_classes/model#transformers.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, l'élagage des têtes, etc.). Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#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[[transformers.LongformerModel.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, global_attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/longformer/modeling_longformer.py#L1384) **Paramètres :** input_ids (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/main/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids) attention_mask (`torch.Tensor` de 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 qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask) global_attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour déterminer l'attention accordée à chaque jeton, attention locale ou attention globale. Les jetons avec une attention globale portent leur attention sur tous les autres jetons, et tous les autres jetons portent leur attention sur eux. C'est important pour l'ajustement fin spécifique à une tâche car cela rend le modèle plus flexible dans la représentation de la tâche. Par exemple, pour la classification, le jeton doit recevoir une attention globale. Pour la question-réponse, tous les jetons de la question doivent également avoir une attention globale. Veuillez consulter le [Longformer paper](https://huggingface.co/papers/2004.05150) pour plus de détails. Valeurs du masque sélectionnées dans `[0, 1]` : - 0 pour l'attention locale (une attention par fenêtre glissante), - 1 pour l'attention globale (jetons qui portent leur attention sur tous les autres jetons, et sur lesquels tous les autres jetons portent leur attention). token_type_ids (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de segment pour indiquer les première et deuxième parties des entrées. Les indices sont sélectionnés dans `[0, 1]` : - 0 correspond à un jeton de *phrase A*, - 1 correspond à un jeton de *phrase B*. [Que sont les identifiants de type de jeton ?](../glossary#token-type-ids) position_ids (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle `[0, config.n_positions - 1]`. [Que sont les position IDs ?](../glossary#position-ids) inputs_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer `input_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 indices `input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle. output_attentions (`bool`, *facultatif*) : Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Voir `attentions` sous les tenseurs retournés pour plus de détails. output_hidden_states (`bool`, *facultatif*) : Indique s'il faut retourner les états cachés de toutes les couches. Voir `hidden_states` dans les tenseurs retournés pour plus de détails. return_dict (`bool`, *facultatif*) : Indique s'il faut retourner un [ModelOutput](/docs/transformers/main/fr/main_classes/output#transformers.utils.ModelOutput) plutôt qu'un simple tuple. **Retourne :** [LongformerBaseModelOutputWithPooling](/docs/transformers/main/fr/model_doc/longformer#transformers.models.longformer.modeling_longformer.LongformerBaseModelOutputWithPooling) ou `tuple(torch.Tensor)` Un [LongformerBaseModelOutputWithPooling](/docs/transformers/main/fr/model_doc/longformer#transformers.models.longformer.modeling_longformer.LongformerBaseModelOutputWithPooling) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([LongformerConfig](/docs/transformers/main/fr/model_doc/longformer#transformers.LongformerConfig)) et les entrées. La méthode forward du [LongformerModel](/docs/transformers/main/fr/model_doc/longformer#transformers.LongformerModel) 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 `Module` plutô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.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) -- Séquence d'états cachés à la sortie de la dernière couche du modèle. - **pooler_output** (`torch.Tensor` de forme `(batch_size, hidden_size)`) -- État caché de la dernière couche du premier jeton de la séquence (jeton de classification), traité ensuite par une couche linéaire et une fonction d'activation Tanh. Les poids de la couche linéaire sont entraînés à partir de l'objectif de prédiction de la phrase suivante (classification) lors de la pré-formation. - **hidden_states** (`tuple[torch.Tensor, ...]`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (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.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, x + attention_window + 1)`, où `x` est le nombre de jetons avec un masque d'attention global. Poids d'attention locaux après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention. Il s'agit des poids d'attention de chaque jeton de la séquence vers chaque jeton avec attention globale (les `x` premières valeurs) et vers chaque jeton de la fenêtre d'attention (les valeurs restantes `attention_window + 1` values). Note that the first `x` values refer to tokens with fixed positions in the text, but the remaining `attention_window + 1` values refer to tokens with relative positions: the attention weight of a token to itself is located at index `x + attention_window / 2` and the `attention_window / 2` preceding (succeeding) values are the attention weights to the `attention_window / 2` preceding (succeeding) tokens. If the attention window contains a token with global attention, the attention weight at the corresponding index is set to 0; the value should be accessed from the first `x` attention weights. If a token has global attention, the attention weights to all other tokens in `attentions` is set to 0, the values should be accessed from `global_attentions`. - **global_attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, x)`, où `x` est le nombre de jetons avec un masque d'attention globale. Poids d'attention globaux après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention. Il s'agit des poids d'attention de chaque token doté d'une attention globale vers chaque token de la séquence. Exemples : ```python >>> import torch >>> from transformers import LongformerModel, AutoTokenizer >>> model = LongformerModel.from_pretrained("allenai/longformer-base-4096") >>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-base-4096") >>> SAMPLE_TEXT = " ".join(["Hello world! "] * 1000) # long input document >>> input_ids = torch.tensor(tokenizer.encode(SAMPLE_TEXT)).unsqueeze(0) # batch of size 1 >>> attention_mask = torch.ones( ... input_ids.shape, dtype=torch.long, device=input_ids.device ... ) # initialize to local attention >>> global_attention_mask = torch.zeros( ... input_ids.shape, dtype=torch.long, device=input_ids.device ... ) # initialize to global attention to be deactivated for all tokens >>> global_attention_mask[ ... :, ... [ ... 1, ... 4, ... 21, ... ], ... ] = 1 # Set global attention to random tokens for the sake of this example >>> # Usually, set global attention based on the task. For example, >>> # classification: the token >>> # QA: question tokens >>> # LM: potentially on the beginning of sentences and paragraphs >>> outputs = model(input_ids, attention_mask=attention_mask, global_attention_mask=global_attention_mask) >>> sequence_output = outputs.last_hidden_state >>> pooled_output = outputs.pooler_output ``` ## LongformerForMaskedLM[[transformers.LongformerForMaskedLM]] #### transformers.LongformerForMaskedLM[[transformers.LongformerForMaskedLM]] ```python transformers.LongformerForMaskedLM(config: LongformerConfig) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/longformer/modeling_longformer.py#L1522) **Paramètres :** config ([LongformerConfig](/docs/transformers/main/fr/model_doc/longformer#transformers.LongformerConfig)) : 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()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle. Le modèle Longformer avec une tête de `language modeling` au sommet." Ce modèle hérite de [PreTrainedModel](/docs/transformers/main/fr/main_classes/model#transformers.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, l'élagage des têtes, etc.). Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#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[[transformers.LongformerForMaskedLM.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, global_attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/longformer/modeling_longformer.py#L1543) **Paramètres :** input_ids (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/main/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids) attention_mask (`torch.Tensor` de 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 qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask) global_attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour déterminer l'attention accordée à chaque jeton, attention locale ou attention globale. Les jetons avec une attention globale portent leur attention sur tous les autres jetons, et tous les autres jetons portent leur attention sur eux. C'est important pour l'ajustement fin spécifique à une tâche car cela rend le modèle plus flexible dans la représentation de la tâche. Par exemple, pour la classification, le jeton doit recevoir une attention globale. Pour la question-réponse, tous les jetons de la question doivent également avoir une attention globale. Veuillez consulter le [Longformer paper](https://huggingface.co/papers/2004.05150) pour plus de détails. Valeurs du masque sélectionnées dans `[0, 1]` : - 0 pour l'attention locale (une attention par fenêtre glissante), - 1 pour l'attention globale (jetons qui portent leur attention sur tous les autres jetons, et sur lesquels tous les autres jetons portent leur attention). token_type_ids (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de segment pour indiquer les première et deuxième parties des entrées. Les indices sont sélectionnés dans `[0, 1]` : - 0 correspond à un jeton de *phrase A*, - 1 correspond à un jeton de *phrase B*. [Que sont les identifiants de type de jeton ?](../glossary#token-type-ids) position_ids (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle `[0, config.n_positions - 1]`. [Que sont les position IDs ?](../glossary#position-ids) inputs_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer `input_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 indices `input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle. labels (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Étiquettes pour le calcul de la perte de modélisation de langage masquée. Les indices doivent être dans `[-100, 0, ..., config.vocab_size]` (voir la docstring de `input_ids`). Les jetons dont l'indice est défini sur `-100` sont ignorés (masqués) ; la perte n'est calculée que pour les jetons dont l'étiquette est dans `[0, ..., config.vocab_size]`. output_attentions (`bool`, *facultatif*) : Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Voir `attentions` sous les tenseurs retournés pour plus de détails. output_hidden_states (`bool`, *facultatif*) : Indique s'il faut retourner les états cachés de toutes les couches. Voir `hidden_states` dans les tenseurs retournés pour plus de détails. return_dict (`bool`, *facultatif*) : Indique s'il faut retourner un [ModelOutput](/docs/transformers/main/fr/main_classes/output#transformers.utils.ModelOutput) plutôt qu'un simple tuple. **Retourne :** [LongformerMaskedLMOutput](/docs/transformers/main/fr/model_doc/longformer#transformers.models.longformer.modeling_longformer.LongformerMaskedLMOutput) ou `tuple(torch.Tensor)` Un [LongformerMaskedLMOutput](/docs/transformers/main/fr/model_doc/longformer#transformers.models.longformer.modeling_longformer.LongformerMaskedLMOutput) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([LongformerConfig](/docs/transformers/main/fr/model_doc/longformer#transformers.LongformerConfig)) et les entrées. La méthode forward de [LongformerForMaskedLM](/docs/transformers/main/fr/model_doc/longformer#transformers.LongformerForMaskedLM) 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 `Module` plutô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.Tensor` de forme `(1,)`, *facultatif*, renvoyé lorsque `labels` est fourni) -- Perte de modélisation de langage masquée (MLM). - **logits** (`torch.Tensor` de 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). - **hidden_states** (`tuple[torch.Tensor, ...]`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (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.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, x + attention_window + 1)`, où `x` est le nombre de jetons avec un masque d'attention global. Poids d'attention locaux après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention. Il s'agit des poids d'attention de chaque jeton de la séquence vers chaque jeton avec attention globale (les `x` premières valeurs) et vers chaque jeton de la fenêtre d'attention (les valeurs restantes `attention_window + 1` values). Note that the first `x` values refer to tokens with fixed positions in the text, but the remaining `attention_window + 1` values refer to tokens with relative positions: the attention weight of a token to itself is located at index `x + attention_window / 2` and the `attention_window / 2` preceding (succeeding) values are the attention weights to the `attention_window / 2` preceding (succeeding) tokens. If the attention window contains a token with global attention, the attention weight at the corresponding index is set to 0; the value should be accessed from the first `x` attention weights. If a token has global attention, the attention weights to all other tokens in `attentions` is set to 0, the values should be accessed from `global_attentions`. - **global_attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, x)`, où `x` est le nombre de jetons avec un masque d'attention globale. Poids d'attention globaux après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention. Il s'agit des poids d'attention de chaque token doté d'une attention globale vers chaque token de la séquence. Exemple de remplissage du masque : ```python >>> from transformers import AutoTokenizer, LongformerForMaskedLM >>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-base-4096") >>> model = LongformerForMaskedLM.from_pretrained("allenai/longformer-base-4096") ``` Essayons une entrée très longue. ```python >>> TXT = ( ... "My friends are but they eat too many carbs." ... + " That's why I decide not to eat with them." * 300 ... ) >>> input_ids = tokenizer([TXT], return_tensors="pt")["input_ids"] >>> logits = model(input_ids).logits >>> masked_index = (input_ids[0] == tokenizer.mask_token_id).nonzero().item() >>> probs = logits[0, masked_index].softmax(dim=0) >>> values, predictions = probs.topk(5) >>> tokenizer.decode(predictions).split() ['healthy', 'skinny', 'thin', 'good', 'vegetarian'] ``` ## LongformerForSequenceClassification[[transformers.LongformerForSequenceClassification]] #### transformers.LongformerForSequenceClassification[[transformers.LongformerForSequenceClassification]] ```python transformers.LongformerForSequenceClassification(config: LongformerConfig) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/longformer/modeling_longformer.py#L1639) **Paramètres :** config ([LongformerConfig](/docs/transformers/main/fr/model_doc/longformer#transformers.LongformerConfig)) : 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()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle. Modèle Longformer, un transformer doté d'une tête de classification/régression de séquence (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](/docs/transformers/main/fr/main_classes/model#transformers.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, l'élagage des têtes, etc.). Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#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[[transformers.LongformerForSequenceClassification.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, global_attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/longformer/modeling_longformer.py#L1651) **Paramètres :** input_ids (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/main/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids) attention_mask (`torch.Tensor` de 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 qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask) global_attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour déterminer l'attention accordée à chaque jeton, attention locale ou attention globale. Les jetons avec une attention globale portent leur attention sur tous les autres jetons, et tous les autres jetons portent leur attention sur eux. C'est important pour l'ajustement fin spécifique à une tâche car cela rend le modèle plus flexible dans la représentation de la tâche. Par exemple, pour la classification, le jeton doit recevoir une attention globale. Pour la question-réponse, tous les jetons de la question doivent également avoir une attention globale. Veuillez consulter le [Longformer paper](https://huggingface.co/papers/2004.05150) pour plus de détails. Valeurs du masque sélectionnées dans `[0, 1]` : - 0 pour l'attention locale (une attention par fenêtre glissante), - 1 pour l'attention globale (jetons qui portent leur attention sur tous les autres jetons, et sur lesquels tous les autres jetons portent leur attention). token_type_ids (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de segment pour indiquer les première et deuxième parties des entrées. Les indices sont sélectionnés dans `[0, 1]` : - 0 correspond à un jeton de *phrase A*, - 1 correspond à un jeton de *phrase B*. [Que sont les identifiants de type de jeton ?](../glossary#token-type-ids) position_ids (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle `[0, config.n_positions - 1]`. [Que sont les position IDs ?](../glossary#position-ids) inputs_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer `input_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 indices `input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle. labels (`torch.LongTensor` de 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]`. Si `config.num_labels == 1`, une perte de régression est calculée (perte du carré moyen). Si `config.num_labels > 1`, une perte de classification est calculée (entropie croisée). output_attentions (`bool`, *facultatif*) : Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Voir `attentions` sous les tenseurs retournés pour plus de détails. output_hidden_states (`bool`, *facultatif*) : Indique s'il faut retourner les états cachés de toutes les couches. Voir `hidden_states` dans les tenseurs retournés pour plus de détails. return_dict (`bool`, *facultatif*) : Indique s'il faut retourner un [ModelOutput](/docs/transformers/main/fr/main_classes/output#transformers.utils.ModelOutput) plutôt qu'un simple tuple. **Retourne :** [LongformerSequenceClassifierOutput](/docs/transformers/main/fr/model_doc/longformer#transformers.models.longformer.modeling_longformer.LongformerSequenceClassifierOutput) ou `tuple(torch.Tensor)` Un [LongformerSequenceClassifierOutput](/docs/transformers/main/fr/model_doc/longformer#transformers.models.longformer.modeling_longformer.LongformerSequenceClassifierOutput) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([LongformerConfig](/docs/transformers/main/fr/model_doc/longformer#transformers.LongformerConfig)) et les entrées. La méthode forward de [LongformerForSequenceClassification](/docs/transformers/main/fr/model_doc/longformer#transformers.LongformerForSequenceClassification) 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 `Module` plutô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.Tensor` de forme `(1,)`, *facultatif*, renvoyé lorsque `labels` est fourni) -- Perte de classification (ou de régression si config.num_labels==1). - **logits** (`torch.Tensor` de forme `(batch_size, config.num_labels)`) -- Scores de classification (ou de régression si config.num_labels==1) (avant SoftMax). - **hidden_states** (`tuple[torch.Tensor, ...]`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (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.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, x + attention_window + 1)`, où `x` est le nombre de jetons avec un masque d'attention global. Poids d'attention locaux après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention. Il s'agit des poids d'attention de chaque jeton de la séquence vers chaque jeton avec attention globale (les `x` premières valeurs) et vers chaque jeton de la fenêtre d'attention (les valeurs restantes `attention_window + 1` values). Note that the first `x` values refer to tokens with fixed positions in the text, but the remaining `attention_window + 1` values refer to tokens with relative positions: the attention weight of a token to itself is located at index `x + attention_window / 2` and the `attention_window / 2` preceding (succeeding) values are the attention weights to the `attention_window / 2` preceding (succeeding) tokens. If the attention window contains a token with global attention, the attention weight at the corresponding index is set to 0; the value should be accessed from the first `x` attention weights. If a token has global attention, the attention weights to all other tokens in `attentions` is set to 0, the values should be accessed from `global_attentions`. - **global_attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, x)`, où `x` est le nombre de jetons avec un masque d'attention globale. Poids d'attention globaux après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention. Il s'agit des poids d'attention de chaque token doté d'une attention globale vers chaque token de la séquence. Exemple de classification mono-étiquette : ```python >>> import torch >>> from transformers import AutoTokenizer, LongformerForSequenceClassification >>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-base-4096") >>> model = LongformerForSequenceClassification.from_pretrained("allenai/longformer-base-4096") >>> 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 = LongformerForSequenceClassification.from_pretrained("allenai/longformer-base-4096", num_labels=num_labels) >>> labels = torch.tensor([1]) >>> loss = model(**inputs, labels=labels).loss >>> round(loss.item(), 2) ... ``` Exemple de classification multi-étiquettes : ```python >>> import torch >>> from transformers import AutoTokenizer, LongformerForSequenceClassification >>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-base-4096") >>> model = LongformerForSequenceClassification.from_pretrained("allenai/longformer-base-4096", 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 = LongformerForSequenceClassification.from_pretrained( ... "allenai/longformer-base-4096", 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).loss ``` ## LongformerForMultipleChoice[[transformers.LongformerForMultipleChoice]] #### transformers.LongformerForMultipleChoice[[transformers.LongformerForMultipleChoice]] ```python transformers.LongformerForMultipleChoice(config: LongformerConfig) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/longformer/modeling_longformer.py#L1966) **Paramètres :** config ([LongformerConfig](/docs/transformers/main/fr/model_doc/longformer#transformers.LongformerConfig)) : 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()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle. Le modèle Longformer avec une tête de classification à choix multiples au sommet (une couche linéaire au-dessus de la sortie agrégée et un softmax), par exemple pour les tâches RocStories/SWAG. Ce modèle hérite de [PreTrainedModel](/docs/transformers/main/fr/main_classes/model#transformers.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, l'élagage des têtes, etc.). Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#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[[transformers.LongformerForMultipleChoice.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, global_attention_mask: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/longformer/modeling_longformer.py#L1977) **Paramètres :** input_ids (`torch.LongTensor` de forme `(batch_size, num_choices, sequence_length)`) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/main/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids) token_type_ids (`torch.LongTensor` de forme `(batch_size, num_choices, sequence_length)`, *facultatif*) : Indices de jetons de segment pour indiquer les première et deuxième parties des entrées. Les indices sont sélectionnés dans `[0, 1]` : - 0 correspond à un jeton de *phrase A*, - 1 correspond à un jeton de *phrase B*. [Que sont les identifiants de type de jeton ?](../glossary#token-type-ids) attention_mask (`torch.Tensor` de 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 qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask) global_attention_mask (`torch.Tensor` de forme `(batch_size, num_choices, sequence_length)`, *facultatif*) : Masque pour déterminer l'attention accordée à chaque jeton, attention locale ou attention globale. Les jetons avec une attention globale portent leur attention sur tous les autres jetons, et tous les autres jetons portent leur attention sur eux. C'est important pour l'ajustement fin spécifique à une tâche car cela rend le modèle plus flexible dans la représentation de la tâche. Par exemple, pour la classification, le jeton doit recevoir une attention globale. Pour la question-réponse, tous les jetons de la question doivent également avoir une attention globale. Veuillez consulter le [Longformer paper](https://huggingface.co/papers/2004.05150) pour plus de détails. Valeurs du masque sélectionnées dans `[0, 1]` : - 0 pour l'attention locale (une attention par fenêtre glissante), - 1 pour l'attention globale (jetons qui portent leur attention sur tous les autres jetons, et sur lesquels tous les autres jetons portent leur attention). labels (`torch.LongTensor` de forme `(batch_size,)`, *facultatif*) : Étiquettes pour le calcul de la perte de classification à choix multiples. Les indices doivent être dans `[0, ..., num_choices-1]` où `num_choices` est la taille de la deuxième dimension des tenseurs d'entrée. (Voir `input_ids` ci-dessus) position_ids (`torch.LongTensor` de forme `(batch_size, num_choices, sequence_length)`, *facultatif*) : Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle `[0, config.max_position_embeddings - 1]`. [Que sont les position IDs ?](../glossary#position-ids) inputs_embeds (`torch.Tensor` de forme `(batch_size, num_choices, sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer `input_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 façon de convertir les indices `input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégrations interne du modèle. output_attentions (`bool`, *facultatif*) : Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Voir `attentions` sous les tenseurs retournés pour plus de détails. output_hidden_states (`bool`, *facultatif*) : Indique s'il faut retourner les états cachés de toutes les couches. Voir `hidden_states` dans les tenseurs retournés pour plus de détails. return_dict (`bool`, *facultatif*) : Indique s'il faut retourner un [ModelOutput](/docs/transformers/main/fr/main_classes/output#transformers.utils.ModelOutput) plutôt qu'un simple tuple. **Retourne :** [LongformerMultipleChoiceModelOutput](/docs/transformers/main/fr/model_doc/longformer#transformers.models.longformer.modeling_longformer.LongformerMultipleChoiceModelOutput) ou `tuple(torch.Tensor)` Un [LongformerMultipleChoiceModelOutput](/docs/transformers/main/fr/model_doc/longformer#transformers.models.longformer.modeling_longformer.LongformerMultipleChoiceModelOutput) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([LongformerConfig](/docs/transformers/main/fr/model_doc/longformer#transformers.LongformerConfig)) et les entrées. La méthode forward de [LongformerForMultipleChoice](/docs/transformers/main/fr/model_doc/longformer#transformers.LongformerForMultipleChoice) surcharge 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 `Module` plutô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.Tensor` de forme *(1,)*, *facultatif*, renvoyé lorsque `labels` est fourni) -- Perte de classification. - **logits** (`torch.Tensor` de forme `(batch_size, num_choices)`) -- *num_choices* est la deuxième dimension des tenseurs d'entrée. (voir *input_ids* ci-dessus). Scores de classification (avant SoftMax). - **hidden_states** (`tuple[torch.Tensor, ...]`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (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.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, x + attention_window + 1)`, où `x` est le nombre de jetons avec un masque d'attention global. Poids d'attention locaux après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention. Il s'agit des poids d'attention de chaque jeton de la séquence vers chaque jeton avec attention globale (les `x` premières valeurs) et vers chaque jeton de la fenêtre d'attention (les valeurs restantes `attention_window + 1` values). Note that the first `x` values refer to tokens with fixed positions in the text, but the remaining `attention_window + 1` values refer to tokens with relative positions: the attention weight of a token to itself is located at index `x + attention_window / 2` and the `attention_window / 2` preceding (succeeding) values are the attention weights to the `attention_window / 2` preceding (succeeding) tokens. If the attention window contains a token with global attention, the attention weight at the corresponding index is set to 0; the value should be accessed from the first `x` attention weights. If a token has global attention, the attention weights to all other tokens in `attentions` is set to 0, the values should be accessed from `global_attentions`. - **global_attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, x)`, où `x` est le nombre de jetons avec un masque d'attention globale. Poids d'attention globaux après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention. Il s'agit des poids d'attention de chaque token doté d'une attention globale vers chaque token de la séquence. Exemple : ```python >>> from transformers import AutoTokenizer, LongformerForMultipleChoice >>> import torch >>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-base-4096") >>> model = LongformerForMultipleChoice.from_pretrained("allenai/longformer-base-4096") >>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced." >>> choice0 = "It is eaten with a fork and a knife." >>> choice1 = "It is eaten while held in the hand." >>> labels = torch.tensor(0).unsqueeze(0) # choice0 is correct (according to Wikipedia ;)), batch size 1 >>> encoding = tokenizer([prompt, prompt], [choice0, choice1], return_tensors="pt", padding=True) >>> outputs = model(**{k: v.unsqueeze(0) for k, v in encoding.items()}, labels=labels) # batch size is 1 >>> # the linear classifier still needs to be trained >>> loss = outputs.loss >>> logits = outputs.logits ``` ## LongformerForTokenClassification[[transformers.LongformerForTokenClassification]] #### transformers.LongformerForTokenClassification[[transformers.LongformerForTokenClassification]] ```python transformers.LongformerForTokenClassification(config: LongformerConfig) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/longformer/modeling_longformer.py#L1887) **Paramètres :** config ([LongformerConfig](/docs/transformers/main/fr/model_doc/longformer#transformers.LongformerConfig)) : 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()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle. Le transformer Longformer 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](/docs/transformers/main/fr/main_classes/model#transformers.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, l'élagage des têtes, etc.). Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#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[[transformers.LongformerForTokenClassification.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, global_attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/longformer/modeling_longformer.py#L1899) **Paramètres :** input_ids (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/main/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids) attention_mask (`torch.Tensor` de 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 qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask) global_attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour déterminer l'attention accordée à chaque jeton, attention locale ou attention globale. Les jetons avec une attention globale portent leur attention sur tous les autres jetons, et tous les autres jetons portent leur attention sur eux. C'est important pour l'ajustement fin spécifique à une tâche car cela rend le modèle plus flexible dans la représentation de la tâche. Par exemple, pour la classification, le jeton doit recevoir une attention globale. Pour la question-réponse, tous les jetons de la question doivent également avoir une attention globale. Veuillez consulter le [Longformer paper](https://huggingface.co/papers/2004.05150) pour plus de détails. Valeurs du masque sélectionnées dans `[0, 1]` : - 0 pour l'attention locale (une attention par fenêtre glissante), - 1 pour l'attention globale (jetons qui portent leur attention sur tous les autres jetons, et sur lesquels tous les autres jetons portent leur attention). token_type_ids (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de segment pour indiquer les première et deuxième parties des entrées. Les indices sont sélectionnés dans `[0, 1]` : - 0 correspond à un jeton de *phrase A*, - 1 correspond à un jeton de *phrase B*. [Que sont les identifiants de type de jeton ?](../glossary#token-type-ids) position_ids (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle `[0, config.n_positions - 1]`. [Que sont les position IDs ?](../glossary#position-ids) inputs_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer `input_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 indices `input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle. labels (`torch.LongTensor` de 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]`. output_attentions (`bool`, *facultatif*) : Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Voir `attentions` sous les tenseurs retournés pour plus de détails. output_hidden_states (`bool`, *facultatif*) : Indique s'il faut retourner les états cachés de toutes les couches. Voir `hidden_states` dans les tenseurs retournés pour plus de détails. return_dict (`bool`, *facultatif*) : Indique s'il faut retourner un [ModelOutput](/docs/transformers/main/fr/main_classes/output#transformers.utils.ModelOutput) plutôt qu'un simple tuple. **Retourne :** [LongformerTokenClassifierOutput](/docs/transformers/main/fr/model_doc/longformer#transformers.models.longformer.modeling_longformer.LongformerTokenClassifierOutput) ou `tuple(torch.Tensor)` Un [LongformerTokenClassifierOutput](/docs/transformers/main/fr/model_doc/longformer#transformers.models.longformer.modeling_longformer.LongformerTokenClassifierOutput) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([LongformerConfig](/docs/transformers/main/fr/model_doc/longformer#transformers.LongformerConfig)) et les entrées. La méthode forward de [LongformerForTokenClassification](/docs/transformers/main/fr/model_doc/longformer#transformers.LongformerForTokenClassification) 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 `Module` plutô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.Tensor` de forme `(1,)`, *facultatif*, renvoyé lorsque `labels` est fourni) -- Perte de classification. - **logits** (`torch.Tensor` de forme `(batch_size, sequence_length, config.num_labels)`) -- Scores de classification (avant SoftMax). - **hidden_states** (`tuple[torch.Tensor, ...]`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (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.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, x + attention_window + 1)`, où `x` est le nombre de jetons avec un masque d'attention global. Poids d'attention locaux après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention. Il s'agit des poids d'attention de chaque jeton de la séquence vers chaque jeton avec attention globale (les `x` premières valeurs) et vers chaque jeton de la fenêtre d'attention (les valeurs restantes `attention_window + 1` values). Note that the first `x` values refer to tokens with fixed positions in the text, but the remaining `attention_window + 1` values refer to tokens with relative positions: the attention weight of a token to itself is located at index `x + attention_window / 2` and the `attention_window / 2` preceding (succeeding) values are the attention weights to the `attention_window / 2` preceding (succeeding) tokens. If the attention window contains a token with global attention, the attention weight at the corresponding index is set to 0; the value should be accessed from the first `x` attention weights. If a token has global attention, the attention weights to all other tokens in `attentions` is set to 0, the values should be accessed from `global_attentions`. - **global_attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, x)`, où `x` est le nombre de jetons avec un masque d'attention globale. Poids d'attention globaux après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention. Il s'agit des poids d'attention de chaque token doté d'une attention globale vers chaque token de la séquence. Exemple : ```python >>> from transformers import AutoTokenizer, LongformerForTokenClassification >>> import torch >>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-base-4096") >>> model = LongformerForTokenClassification.from_pretrained("allenai/longformer-base-4096") >>> 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) ... ``` ## LongformerForQuestionAnswering[[transformers.LongformerForQuestionAnswering]] #### transformers.LongformerForQuestionAnswering[[transformers.LongformerForQuestionAnswering]] ```python transformers.LongformerForQuestionAnswering(config: LongformerConfig) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/longformer/modeling_longformer.py#L1758) **Paramètres :** config ([LongformerConfig](/docs/transformers/main/fr/model_doc/longformer#transformers.LongformerConfig)) : 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()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle. Le transformer Longformer avec une tête de classification de segments au sommet pour les tâches de question-réponse extractives comme SQuAD (une couche linéaire au sommet de la sortie des états cachés pour calculer `span start logits` et `span end logits`). Ce modèle hérite de [PreTrainedModel](/docs/transformers/main/fr/main_classes/model#transformers.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, l'élagage des têtes, etc.). Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#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[[transformers.LongformerForQuestionAnswering.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, global_attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, start_positions: typing.Optional[torch.Tensor] = None, end_positions: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/longformer/modeling_longformer.py#L1769) **Paramètres :** input_ids (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/main/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids) attention_mask (`torch.Tensor` de 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 qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask) global_attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour déterminer l'attention accordée à chaque jeton, attention locale ou attention globale. Les jetons avec une attention globale portent leur attention sur tous les autres jetons, et tous les autres jetons portent leur attention sur eux. C'est important pour l'ajustement fin spécifique à une tâche car cela rend le modèle plus flexible dans la représentation de la tâche. Par exemple, pour la classification, le jeton doit recevoir une attention globale. Pour la question-réponse, tous les jetons de la question doivent également avoir une attention globale. Veuillez consulter le [Longformer paper](https://huggingface.co/papers/2004.05150) pour plus de détails. Valeurs du masque sélectionnées dans `[0, 1]` : - 0 pour l'attention locale (une attention par fenêtre glissante), - 1 pour l'attention globale (jetons qui portent leur attention sur tous les autres jetons, et sur lesquels tous les autres jetons portent leur attention). token_type_ids (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de segment pour indiquer les première et deuxième parties des entrées. Les indices sont sélectionnés dans `[0, 1]` : - 0 correspond à un jeton de *phrase A*, - 1 correspond à un jeton de *phrase B*. [Que sont les identifiants de type de jeton ?](../glossary#token-type-ids) position_ids (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle `[0, config.n_positions - 1]`. [Que sont les position IDs ?](../glossary#position-ids) inputs_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer `input_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 indices `input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle. start_positions (`torch.Tensor` de forme `(batch_size,)`, *facultatif*) : Étiquettes pour la position (index) du début de l'intervalle étiqueté, utilisées pour le calcul de la perte de classification de jetons. Les positions sont limité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.Tensor` de 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 limité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. output_attentions (`bool`, *facultatif*) : Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Voir `attentions` sous les tenseurs retournés pour plus de détails. output_hidden_states (`bool`, *facultatif*) : Indique s'il faut retourner les états cachés de toutes les couches. Voir `hidden_states` dans les tenseurs retournés pour plus de détails. return_dict (`bool`, *facultatif*) : Indique s'il faut retourner un [ModelOutput](/docs/transformers/main/fr/main_classes/output#transformers.utils.ModelOutput) plutôt qu'un simple tuple. **Retourne :** [LongformerQuestionAnsweringModelOutput](/docs/transformers/main/fr/model_doc/longformer#transformers.models.longformer.modeling_longformer.LongformerQuestionAnsweringModelOutput) ou `tuple(torch.Tensor)` Un [LongformerQuestionAnsweringModelOutput](/docs/transformers/main/fr/model_doc/longformer#transformers.models.longformer.modeling_longformer.LongformerQuestionAnsweringModelOutput) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([LongformerConfig](/docs/transformers/main/fr/model_doc/longformer#transformers.LongformerConfig)) et les entrées. La méthode forward de [LongformerForQuestionAnswering](/docs/transformers/main/fr/model_doc/longformer#transformers.LongformerForQuestionAnswering) 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 `Module` plutô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.Tensor` de forme `(1,)`, *facultatif*, renvoyé lorsque `labels` est fourni) -- La perte totale d'extraction de spans est la somme d'une entropie croisée pour les positions de début et de fin. - **start_logits** (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) -- Scores de début de segment (avant SoftMax). - **end_logits** (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) -- Scores de fin de segment (avant SoftMax). - **hidden_states** (`tuple[torch.Tensor, ...]`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (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.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, x + attention_window + 1)`, où `x` est le nombre de jetons avec un masque d'attention global. Poids d'attention locaux après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention. Il s'agit des poids d'attention de chaque jeton de la séquence vers chaque jeton avec attention globale (les `x` premières valeurs) et vers chaque jeton de la fenêtre d'attention (les valeurs restantes `attention_window + 1` values). Note that the first `x` values refer to tokens with fixed positions in the text, but the remaining `attention_window + 1` values refer to tokens with relative positions: the attention weight of a token to itself is located at index `x + attention_window / 2` and the `attention_window / 2` preceding (succeeding) values are the attention weights to the `attention_window / 2` preceding (succeeding) tokens. If the attention window contains a token with global attention, the attention weight at the corresponding index is set to 0; the value should be accessed from the first `x` attention weights. If a token has global attention, the attention weights to all other tokens in `attentions` is set to 0, the values should be accessed from `global_attentions`. - **global_attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, x)`, où `x` est le nombre de jetons avec un masque d'attention globale. Poids d'attention globaux après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention. Il s'agit des poids d'attention de chaque token doté d'une attention globale vers chaque token de la séquence. Exemples : ```python >>> from transformers import AutoTokenizer, LongformerForQuestionAnswering >>> import torch >>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-large-4096-finetuned-triviaqa") >>> model = LongformerForQuestionAnswering.from_pretrained("allenai/longformer-large-4096-finetuned-triviaqa") >>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet" >>> encoding = tokenizer(question, text, return_tensors="pt") >>> input_ids = encoding["input_ids"] >>> # default is local attention everywhere >>> # the forward method will automatically set global attention on question tokens >>> attention_mask = encoding["attention_mask"] >>> outputs = model(input_ids, attention_mask=attention_mask) >>> start_logits = outputs.start_logits >>> end_logits = outputs.end_logits >>> all_tokens = tokenizer.convert_ids_to_tokens(input_ids[0].tolist()) >>> answer_tokens = all_tokens[torch.argmax(start_logits) : torch.argmax(end_logits) + 1] >>> answer = tokenizer.decode( ... tokenizer.convert_tokens_to_ids(answer_tokens) ... ) # remove space prepending space token ```