Transformers documentation
LUKE
Ce modèle a été publié dans HF papers le 2020-10-02 et ajouté à Hugging Face Transformers le 2021-05-03.
LUKE
Aperçu
Le modèle LUKE a été proposé dans LUKE: Deep Contextualized Entity Representations with Entity-aware Self-attention par Ikuya Yamada, Akari Asai, Hiroyuki Shindo, Hideaki Takeda et Yuji Matsumoto. Il est basé sur RoBERTa et ajoute des embeddings d'entités ainsi qu'un mécanisme d'auto-attention prenant en compte les entités, ce qui aide à améliorer les performances sur diverses tâches en aval impliquant le raisonnement sur des entités, telles que la reconnaissance d'entités nommées, la réponse à des questions extractives et de type cloze, le typage d'entités et la classification de relations.
L'abstract de l'article est le suivant :
Les représentations d’entités sont utiles dans les tâches de traitement du langage naturel impliquant des entités. Dans cet article, nous proposons de nouvelles représentations contextuelles pré-entraînées de mots et d’entités basées sur le transformeur bidirectionnel. Le modèle proposé traite les mots et les entités d’un texte donné comme des jetons indépendants et produit des représentations contextuelles de ceux-ci. Notre modèle est entraîné à l’aide d’une nouvelle tâche de pré-entraînement basée sur le modèle de langage masqué de BERT. Cette tâche consiste à prédire des mots et des entités masqués aléatoirement dans un large corpus annoté d’entités extrait de Wikipédia. Nous proposons également un mécanisme d’auto-attention prenant en compte les entités, qui est une extension du mécanisme d’auto-attention du transformeur et qui tient compte des types de jetons (mots ou entités) lors du calcul des scores d’attention. Le modèle proposé atteint des performances empiriques impressionnantes sur une large gamme de tâches liées aux entités. En particulier, il obtient des résultats de l’état de l’art sur cinq jeux de données bien connus : Open Entity (typage d’entités), TACRED (classification de relations), CoNLL-2003 (reconnaissance d’entités nommées), ReCoRD (réponses à des questions de type cloze) et SQuAD 1.1 (réponses à des questions extractives).
Ce modèle a été contribué par ikuyamada et nielsr. Le code d'origine peut être trouvé ici.
Conseils d'utilisation
Cette implémentation est identique à RobertaModel, avec l’ajout d’embeddings d’entités ainsi que d’un mécanisme d’auto-attention prenant en compte les entités, ce qui améliore les performances sur les tâches impliquant un raisonnement sur les entités.
LUKE traite les entités comme des jetons d'entrée ; il prend donc
entity_ids,entity_attention_mask,entity_token_type_idsetentity_position_idsen entrée supplémentaire. Vous pouvez les obtenir à l'aide de LukeTokenizer.LukeTokenizer prend en entrée supplémentaire
entitiesetentity_spans(positions de début et de fin basées sur les caractères des entités dans le texte d'entrée).entitiesconsiste généralement en des entités [MASK] ou des entités Wikipédia. La brève description lors de la saisie de ces entités est la suivante :- Saisir des entités [MASK] pour calculer les représentations d'entités : l'entité [MASK] est utilisée pour masquer les entités à prédire lors de la préformation. Lorsque LUKE reçoit l'entité [MASK], il tente de prédire l'entité d'origine en collectant les informations sur l'entité à partir du texte d'entrée. Par conséquent, l'entité [MASK] peut être utilisée pour traiter des tâches en aval nécessitant les informations sur les entités dans le texte, telles que le typage d'entités, la classification de relations et la reconnaissance d'entités nommées.
- Saisir des entités Wikipédia pour calculer des représentations de jetons enrichies par la connaissance : LUKE apprend des informations riches (ou des connaissances) sur les entités Wikipédia lors de la préformation et stocke ces informations dans son plongement d'entité. En utilisant les entités Wikipédia comme jetons d'entrée, LUKE produit des représentations de jetons enrichies par les informations stockées dans les plongements de ces entités. Cela est particulièrement efficace pour les tâches nécessitant des connaissances du monde réel, telles que la réponse aux questions.
Il existe trois modèles de tête pour l'ancien cas d'utilisation :
- LukeForEntityClassification, pour les tâches de classification d’une entité unique dans un texte d’entrée, telles que le typage d’entités, par exemple le Open Entity dataset. Ce modèle place une tête linéaire au-dessus de la représentation de l’entité en sortie.
- LukeForEntityPairClassification, pour les tâches de classification de la relation entre deux entités, telles que la classification de relations, par exemple sur le jeu de données TACRED. Ce modèle place une tête linéaire sur la représentation de sortie concaténée de la paire d’entités données.
- LukeForEntitySpanClassification, pour les tâches de classification de séquences d’entités, telles que la reconnaissance d’entités nommées (NER). Ce modèle place une tête linéaire au-dessus des représentations d’entités en sortie. Vous pouvez traiter le NER avec ce modèle en fournissant au modèle toutes les entités possibles présentes dans le texte.
LukeTokenizer possède un argument
taskqui vous permet de créer facilement une entrée pour ces modèles de tête en spécifianttask="entity_classification",task="entity_pair_classification"outask="entity_span_classification". Veuillez consulter le code d'exemple de chaque modèle de tête.
Exemple d'utilisation :
from transformers import LukeForEntityPairClassification, LukeModel, LukeTokenizer
model = LukeModel.from_pretrained("studio-ousia/luke-base", device_map="auto")
tokenizer = LukeTokenizer.from_pretrained("studio-ousia/luke-base")
# Example 1: Computing the contextualized entity representation corresponding to the entity mention "Beyoncé"
text = "Beyoncé lives in Los Angeles."
entity_spans = [(0, 7)] # character-based entity span corresponding to "Beyoncé"
inputs = tokenizer(text, entity_spans=entity_spans, add_prefix_space=True, return_tensors="pt").to(model.device)
outputs = model(**inputs)
word_last_hidden_state = outputs.last_hidden_state
entity_last_hidden_state = outputs.entity_last_hidden_state
# Example 2: Inputting Wikipedia entities to obtain enriched contextualized representations
entities = [
"Beyoncé",
"Los Angeles",
] # Wikipedia entity titles corresponding to the entity mentions "Beyoncé" and "Los Angeles"
entity_spans = [(0, 7), (17, 28)] # character-based entity spans corresponding to "Beyoncé" and "Los Angeles"
inputs = tokenizer(text, entities=entities, entity_spans=entity_spans, add_prefix_space=True, return_tensors="pt").to(model.device)
outputs = model(**inputs)
word_last_hidden_state = outputs.last_hidden_state
entity_last_hidden_state = outputs.entity_last_hidden_state
# Example 3: Classifying the relationship between two entities using LukeForEntityPairClassification head model
model = LukeForEntityPairClassification.from_pretrained("studio-ousia/luke-large-finetuned-tacred", device_map="auto")
tokenizer = LukeTokenizer.from_pretrained("studio-ousia/luke-large-finetuned-tacred")
entity_spans = [(0, 7), (17, 28)] # character-based entity spans corresponding to "Beyoncé" and "Los Angeles"
inputs = tokenizer(text, entity_spans=entity_spans, return_tensors="pt").to(model.device)
outputs = model(**inputs)
logits = outputs.logits
predicted_class_idx = int(logits[0].argmax())
print("Predicted class:", model.config.id2label[predicted_class_idx])Ressources
- Un notebook de démonstration sur la façon d’affiner [LukeForEntityPairClassification](/docs/transformers/main/en/model_doc/luke#transformers.LukeForEntityPairClassification) pour la classification de relations
- Notebooks illustrant la reproduction des résultats rapportés dans l'article avec l'implémentation HuggingFace de LUKE
- Guide de la tâche de classification de texte
- Guide de la tâche de classification de jetons
- Guide de la tâche de réponse aux questions
- Guide de la tâche de modélisation de langage masqué
- Guide de la tâche de choix multiples
LukeConfig
classe transformers.LukeConfig
< source >( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonevocab_size: int = 50267entity_vocab_size: int = 500000hidden_size: int = 768entity_emb_size: int = 256num_hidden_layers: int = 12num_attention_heads: int = 12intermediate_size: int = 3072hidden_act: str = 'gelu'hidden_dropout_prob: float | int = 0.1attention_probs_dropout_prob: float | int = 0.1max_position_embeddings: int = 512type_vocab_size: int = 2initializer_range: float = 0.02layer_norm_eps: float = 1e-12use_entity_aware_attention: bool = Trueclassifier_dropout: float | int | None = Nonepad_token_id: int | None = 1bos_token_id: int | None = 0eos_token_id: int | list[int] | None = 2tie_word_embeddings: bool = True )
Paramètres
- vocab_size (
int, facultatif, par défaut50267) — Taille du vocabulaire du modèle. Définit le nombre de jetons différents qui peuvent être représentés parinput_ids. - entity_vocab_size (
int, facultatif, par défaut 500000) — Taille du vocabulaire des entités du modèle LUKE. Définit le nombre d'entités différentes qui peuvent être représentées par lesentity_idspassées lors de l'appel de LukeModel. - hidden_size (
int, facultatif, par défaut768) — Dimension des représentations cachées. - entity_emb_size (
int, facultatif, valeur par défaut 256) — Le nombre de dimensions de l'embedding d'entité. - num_hidden_layers (
int, facultatif, par défaut12) — Nombre de couches cachées dans le décodeur Transformer. - num_attention_heads (
int, facultatif, valeur par défaut12) — Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer. - intermediate_size (
int, facultatif, par défaut3072) — Dimension des représentations du MLP. - hidden_act (
str, facultatif, par défautgelu) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) du décodeur. Par exemple,"gelu","relu","silu", etc. - hidden_dropout_prob (
Union[float, int], facultatif, par défaut0.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, par défaut0.1) — Le taux de dropout appliqué aux probabilités d'attention. - max_position_embeddings (
int, facultatif, par défaut512) — La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé. - type_vocab_size (
int, facultatif, par défaut2) — La taille du vocabulaire destoken_type_ids. - initializer_range (
float, facultatif, par défaut0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids. - layer_norm_eps (
float, facultatif, valeur par défaut1e-12) — L'épsilon utilisé par les couches de normalisation de couche. - use_entity_aware_attention (
bool, facultatif, valeur par défautTrue) — Indique si le modèle doit utiliser le mécanisme d'auto-attention conscient des entités proposé dans LUKE: Deep Contextualized Entity Representations with Entity-aware Self-attention (Yamada et al.). - classifier_dropout (
Union[float, int], facultatif) — Le taux de dropout pour le classifieur. - pad_token_id (
int, facultatif, par défaut1) — Identifiant du jeton utilisé pour le bourrage dans le vocabulaire. - bos_token_id (
int, facultatif, par défaut0) — Identifiant du jeton utilisé pour le début de flux dans le vocabulaire. - eos_token_id (
Union[int, list[int]], facultatif, par défaut2) — Identifiant du jeton utilisé pour la fin de flux dans le vocabulaire. - tie_word_embeddings (
bool, facultatif, par défautTrue) — Indique s'il faut lier les embeddings de poids selon la correspondancetied_weights_keysdu modèle.
Ceci est la classe de configuration destinée à stocker la configuration d'un LukeModel. Elle est utilisée pour instancier un modèle Luke en fonction des arguments spécifiés, définissant ainsi l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de studio-ousia/luke-base
Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.
LukeTokenizer
classe transformers.LukeTokenizer
< source >( vocab: str | dict[str, int] | None = Nonemerges: str | list[str] | None = Noneentity_vocab: str | dict | list | None = Noneerrors = 'replace'bos_token = '<s>'eos_token = '</s>'sep_token = '</s>'cls_token = '<s>'unk_token = '<unk>'pad_token = '<pad>'mask_token = '<mask>'add_prefix_space = Falsetask = Nonemax_entity_length = 32max_mention_length = 30entity_1_token = '<ent>'entity_2_token = '<ent2>'entity_unk_token = '[UNK]'entity_pad_token = '[PAD]'entity_mask_token = '[MASK]'entity_mask2_token = '[MASK2]'**kwargs )
Paramètres
- vocab_file (
str) — Chemin vers le fichier de vocabulaire. - merges_file (
str) — Chemin vers le fichier de fusions. - vocab (
stroudict[str, int], facultatif) — Dictionnaire de vocabulaire personnalisé. S'il n'est pas fourni, le vocabulaire est chargé depuisvocab_file. - merges (
stroulist[str], facultatif) — Liste de fusions personnalisée. Si non fournie, les fusions sont chargées depuismerges_file. - entity_vocab_file (
str) — Chemin vers le fichier de vocabulaire des entités. - task (
str, facultatif) — Tâche pour laquelle vous souhaitez préparer les séquences. L’une des valeurs"entity_classification","entity_pair_classification"ou"entity_span_classification". Si vous spécifiez cet argument, la séquence d’entités est automatiquement créée à partir de l’entité ou des entités fournies. - max_entity_length (
int, facultatif, valeur par défaut 32) — La longueur maximale deentity_ids. - max_mention_length (
int, facultatif, valeur par défaut 30) — Le nombre maximal de jetons à l'intérieur d'une entité. - entity_1_token (
str, facultatif, par défaut<ent>) — Le jeton spécial utilisé pour représenter une entité dans une séquence de jetons de mots. Ce jeton n’est utilisé que lorsquetaskest défini sur"entity_classification"ou"entity_pair_classification". - entity_2_token (
str, facultatif, par défaut<ent2>) — Le jeton spécial utilisé pour représenter une entité dans une séquence de jetons de mots. Ce jeton n’est utilisé que lorsquetaskest défini sur"entity_pair_classification". - errors (
str, facultatif, par défaut"replace") — Paradigme à suivre lors du décodage des octets en UTF-8. Voir bytes.decode pour plus d'informations. - bos_token (
str, facultatif, défaut"<s>") — Le 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 ce jeton qui est utilisé pour le début de la séquence. Le jeton utilisé est
cls_token. - eos_token (
str, facultatif, défaut :"</s>") — Le 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 sep_token.Lors de la construction d'une séquence à l'aide de jetons spéciaux, ce n'est pas ce jeton qui est utilisé pour la fin de séquence. Le jeton utilisé est le
sep_token. - sep_token (
str, facultatif, par défaut"</s>") — 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, par défaut"<s>") — Le jeton de classification 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"<unk>") — 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"<pad>") — Le jeton utilisé pour le bourrage, par exemple lors du regroupement de séquences de longueurs différentes. - mask_token (
str, facultatif, par défaut"<mask>") — 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, valeur par défautFalse) — 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 LUKE détecte le début des mots par l'espace qui les précède).
Construit un tokeniseur LUKE, dérivé du tokeniseur GPT-2, en utilisant l'encodage par paires de bytes au niveau des octets.
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 :
>>> from transformers import LukeTokenizer
>>> tokenizer = LukeTokenizer.from_pretrained("studio-ousia/luke-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 tokeniseur ajoute un espace avant chaque mot (y compris le premier).
Ce tokenizer hérite de PreTrainedTokenizer, qui contient la plupart des méthodes principales. Les utilisateurs doivent se référer à cette superclasse pour plus d'informations sur ces méthodes. Il crée également des séquences d'entités, à savoir entity_ids, entity_attention_mask, entity_token_type_ids et entity_position_ids, à utiliser par le modèle LUKE.
__call__
< source >( text: str | list[str]text_pair: str | list[str] | None = Noneentity_spans: list[tuple[int, int]] | list[list[tuple[int, int]]] | None = Noneentity_spans_pair: list[tuple[int, int]] | list[list[tuple[int, int]]] | None = Noneentities: list[str] | list[list[str]] | None = Noneentities_pair: list[str] | list[list[str]] | None = Noneadd_special_tokens: bool = Truepadding: bool | str | transformers.utils.generic.PaddingStrategy = Falsetruncation: bool | str | transformers.tokenization_utils_base.TruncationStrategy | None = Nonemax_length: int | None = Nonemax_entity_length: int | None = Nonestride: int = 0is_split_into_words: bool | None = Falsepad_to_multiple_of: int | None = Nonepadding_side: str | None = Nonereturn_tensors: str | transformers.utils.generic.TensorType | None = Nonereturn_token_type_ids: bool | None = Nonereturn_attention_mask: bool | None = Nonereturn_overflowing_tokens: bool = Falsereturn_special_tokens_mask: bool = Falsereturn_offsets_mapping: bool = Falsereturn_length: bool = Falseverbose: bool = True**kwargs ) → BatchEncoding
Retourne
Un BatchEncoding avec les champs suivants :
-
input_ids — Liste des identifiants de jetons à fournir à un modèle.
-
token_type_ids — Liste des identifiants de type de jeton à fournir à un modèle (lorsque
return_token_type_ids=Trueou si “token_type_ids” est présent dansself.model_input_names). -
attention_mask — Liste d’indices spécifiant les jetons auxquels le modèle doit prêter attention (lorsque
return_attention_mask=Trueou si “attention_mask” est présent dansself.model_input_names). -
entity_ids — Liste des identifiants d'entités à fournir à un modèle.
-
entity_position_ids — Liste des positions des entités dans la séquence d'entrée à fournir au modèle.
-
entity_token_type_ids — Liste des identifiants de type d’entité des jetons à fournir au modèle (lorsque
return_token_type_ids=Trueou si “entity_token_type_ids” est présent dansself.model_input_names). -
entity_attention_mask — Liste d’indices spécifiant les entités auxquelles le modèle doit prêter attention (lorsque
return_attention_mask=Trueou si “entity_attention_mask” est présent dansself.model_input_names). -
entity_start_positions — Liste des positions de début des entités dans la séquence de jetons de mots (lorsque
task="entity_span_classification"). -
entity_end_positions — Liste des positions de fin des entités dans la séquence de jetons de mots (lorsque
task="entity_span_classification"). -
overflowing_tokens — Liste des séquences de jetons en dépassement (lorsqu'une
max_lengthest spécifiée etreturn_overflowing_tokens=True). -
num_truncated_tokens — Nombre de jetons tronqués (lorsqu'une
max_lengthest spécifiée etreturn_overflowing_tokens=True). -
special_tokens_mask — Liste de 0 et de 1, où 1 indique les jetons spéciaux ajoutés et 0 indique les jetons de séquence réguliers (lorsque
add_special_tokens=Trueetreturn_special_tokens_mask=True). -
length — La longueur des entrées (lorsque
return_length=True)
add_special_tokens (bool, facultatif, par défaut True) :
Indique s'il faut ajouter des jetons spéciaux lors de l'encodage des séquences. Cela utilise la fonction sous-jacente PretrainedTokenizerBase.build_inputs_with_special_tokens, qui définit les jetons ajoutés automatiquement aux identifiants d'entrée. C'est utile si vous souhaitez ajouter automatiquement des jetons bos ou eos.
padding (bool, str ou PaddingStrategy, facultatif, par défaut False) :
Active et contrôle le bourrage. Accepte les valeurs suivantes :
Trueou'longest': Ajuster à la séquence la plus longue du lot (ou aucun ajustement si une seule séquence est fournie).'max_length': Remplir jusqu'à une longueur maximale spécifiée par l'argumentmax_lengthou jusqu'à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni.Falseou'do_not_pad'(par défaut) : aucun bourrage (c.-à-d. peut produire un lot avec des séquences de longueurs différentes). truncation (bool,strou TruncationStrategy, facultatif, par défautFalse) : Active et contrôle la troncature. Accepte les valeurs suivantes :Trueou'longest_first': Tronquer à une longueur maximale spécifiée avec l’argumentmax_lengthou à la longueur d’entrée maximale acceptable pour le modèle si cet argument n’est pas fourni. Cela tronquera jeton par jeton, en retirant un jeton de la séquence la plus longue du couple si un couple de séquences (ou un lot de couples) est fourni.'only_first': Tronque à une longueur maximale spécifiée avec l'argumentmax_lengthou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. Cela ne tronquera que la première séquence d'une paire si une paire de séquences (ou un lot de paires) est fournie.'only_second': Tronque à une longueur maximale spécifiée avec l'argumentmax_lengthou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. Cela ne tronquera que la deuxième séquence d'une paire si une paire de séquences (ou un lot de paires) est fournie.Falseou'do_not_truncate'(par défaut) : aucune troncature (c’est-à-dire, peut produire un lot avec des longueurs de séquences supérieures à la taille d’entrée maximale admissible par le modèle). max_length (int, facultatif) : Contrôle la longueur maximale à utiliser par l’un des paramètres de troncature/remplissage.
Si non défini ou défini sur None, la longueur maximale prédéfinie du modèle sera utilisée si l'une des paramètres de troncature/remplissage en exige une. Si le modèle n'a pas de longueur d'entrée maximale spécifique (comme XLNet), la troncature/le remplissage à une longueur maximale sera désactivé.
stride (int, facultatif, valeur par défaut 0) :
Si défini sur un nombre avec max_length, les jetons en dépassement renvoyés lorsque return_overflowing_tokens=True contiendront certains jetons de la fin de la séquence tronquée renvoyée afin de fournir un chevauchement entre les séquences tronquées et en dépassement. La valeur de cet argument définit le nombre de jetons en chevauchement.
is_split_into_words (bool, facultatif, valeur par défaut False) :
Indique si l'entrée est déjà pré-tokenisée (par exemple, découpée en mots). Si défini sur True, le tokeniseur suppose que l'entrée est déjà découpée en mots (par exemple, en la séparant sur les espaces) qu'il tokenisera. Cela est utile pour la NER ou la classification de jetons.
pad_to_multiple_of (int, facultatif) :
Si défini, remplit la séquence jusqu'à un multiple de la valeur fournie. Nécessite l'activation de padding.
Cela est particulièrement utile pour permettre l'utilisation des Tensor Cores sur le matériel NVIDIA avec une capacité de calcul >= 7.5 (Volta).
padding_side (str, facultatif) :
Le côté sur lequel le modèle doit avoir le remplissage appliqué. Doit être sélectionné entre ['right', 'left'].
La valeur par défaut est choisie à partir de l'attribut de classe du même nom.
return_tensors (str ou TensorType, facultatif) :
Si défini, renvoie des tenseurs au lieu d'une liste d'entiers python. Les valeurs acceptables sont :
'pt': Renvoie des objetstorch.Tensorde PyTorch.'np': Renvoie des objets Numpynp.ndarray.
return_token_type_ids (bool, facultatif) :
Indique s'il faut retourner les identifiants de type de jeton. Si la valeur par défaut est conservée, les identifiants de type de jeton seront retournés selon la valeur par défaut du tokeniseur spécifique, définie par l'attribut return_outputs.
Qu’est-ce que les identifiants de type de jeton ? return_attention_mask (bool, facultatif) :
Indique s’il faut retourner le masque d’attention. Si la valeur par défaut est conservée, le masque d’attention est retourné selon la valeur par défaut du tokeniseur spécifique, définie par l’attribut return_outputs.
Qu'est-ce que les masques d'attention ? return_overflowing_tokens (bool, facultatif, par défaut False) :
Indique s'il faut ou non renvoyer les séquences de jetons en dépassement. Si une paire de séquences d'identifiants d'entrée (ou un lot de paires) est fournie avec truncation_strategy = longest_first ou True, une erreur est levée au lieu de renvoyer les jetons en dépassement.
return_special_tokens_mask (bool, facultatif, par défaut False) :
Indique s'il faut ou non renvoyer les informations du masque des jetons spéciaux.
return_offsets_mapping (bool, facultatif, par défaut False) :
Indique s'il faut ou non renvoyer (char_start, char_end) pour chaque jeton.
Ceci n’est disponible que sur les tokenizers rapides héritant de PreTrainedTokenizerFast ; si vous utilisez le tokenizer Python, cette méthode lève NotImplementedError.
return_length (bool, facultatif, par défaut False) :
Indique s’il faut ou non retourner les longueurs des entrées encodées.
verbose (bool, facultatif, par défaut True) :
Indique s’il faut ou non afficher plus d’informations et d’avertissements.
**kwargs : transmis à la méthode self.tokenize()
LukeModel
classe transformers.LukeModel
< source >( config: LukeConfigadd_pooling_layer: bool = True )
Paramètres
- config (LukeConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.
- add_pooling_layer (
bool, facultatif, par défautTrue) — Indique s'il faut ajouter une couche de pooling
La sortie du transformateur du modèle LUKE brut, produisant des états cachés bruts pour les jetons de mots et les entités, sans
Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)
Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneentity_ids: typing.Optional[torch.LongTensor] = Noneentity_attention_mask: typing.Optional[torch.Tensor] = Noneentity_token_type_ids: typing.Optional[torch.LongTensor] = Noneentity_position_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → BaseLukeModelOutputWithPooling or tuple(torch.Tensor)
Paramètres
- input_ids (
torch.LongTensorde 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. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
- attention_mask (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans[0, 1]:- 1 pour les jetons qui ne sont pas masqués,
- 0 pour les jetons masqués.
- token_type_ids (
torch.LongTensorde forme(batch_size, sequence_length), facultatif) — Indices de jetons de segment pour indiquer les première et deuxième parties des entrées. Les indices sont choisis dans[0, 1]:- 0 correspond à un jeton sentence A,
- 1 correspond à un jeton sentence B.
- position_ids (
torch.LongTensorde 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]. - entity_ids (
torch.LongTensorde forme(batch_size, entity_length)) — Indices des jetons d'entité dans le vocabulaire des entités.Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
- entity_attention_mask (
torch.Tensorde forme(batch_size, entity_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices de jetons d'entité de bourrage. Les valeurs du masque sont choisies dans[0, 1]:- 1 pour les jetons d'entités qui ne sont pas masqués,
- 0 pour les jetons d'entités qui sont masqués.
- entity_token_type_ids (
torch.LongTensorde forme(batch_size, entity_length), facultatif) — Indices de jetons de segment pour indiquer les parties première et seconde des entrées de jetons d'entité. Les indices sont sélectionnés dans[0, 1]:- 0 correspond à un jeton d'entité de portion A,
- 1 correspond à un jeton d'entité de portion B.
- entity_position_ids (
torch.LongTensorde forme(batch_size, entity_length, max_mention_length), facultatif) — Indices des positions de chaque entité d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle[0, config.max_position_embeddings - 1]. - inputs_embeds (
torch.Tensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerinput_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indicesinput_idsen vecteurs associés que la matrice de recherche d’intégration interne du modèle. - output_attentions (
bool, facultatif) — Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Consultezattentionssous 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. Voirhidden_statessous les tenseurs retournés pour plus de détails. - return_dict (
bool, facultatif) — Indique s'il faut retourner un ModelOutput plutôt qu'un simple tuple.
Retourne
BaseLukeModelOutputWithPooling ou tuple(torch.Tensor)
Un BaseLukeModelOutputWithPooling ou un tuple de
torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (LukeConfig) et des entrées.
La méthode forward du modèle LukeModel redéfinit la méthode spéciale __call__.
Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance
Moduleplutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.
last_hidden_state (
torch.Tensorde 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.Tensorde 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.hidden_states (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.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é lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
entity_last_hidden_state (
torch.Tensorde forme(batch_size, entity_length, hidden_size)) — Séquence des états cachés des entités à la sortie de la dernière couche du modèle.entity_hidden_states (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings + un pour la sortie de chaque couche) de forme(batch_size, entity_length, hidden_size). États cachés des entités du modèle à la sortie de chaque couche, ainsi que les sorties des embeddings d'entités initiaux.
Exemples :
>>> from transformers import AutoTokenizer, LukeModel
>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-base")
>>> model = LukeModel.from_pretrained("studio-ousia/luke-base")
# Compute the contextualized entity representation corresponding to the entity mention "Beyoncé"
>>> text = "Beyoncé lives in Los Angeles."
>>> entity_spans = [(0, 7)] # character-based entity span corresponding to "Beyoncé"
>>> encoding = tokenizer(text, entity_spans=entity_spans, add_prefix_space=True, return_tensors="pt")
>>> outputs = model(**encoding)
>>> word_last_hidden_state = outputs.last_hidden_state
>>> entity_last_hidden_state = outputs.entity_last_hidden_state
# Input Wikipedia entities to obtain enriched contextualized representations of word tokens
>>> text = "Beyoncé lives in Los Angeles."
>>> entities = [
... "Beyoncé",
... "Los Angeles",
... ] # Wikipedia entity titles corresponding to the entity mentions "Beyoncé" and "Los Angeles"
>>> entity_spans = [
... (0, 7),
... (17, 28),
... ] # character-based entity spans corresponding to "Beyoncé" and "Los Angeles"
>>> encoding = tokenizer(
... text, entities=entities, entity_spans=entity_spans, add_prefix_space=True, return_tensors="pt"
... )
>>> outputs = model(**encoding)
>>> word_last_hidden_state = outputs.last_hidden_state
>>> entity_last_hidden_state = outputs.entity_last_hidden_stateLukeForMaskedLM
classe transformers.LukeForMaskedLM
< source >( config: LukeConfig )
Paramètres
- config (LukeConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.
Le modèle LUKE avec une tête de modélisation du langage et une tête de prédiction d'entités au sommet pour la modélisation du langage masquée et la prédiction d'entités masquées.
Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)
Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneentity_ids: typing.Optional[torch.LongTensor] = Noneentity_attention_mask: typing.Optional[torch.LongTensor] = Noneentity_token_type_ids: typing.Optional[torch.LongTensor] = Noneentity_position_ids: typing.Optional[torch.LongTensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneentity_labels: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → LukeMaskedLMOutput or tuple(torch.Tensor)
Paramètres
- input_ids (
torch.LongTensorde 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. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
- attention_mask (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans[0, 1]:- 1 pour les jetons qui ne sont pas masqués,
- 0 pour les jetons masqués.
- token_type_ids (
torch.LongTensorde forme(batch_size, sequence_length), facultatif) — Indices de jetons de segment pour indiquer les première et deuxième parties des entrées. Les indices sont choisis dans[0, 1]:- 0 correspond à un jeton sentence A,
- 1 correspond à un jeton sentence B.
- position_ids (
torch.LongTensorde 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]. - entity_ids (
torch.LongTensorde forme(batch_size, entity_length)) — Indices des jetons d'entité dans le vocabulaire des entités.Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
- entity_attention_mask (
torch.Tensorde forme(batch_size, entity_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices de jetons d'entité de bourrage. Les valeurs du masque sont choisies dans[0, 1]:- 1 pour les jetons d'entités qui ne sont pas masqués,
- 0 pour les jetons d'entités qui sont masqués.
- entity_token_type_ids (
torch.LongTensorde forme(batch_size, entity_length), facultatif) — Indices de jetons de segment pour indiquer les parties première et seconde des entrées de jetons d'entité. Les indices sont sélectionnés dans[0, 1]:- 0 correspond à un jeton d'entité de portion A,
- 1 correspond à un jeton d'entité de portion B.
- entity_position_ids (
torch.LongTensorde forme(batch_size, entity_length, max_mention_length), facultatif) — Indices des positions de chaque entité d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle[0, config.max_position_embeddings - 1]. - labels (
torch.LongTensorde 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 deinput_ids). Les jetons dont l'indice est défini sur-100sont ignorés (masqués) ; la perte n'est calculée que pour les jetons dont l'étiquette est dans[0, ..., config.vocab_size]. - entity_labels (
torch.LongTensorde forme(batch_size, entity_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 deinput_ids). Les jetons dont l'indice est défini sur-100sont ignorés (masqués) ; la perte n'est calculée que pour les jetons dont l'étiquette est dans[0, ..., config.vocab_size]. - inputs_embeds (
torch.Tensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerinput_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indicesinput_idsen vecteurs associés que la matrice de recherche d’intégration interne du modèle. - output_attentions (
bool, facultatif) — Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Consultezattentionssous 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. Voirhidden_statessous les tenseurs retournés pour plus de détails. - return_dict (
bool, facultatif) — Indique s'il faut retourner un ModelOutput plutôt qu'un simple tuple.
Retourne
LukeMaskedLMOutput ou tuple(torch.Tensor)
Un LukeMaskedLMOutput ou un tuple de
torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (LukeConfig) et des entrées.
La méthode forward de LukeForMaskedLM redéfinit la méthode spéciale __call__.
Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance
Moduleplutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.
loss (
torch.Tensorde forme(1,), facultatif, renvoyé lorsquelabelsest fourni) — La somme de la perte de modélisation de langage masquée (MLM) et de la perte de prédiction d'entités.mlm_loss (
torch.Tensorde forme(1,), facultatif, renvoyé lorsquelabelsest fourni) — Perte de modélisation de langage masquée (MLM).mep_loss (
torch.Tensorde forme(1,), facultatif, renvoyé lorsquelabelsest fourni) — Perte de prédiction d'entités masquées (MEP).logits (
torch.Tensorde 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).entity_logits (
torch.Tensorde forme(batch_size, sequence_length, config.vocab_size)) — Scores de prédiction de la tête de prédiction d'entités (scores pour chaque jeton du vocabulaire des entités avant SoftMax).hidden_states (
tuple[torch.Tensor], facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.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.
entity_hidden_states (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings + un pour la sortie de chaque couche) de forme(batch_size, entity_length, hidden_size). États cachés des entités du modèle à la sortie de chaque couche, ainsi que les sorties des embeddings d'entités initiaux.attentions (
tuple[torch.Tensor, ...], facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
Exemple :
>>> from transformers import AutoTokenizer, LukeForMaskedLM
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-base")
>>> model = LukeForMaskedLM.from_pretrained("studio-ousia/luke-base")
>>> inputs = tokenizer("The capital of France is <mask>.", return_tensors="pt")
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> # retrieve index of <mask>
>>> mask_token_index = (inputs.input_ids == tokenizer.mask_token_id)[0].nonzero(as_tuple=True)[0]
>>> predicted_token_id = logits[0, mask_token_index].argmax(axis=-1)
>>> tokenizer.decode(predicted_token_id)
...
>>> labels = tokenizer("The capital of France is Paris.", return_tensors="pt")["input_ids"]
>>> # mask labels of non-<mask> tokens
>>> labels = torch.where(inputs.input_ids == tokenizer.mask_token_id, labels, -100)
>>> outputs = model(**inputs, labels=labels)
>>> round(outputs.loss.item(), 2)
...LukeForEntityClassification
classe transformers.LukeForEntityClassification
< source >( config: LukeConfig )
Paramètres
- config (LukeConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.
Le modèle LUKE avec une tête de classification au sommet (une couche linéaire au sommet de l'état caché du premier jeton d'entité) pour les tâches de classification d'entités, telles qu'Open Entity.
Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)
Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneentity_ids: typing.Optional[torch.LongTensor] = Noneentity_attention_mask: typing.Optional[torch.Tensor] = Noneentity_token_type_ids: typing.Optional[torch.LongTensor] = Noneentity_position_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → EntityClassificationOutput or tuple(torch.Tensor)
Paramètres
- input_ids (
torch.LongTensorde 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. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
- attention_mask (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans[0, 1]:- 1 pour les jetons qui ne sont pas masqués,
- 0 pour les jetons masqués.
- token_type_ids (
torch.LongTensorde forme(batch_size, sequence_length), facultatif) — Indices de jetons de segment pour indiquer les première et deuxième parties des entrées. Les indices sont choisis dans[0, 1]:- 0 correspond à un jeton sentence A,
- 1 correspond à un jeton sentence B.
- position_ids (
torch.LongTensorde 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]. - entity_ids (
torch.LongTensorde forme(batch_size, entity_length)) — Indices des jetons d'entité dans le vocabulaire des entités.Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
- entity_attention_mask (
torch.Tensorde forme(batch_size, entity_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices de jetons d'entité de bourrage. Les valeurs du masque sont choisies dans[0, 1]:- 1 pour les jetons d'entités qui ne sont pas masqués,
- 0 pour les jetons d'entités qui sont masqués.
- entity_token_type_ids (
torch.LongTensorde forme(batch_size, entity_length), facultatif) — Indices de jetons de segment pour indiquer les parties première et seconde des entrées de jetons d'entité. Les indices sont sélectionnés dans[0, 1]:- 0 correspond à un jeton d'entité de portion A,
- 1 correspond à un jeton d'entité de portion B.
- entity_position_ids (
torch.LongTensorde forme(batch_size, entity_length, max_mention_length), facultatif) — Indices des positions de chaque entité d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle[0, config.max_position_embeddings - 1]. - inputs_embeds (
torch.Tensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerinput_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indicesinput_idsen vecteurs associés que la matrice de recherche d’intégration interne du modèle. - labels (
torch.LongTensorde forme(batch_size,)ou(batch_size, num_labels), facultatif) — Étiquettes pour le calcul de la perte de classification. Si la forme est(batch_size,), la perte d'entropie croisée est utilisée pour la classification mono-étiquette. Dans ce cas, les étiquettes doivent contenir les indices qui doivent se situer dans[0, ..., config.num_labels - 1]. Si la forme est(batch_size, num_labels), la perte d'entropie croisée binaire est utilisée pour la classification multi-étiquettes. Dans ce cas, les étiquettes ne doivent contenir que[0, 1], où 0 et 1 indiquent respectivement faux et vrai. - output_attentions (
bool, facultatif) — Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Consultezattentionssous 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. Voirhidden_statessous les tenseurs retournés pour plus de détails. - return_dict (
bool, facultatif) — Indique s'il faut retourner un ModelOutput plutôt qu'un simple tuple.
Retourne
EntityClassificationOutput ou tuple(torch.Tensor)
Un EntityClassificationOutput ou un tuple de
torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (LukeConfig) et des entrées.
La méthode forward de LukeForEntityClassification redéfinit la méthode spéciale __call__.
Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance
Moduleplutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.
loss (
torch.Tensorde forme(1,), facultatif, renvoyé lorsquelabelsest fourni) — Perte de classification.logits (
torch.Tensorde forme(batch_size, config.num_labels)) — Scores de classification (avant SoftMax).hidden_states (
tuple[torch.Tensor, ...], facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.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.
entity_hidden_states (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings + un pour la sortie de chaque couche) de forme(batch_size, entity_length, hidden_size). États cachés des entités du modèle à la sortie de chaque couche, ainsi que les sorties des embeddings d'entités initiaux.attentions (
tuple[torch.Tensor, ...], facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
Exemples :
>>> from transformers import AutoTokenizer, LukeForEntityClassification
>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-large-finetuned-open-entity")
>>> model = LukeForEntityClassification.from_pretrained("studio-ousia/luke-large-finetuned-open-entity")
>>> text = "Beyoncé lives in Los Angeles."
>>> entity_spans = [(0, 7)] # character-based entity span corresponding to "Beyoncé"
>>> inputs = tokenizer(text, entity_spans=entity_spans, return_tensors="pt")
>>> outputs = model(**inputs)
>>> logits = outputs.logits
>>> predicted_class_idx = logits.argmax(-1).item()
>>> print("Predicted class:", model.config.id2label[predicted_class_idx])
Predicted class: personLukeForEntityPairClassification
classe transformers.LukeForEntityPairClassification
< source >( config: LukeConfig )
Paramètres
- config (LukeConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.
Le modèle LUKE avec une tête de classification au sommet (une couche linéaire au-dessus des états cachés des deux jetons d'entité) pour les tâches de classification de paires d'entités, telles que TACRED.
Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)
Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneentity_ids: typing.Optional[torch.LongTensor] = Noneentity_attention_mask: typing.Optional[torch.Tensor] = Noneentity_token_type_ids: typing.Optional[torch.LongTensor] = Noneentity_position_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → EntityPairClassificationOutput or tuple(torch.Tensor)
Paramètres
- input_ids (
torch.LongTensorde 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. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
- attention_mask (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans[0, 1]:- 1 pour les jetons qui ne sont pas masqués,
- 0 pour les jetons masqués.
- token_type_ids (
torch.LongTensorde forme(batch_size, sequence_length), facultatif) — Indices de jetons de segment pour indiquer les première et deuxième parties des entrées. Les indices sont choisis dans[0, 1]:- 0 correspond à un jeton sentence A,
- 1 correspond à un jeton sentence B.
- position_ids (
torch.LongTensorde 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]. - entity_ids (
torch.LongTensorde forme(batch_size, entity_length)) — Indices des jetons d'entité dans le vocabulaire des entités.Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
- entity_attention_mask (
torch.Tensorde forme(batch_size, entity_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices de jetons d'entité de bourrage. Les valeurs du masque sont choisies dans[0, 1]:- 1 pour les jetons d'entités qui ne sont pas masqués,
- 0 pour les jetons d'entités qui sont masqués.
- entity_token_type_ids (
torch.LongTensorde forme(batch_size, entity_length), facultatif) — Indices de jetons de segment pour indiquer les parties première et seconde des entrées de jetons d'entité. Les indices sont sélectionnés dans[0, 1]:- 0 correspond à un jeton d'entité de portion A,
- 1 correspond à un jeton d'entité de portion B.
- entity_position_ids (
torch.LongTensorde forme(batch_size, entity_length, max_mention_length), facultatif) — Indices des positions de chaque entité d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle[0, config.max_position_embeddings - 1]. - inputs_embeds (
torch.Tensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerinput_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indicesinput_idsen vecteurs associés que la matrice de recherche d’intégration interne du modèle. - labels (
torch.LongTensorde forme(batch_size,)ou(batch_size, num_labels), facultatif) — Étiquettes pour le calcul de la perte de classification. Si la forme est(batch_size,), la perte d'entropie croisée est utilisée pour la classification mono-étiquette. Dans ce cas, les étiquettes doivent contenir les indices qui doivent se situer dans[0, ..., config.num_labels - 1]. Si la forme est(batch_size, num_labels), la perte d'entropie croisée binaire est utilisée pour la classification multi-étiquettes. Dans ce cas, les étiquettes ne doivent contenir que[0, 1], où 0 et 1 indiquent respectivement faux et vrai. - output_attentions (
bool, facultatif) — Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Consultezattentionssous 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. Voirhidden_statessous les tenseurs retournés pour plus de détails. - return_dict (
bool, facultatif) — Indique s'il faut retourner un ModelOutput plutôt qu'un simple tuple.
Retourne
EntityPairClassificationOutput ou tuple(torch.Tensor)
Un EntityPairClassificationOutput ou un tuple de
torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (LukeConfig) et des entrées.
La méthode forward de LukeForEntityPairClassification redéfinit la méthode spéciale __call__.
Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance
Moduleplutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.
loss (
torch.Tensorde forme(1,), facultatif, renvoyé lorsquelabelsest fourni) — Perte de classification.logits (
torch.Tensorde forme(batch_size, config.num_labels)) — Scores de classification (avant SoftMax).hidden_states (
tuple[torch.Tensor, ...], facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.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.
entity_hidden_states (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings + un pour la sortie de chaque couche) de forme(batch_size, entity_length, hidden_size). États cachés des entités du modèle à la sortie de chaque couche, ainsi que les sorties des embeddings d'entités initiaux.attentions (
tuple[torch.Tensor, ...], facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
Exemples :
>>> from transformers import AutoTokenizer, LukeForEntityPairClassification
>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-large-finetuned-tacred")
>>> model = LukeForEntityPairClassification.from_pretrained("studio-ousia/luke-large-finetuned-tacred")
>>> text = "Beyoncé lives in Los Angeles."
>>> entity_spans = [
... (0, 7),
... (17, 28),
... ] # character-based entity spans corresponding to "Beyoncé" and "Los Angeles"
>>> inputs = tokenizer(text, entity_spans=entity_spans, return_tensors="pt")
>>> outputs = model(**inputs)
>>> logits = outputs.logits
>>> predicted_class_idx = logits.argmax(-1).item()
>>> print("Predicted class:", model.config.id2label[predicted_class_idx])
Predicted class: per:cities_of_residenceLukeForEntitySpanClassification
classe transformers.LukeForEntitySpanClassification
< source >( config: LukeConfig )
Paramètres
- config (LukeConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.
Le modèle LUKE avec une tête de classification de segments au sommet (une couche linéaire au-dessus des états cachés en sortie) pour des tâches telles que la reconnaissance d'entités nommées.
Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)
Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneentity_ids: typing.Optional[torch.LongTensor] = Noneentity_attention_mask: typing.Optional[torch.LongTensor] = Noneentity_token_type_ids: typing.Optional[torch.LongTensor] = Noneentity_position_ids: typing.Optional[torch.LongTensor] = Noneentity_start_positions: typing.Optional[torch.LongTensor] = Noneentity_end_positions: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → EntitySpanClassificationOutput or tuple(torch.Tensor)
Paramètres
- input_ids (
torch.LongTensorde 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. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
- attention_mask (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans[0, 1]:- 1 pour les jetons qui ne sont pas masqués,
- 0 pour les jetons masqués.
- token_type_ids (
torch.LongTensorde forme(batch_size, sequence_length), facultatif) — Indices de jetons de segment pour indiquer les première et deuxième parties des entrées. Les indices sont choisis dans[0, 1]:- 0 correspond à un jeton sentence A,
- 1 correspond à un jeton sentence B.
- position_ids (
torch.LongTensorde 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]. - entity_ids (
torch.LongTensorde forme(batch_size, entity_length)) — Indices des jetons d'entité dans le vocabulaire des entités.Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
- entity_attention_mask (
torch.Tensorde forme(batch_size, entity_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices de jetons d'entité de bourrage. Les valeurs du masque sont choisies dans[0, 1]:- 1 pour les jetons d'entités qui ne sont pas masqués,
- 0 pour les jetons d'entités qui sont masqués.
- entity_token_type_ids (
torch.LongTensorde forme(batch_size, entity_length), facultatif) — Indices de jetons de segment pour indiquer les parties première et seconde des entrées de jetons d'entité. Les indices sont sélectionnés dans[0, 1]:- 0 correspond à un jeton d'entité de portion A,
- 1 correspond à un jeton d'entité de portion B.
- entity_position_ids (
torch.LongTensorde forme(batch_size, entity_length, max_mention_length), facultatif) — Indices des positions de chaque entité d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle[0, config.max_position_embeddings - 1]. - entity_start_positions (
torch.LongTensor, facultatif) — Les positions de début des entités dans la séquence de jetons de mots. - entity_end_positions (
torch.LongTensor, facultatif) — Les positions de fin des entités dans la séquence de jetons de mots. - inputs_embeds (
torch.Tensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerinput_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indicesinput_idsen vecteurs associés que la matrice de recherche d’intégration interne du modèle. - labels (
torch.LongTensorde forme(batch_size, entity_length)ou(batch_size, entity_length, num_labels), facultatif) — Étiquettes pour le calcul de la perte de classification. Si la forme est(batch_size, entity_length), la perte d'entropie croisée est utilisée pour la classification mono-étiquette. Dans ce cas, les étiquettes doivent contenir les indices compris dans[0, ..., config.num_labels - 1]. Si la forme est(batch_size, entity_length, num_labels), la perte d'entropie croisée binaire est utilisée pour la classification multi-étiquettes. Dans ce cas, les étiquettes ne doivent contenir que[0, 1], où 0 et 1 indiquent respectivement faux et vrai. - output_attentions (
bool, facultatif) — Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Consultezattentionssous 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. Voirhidden_statessous les tenseurs retournés pour plus de détails. - return_dict (
bool, facultatif) — Indique s'il faut retourner un ModelOutput plutôt qu'un simple tuple.
Retourne
EntitySpanClassificationOutput ou tuple(torch.Tensor)
Un EntitySpanClassificationOutput ou un tuple de
torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (LukeConfig) et des entrées.
La méthode forward de LukeForEntitySpanClassification redéfinit la méthode spéciale __call__.
Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance
Moduleplutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.
loss (
torch.Tensorde forme(1,), facultatif, renvoyé lorsquelabelsest fourni) — Perte de classification.logits (
torch.Tensorde forme(batch_size, entity_length, config.num_labels)) — Scores de classification (avant SoftMax).hidden_states (
tuple[torch.Tensor, ...], facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.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.
entity_hidden_states (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings + un pour la sortie de chaque couche) de forme(batch_size, entity_length, hidden_size). États cachés des entités du modèle à la sortie de chaque couche, ainsi que les sorties des embeddings d'entités initiaux.attentions (
tuple[torch.Tensor, ...], facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
Exemples :
>>> from transformers import AutoTokenizer, LukeForEntitySpanClassification
>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-large-finetuned-conll-2003")
>>> model = LukeForEntitySpanClassification.from_pretrained("studio-ousia/luke-large-finetuned-conll-2003")
>>> text = "Beyoncé lives in Los Angeles"
# List all possible entity spans in the text
>>> word_start_positions = [0, 8, 14, 17, 21] # character-based start positions of word tokens
>>> word_end_positions = [7, 13, 16, 20, 28] # character-based end positions of word tokens
>>> entity_spans = []
>>> for i, start_pos in enumerate(word_start_positions):
... for end_pos in word_end_positions[i:]:
... entity_spans.append((start_pos, end_pos))
>>> inputs = tokenizer(text, entity_spans=entity_spans, return_tensors="pt")
>>> outputs = model(**inputs)
>>> logits = outputs.logits
>>> predicted_class_indices = logits.argmax(-1).squeeze().tolist()
>>> for span, predicted_class_idx in zip(entity_spans, predicted_class_indices):
... if predicted_class_idx != 0:
... print(text[span[0] : span[1]], model.config.id2label[predicted_class_idx])
Beyoncé PER
Los Angeles LOCLukeForSequenceClassification
classe transformers.LukeForSequenceClassification
< source >( config: LukeConfig )
Paramètres
- config (LukeConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.
Le modèle transformer LUKE avec une tête de classification/régression de séquence au sommet (une couche linéaire au sommet de la sortie agrégée), par exemple pour les tâches GLUE.
Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)
Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneentity_ids: typing.Optional[torch.LongTensor] = Noneentity_attention_mask: typing.Optional[torch.Tensor] = Noneentity_token_type_ids: typing.Optional[torch.LongTensor] = Noneentity_position_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → LukeSequenceClassifierOutput or tuple(torch.Tensor)
Paramètres
- input_ids (
torch.LongTensorde 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. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
- attention_mask (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans[0, 1]:- 1 pour les jetons qui ne sont pas masqués,
- 0 pour les jetons masqués.
- token_type_ids (
torch.LongTensorde forme(batch_size, sequence_length), facultatif) — Indices de jetons de segment pour indiquer les première et deuxième parties des entrées. Les indices sont choisis dans[0, 1]:- 0 correspond à un jeton sentence A,
- 1 correspond à un jeton sentence B.
- position_ids (
torch.LongTensorde 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]. - entity_ids (
torch.LongTensorde forme(batch_size, entity_length)) — Indices des jetons d'entité dans le vocabulaire des entités.Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
- entity_attention_mask (
torch.Tensorde forme(batch_size, entity_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices de jetons d'entité de bourrage. Les valeurs du masque sont choisies dans[0, 1]:- 1 pour les jetons d'entités qui ne sont pas masqués,
- 0 pour les jetons d'entités qui sont masqués.
- entity_token_type_ids (
torch.LongTensorde forme(batch_size, entity_length), facultatif) — Indices de jetons de segment pour indiquer les parties première et seconde des entrées de jetons d'entité. Les indices sont sélectionnés dans[0, 1]:- 0 correspond à un jeton d'entité de portion A,
- 1 correspond à un jeton d'entité de portion B.
- entity_position_ids (
torch.LongTensorde forme(batch_size, entity_length, max_mention_length), facultatif) — Indices des positions de chaque entité d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle[0, config.max_position_embeddings - 1]. - inputs_embeds (
torch.Tensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerinput_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indicesinput_idsen vecteurs associés que la matrice de recherche d’intégration interne du modèle. - labels (
torch.LongTensorde forme(batch_size,), facultatif) — Étiquettes pour le calcul de la perte de classification/régression de séquence. Les indices doivent être dans[0, ..., config.num_labels - 1]. Siconfig.num_labels == 1, une perte de régression est calculée (perte du carré moyen). Siconfig.num_labels > 1, une perte de classification est calculée (entropie croisée). - output_attentions (
bool, facultatif) — Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Consultezattentionssous 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. Voirhidden_statessous les tenseurs retournés pour plus de détails. - return_dict (
bool, facultatif) — Indique s'il faut retourner un ModelOutput plutôt qu'un simple tuple.
Retourne
LukeSequenceClassifierOutput ou tuple(torch.Tensor)
Un LukeSequenceClassifierOutput ou un tuple de
torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (LukeConfig) et des entrées.
La méthode forward de LukeForSequenceClassification redéfinit la méthode spéciale __call__.
Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance
Moduleplutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.
loss (
torch.Tensorde forme(1,), facultatif, renvoyé lorsquelabelsest fourni) — Perte de classification (ou de régression si config.num_labels==1).logits (
torch.Tensorde 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é lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.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.
entity_hidden_states (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings + un pour la sortie de chaque couche) de forme(batch_size, entity_length, hidden_size). États cachés des entités du modèle à la sortie de chaque couche, ainsi que les sorties des embeddings d'entités initiaux.attentions (
tuple[torch.Tensor, ...], facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
Exemple de classification mono-étiquette :
>>> import torch
>>> from transformers import AutoTokenizer, LukeForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-base")
>>> model = LukeForSequenceClassification.from_pretrained("studio-ousia/luke-base")
>>> 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 = LukeForSequenceClassification.from_pretrained("studio-ousia/luke-base", num_labels=num_labels)
>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...Exemple de classification multi-étiquettes :
>>> import torch
>>> from transformers import AutoTokenizer, LukeForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-base")
>>> model = LukeForSequenceClassification.from_pretrained("studio-ousia/luke-base", 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 = LukeForSequenceClassification.from_pretrained(
... "studio-ousia/luke-base", 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).lossLukeForMultipleChoice
classe transformers.LukeForMultipleChoice
< source >( config: LukeConfig )
Paramètres
- config (LukeConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.
Le modèle Luke 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. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)
Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneentity_ids: typing.Optional[torch.LongTensor] = Noneentity_attention_mask: typing.Optional[torch.Tensor] = Noneentity_token_type_ids: typing.Optional[torch.LongTensor] = Noneentity_position_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → LukeMultipleChoiceModelOutput or tuple(torch.Tensor)
Paramètres
- input_ids (
torch.LongTensorde 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. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
- attention_mask (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans[0, 1]:- 1 pour les jetons qui ne sont pas masqués,
- 0 pour les jetons masqués.
- token_type_ids (
torch.LongTensorde 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 choisis dans[0, 1]:- 0 correspond à un jeton sentence A,
- 1 correspond à un jeton sentence B.
- position_ids (
torch.LongTensorde 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]. - entity_ids (
torch.LongTensorde forme(batch_size, entity_length)) — Indices des jetons d'entité dans le vocabulaire des entités.Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
- entity_attention_mask (
torch.Tensorde forme(batch_size, entity_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices de jetons d'entité de bourrage. Les valeurs du masque sont choisies dans[0, 1]:- 1 pour les jetons d'entités qui ne sont pas masqués,
- 0 pour les jetons d'entités qui sont masqués.
- entity_token_type_ids (
torch.LongTensorde forme(batch_size, entity_length), facultatif) — Indices de jetons de segment pour indiquer les parties première et seconde des entrées de jetons d'entité. Les indices sont sélectionnés dans[0, 1]:- 0 correspond à un jeton d'entité de portion A,
- 1 correspond à un jeton d'entité de portion B.
- entity_position_ids (
torch.LongTensorde forme(batch_size, entity_length, max_mention_length), facultatif) — Indices des positions de chaque entité d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle[0, config.max_position_embeddings - 1]. - inputs_embeds (
torch.Tensorde forme(batch_size, num_choices, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerinput_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la façon de convertir les indicesinput_idsen vecteurs associés que la matrice de recherche d’intégration interne du modèle. - labels (
torch.LongTensorde forme(batch_size,), facultatif) — Étiquettes pour le calcul de la perte de classification à choix multiples. Les indices doivent être dans[0, ..., num_choices-1]oùnum_choicesest la taille de la deuxième dimension des tenseurs d’entrée. (Voirinput_idsci-dessus) - output_attentions (
bool, facultatif) — Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Consultezattentionssous 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. Voirhidden_statessous les tenseurs retournés pour plus de détails. - return_dict (
bool, facultatif) — Indique s'il faut retourner un ModelOutput plutôt qu'un simple tuple.
Retourne
LukeMultipleChoiceModelOutput ou tuple(torch.Tensor)
Un LukeMultipleChoiceModelOutput ou un tuple de
torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (LukeConfig) et des entrées.
La méthode forward de LukeForMultipleChoice redéfinit la méthode spéciale __call__.
Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance
Moduleplutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.
loss (
torch.Tensorde forme (1,), facultatif, renvoyé lorsquelabelsest fourni) — Perte de classification.logits (
torch.Tensorde 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é lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.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.
entity_hidden_states (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings + un pour la sortie de chaque couche) de forme(batch_size, entity_length, hidden_size). États cachés des entités du modèle à la sortie de chaque couche, ainsi que les sorties des embeddings d'entités initiaux.attentions (
tuple[torch.Tensor, ...], facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
Exemple :
>>> from transformers import AutoTokenizer, LukeForMultipleChoice
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-base")
>>> model = LukeForMultipleChoice.from_pretrained("studio-ousia/luke-base")
>>> 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.logitsLukeForTokenClassification
classe transformers.LukeForTokenClassification
< source >( config: LukeConfig )
Paramètres
- config (LukeConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.
Le modèle LUKE avec une tête de classification de jetons au sommet (une couche linéaire au-dessus de la sortie des états cachés). Pour
résoudre la tâche de reconnaissance d’entités nommées (NER) à l’aide de LUKE, LukeForEntitySpanClassification est plus adapté que cette
classe.
Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)
Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneentity_ids: typing.Optional[torch.LongTensor] = Noneentity_attention_mask: typing.Optional[torch.Tensor] = Noneentity_token_type_ids: typing.Optional[torch.LongTensor] = Noneentity_position_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → LukeTokenClassifierOutput or tuple(torch.Tensor)
Paramètres
- input_ids (
torch.LongTensorde 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. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
- attention_mask (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans[0, 1]:- 1 pour les jetons qui ne sont pas masqués,
- 0 pour les jetons masqués.
- token_type_ids (
torch.LongTensorde forme(batch_size, sequence_length), facultatif) — Indices de jetons de segment pour indiquer les première et deuxième parties des entrées. Les indices sont choisis dans[0, 1]:- 0 correspond à un jeton sentence A,
- 1 correspond à un jeton sentence B.
- position_ids (
torch.LongTensorde 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]. - entity_ids (
torch.LongTensorde forme(batch_size, entity_length)) — Indices des jetons d'entité dans le vocabulaire des entités.Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
- entity_attention_mask (
torch.Tensorde forme(batch_size, entity_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices de jetons d'entité de bourrage. Les valeurs du masque sont choisies dans[0, 1]:- 1 pour les jetons d'entités qui ne sont pas masqués,
- 0 pour les jetons d'entités qui sont masqués.
- entity_token_type_ids (
torch.LongTensorde forme(batch_size, entity_length), facultatif) — Indices de jetons de segment pour indiquer les parties première et seconde des entrées de jetons d'entité. Les indices sont sélectionnés dans[0, 1]:- 0 correspond à un jeton d'entité de portion A,
- 1 correspond à un jeton d'entité de portion B.
- entity_position_ids (
torch.LongTensorde forme(batch_size, entity_length, max_mention_length), facultatif) — Indices des positions de chaque entité d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle[0, config.max_position_embeddings - 1]. - inputs_embeds (
torch.Tensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerinput_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indicesinput_idsen vecteurs associés que la matrice de recherche d’intégration interne du modèle. - labels (
torch.LongTensorde forme(batch_size,), facultatif) — Étiquettes pour le calcul de la perte de classification à choix multiples. Les indices doivent être dans[0, ..., num_choices-1]oùnum_choicesest la taille de la deuxième dimension des tenseurs d’entrée. (Voirinput_idsci-dessus) - output_attentions (
bool, facultatif) — Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Consultezattentionssous 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. Voirhidden_statessous les tenseurs retournés pour plus de détails. - return_dict (
bool, facultatif) — Indique s'il faut retourner un ModelOutput plutôt qu'un simple tuple.
Retourne
LukeTokenClassifierOutput ou tuple(torch.Tensor)
Un LukeTokenClassifierOutput ou un tuple de
torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (LukeConfig) et des entrées.
La méthode forward de LukeForTokenClassification redéfinit la méthode spéciale __call__.
Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance
Moduleplutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.
loss (
torch.Tensorde forme(1,), facultatif, renvoyé lorsquelabelsest fourni) — Perte de classification.logits (
torch.Tensorde forme(batch_size, sequence_length, config.num_labels)) — Scores de classification (avant SoftMax).hidden_states (
tuple[torch.Tensor, ...], facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.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.
entity_hidden_states (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings + un pour la sortie de chaque couche) de forme(batch_size, entity_length, hidden_size). États cachés des entités du modèle à la sortie de chaque couche, ainsi que les sorties des embeddings d'entités initiaux.attentions (
tuple[torch.Tensor, ...], facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
Exemple :
>>> from transformers import AutoTokenizer, LukeForTokenClassification
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-base")
>>> model = LukeForTokenClassification.from_pretrained("studio-ousia/luke-base")
>>> 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)
...LukeForQuestionAnswering
classe transformers.LukeForQuestionAnswering
< source >( config: LukeConfig )
Paramètres
- config (LukeConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.
Le transformateur Luke 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. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)
Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Noneentity_ids: typing.Optional[torch.LongTensor] = Noneentity_attention_mask: typing.Optional[torch.Tensor] = Noneentity_token_type_ids: typing.Optional[torch.LongTensor] = Noneentity_position_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonestart_positions: typing.Optional[torch.LongTensor] = Noneend_positions: typing.Optional[torch.LongTensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → LukeQuestionAnsweringModelOutput or tuple(torch.Tensor)
Paramètres
- input_ids (
torch.LongTensorde 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. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
- attention_mask (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans[0, 1]:- 1 pour les jetons qui ne sont pas masqués,
- 0 pour les jetons masqués.
- token_type_ids (
torch.LongTensorde forme(batch_size, sequence_length), facultatif) — Indices de jetons de segment pour indiquer les première et deuxième parties des entrées. Les indices sont choisis dans[0, 1]:- 0 correspond à un jeton sentence A,
- 1 correspond à un jeton sentence B.
- position_ids (
torch.Tensorde 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]. - entity_ids (
torch.LongTensorde forme(batch_size, entity_length)) — Indices des jetons d'entité dans le vocabulaire des entités.Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
- entity_attention_mask (
torch.Tensorde forme(batch_size, entity_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices de jetons d'entité de bourrage. Les valeurs du masque sont choisies dans[0, 1]:- 1 pour les jetons d'entités qui ne sont pas masqués,
- 0 pour les jetons d'entités qui sont masqués.
- entity_token_type_ids (
torch.LongTensorde forme(batch_size, entity_length), facultatif) — Indices de jetons de segment pour indiquer les parties première et seconde des entrées de jetons d'entité. Les indices sont sélectionnés dans[0, 1]:- 0 correspond à un jeton d'entité de portion A,
- 1 correspond à un jeton d'entité de portion B.
- entity_position_ids (
torch.LongTensorde forme(batch_size, entity_length, max_mention_length), facultatif) — Indices des positions de chaque entité d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle[0, config.max_position_embeddings - 1]. - inputs_embeds (
torch.Tensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerinput_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indicesinput_idsen vecteurs associés que la matrice de recherche d’intégration interne du modèle. - start_positions (
torch.LongTensorde forme(batch_size,), facultatif) — Étiquettes pour la position (index) du début de l'interval étiqueté, utilisées pour le calcul de la perte de classification de jetons. Les positions sont bornées à la longueur de la séquence (sequence_length). Les positions situées en dehors de la séquence ne sont pas prises en compte pour le calcul de la perte. - end_positions (
torch.LongTensorde forme(batch_size,), facultatif) — Étiquettes pour la position (index) de fin de l'intervalle étiqueté, utilisées pour le calcul de la perte de classification de jetons. Les positions sont bornées à la longueur de la séquence (sequence_length). Les positions situées en dehors de la séquence ne sont pas prises en compte pour le calcul de la perte. - output_attentions (
bool, facultatif) — Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Consultezattentionssous 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. Voirhidden_statessous les tenseurs retournés pour plus de détails. - return_dict (
bool, facultatif) — Indique s'il faut retourner un ModelOutput plutôt qu'un simple tuple.
Retourne
LukeQuestionAnsweringModelOutput ou tuple(torch.Tensor)
Un LukeQuestionAnsweringModelOutput ou un tuple de
torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (LukeConfig) et des entrées.
La méthode forward de LukeForQuestionAnswering redéfinit la méthode spéciale __call__.
Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance
Moduleplutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.
loss (
torch.Tensorde forme(1,), facultatif, renvoyé lorsquelabelsest fourni) — La perte totale d'extraction de span est la somme d'une entropie croisée pour les positions de début et de fin.start_logits (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Scores de début de segment (avant SoftMax).end_logits (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Scores de fin de segment (avant SoftMax).hidden_states (
tuple[torch.Tensor, ...], facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.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.
entity_hidden_states (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings + un pour la sortie de chaque couche) de forme(batch_size, entity_length, hidden_size). États cachés des entités du modèle à la sortie de chaque couche, ainsi que les sorties des embeddings d'entités initiaux.attentions (
tuple[torch.Tensor, ...], facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
Exemple :
>>> from transformers import AutoTokenizer, LukeForQuestionAnswering
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("studio-ousia/luke-base")
>>> model = LukeForQuestionAnswering.from_pretrained("studio-ousia/luke-base")
>>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"
>>> inputs = tokenizer(question, text, return_tensors="pt")
>>> with torch.no_grad():
... outputs = model(**inputs)
>>> answer_start_index = outputs.start_logits.argmax()
>>> answer_end_index = outputs.end_logits.argmax()
>>> predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1]
>>> tokenizer.decode(predict_answer_tokens, skip_special_tokens=True)
...
>>> # target is "nice puppet"
>>> target_start_index = torch.tensor([14])
>>> target_end_index = torch.tensor([15])
>>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)
>>> loss = outputs.loss
>>> round(loss.item(), 2)
...