Hugging Face's logo

Transformers documentation

MarkupLM

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.1).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Ce modèle a été publié dans HF papers le 2021-10-16 et ajouté à Hugging Face Transformers le 2022-09-30.

MarkupLM

Aperçu

Le modèle MarkupLM a été proposé dans MarkupLM: Pre-training of Text and Markup Language for Visually-rich Document Understanding par Junlong Li, Yiheng Xu, Lei Cui, Furu Wei. MarkupLM est BERT, mais appliqué aux pages HTML au lieu de documents texte bruts. Le modèle intègre des couches d'incorporation supplémentaires pour améliorer les performances, de manière similaire à LayoutLM.

Le modèle peut être utilisé pour des tâches telles que la réponse à des questions sur des pages web ou l'extraction d'informations à partir de pages web. Il obtient des résultats de l'état de l'art sur 2 benchmarks importants :

  • WebSRC, un jeu de données pour la compréhension de lecture structurelle basée sur le Web (un peu comme SQuAD, mais pour les pages web)
  • SWDE, un jeu de données pour l'extraction d'informations à partir de pages web (essentiellement la reconnaissance d'entités nommées sur des pages web)

L'abstract de l'article est le suivant :

Le pré-entraînement multimodal avec du texte, la mise en page et des images a fait des progrès significatifs pour la compréhension de documents visuellement riches (VrDU), en particulier pour les documents à mise en page fixe, tels que les images de documents scannés. Cependant, il existe encore un grand nombre de documents numériques dont les informations de mise en page ne sont pas fixes et qui doivent être rendus de manière interactive et dynamique pour la visualisation, ce qui rend les approches de pré-entraînement basées sur la mise en page difficiles à appliquer. Dans cet article, nous proposons MarkupLM pour les tâches de compréhension de documents utilisant des langages de balisage comme colonne vertébrale, tels que les documents basés sur HTML/XML, où les informations de texte et de balisage sont pré-entraînées conjointement. Les résultats expérimentaux montrent que le MarkupLM pré-entraîné surpasse significativement les modèles de référence existants et performants sur plusieurs tâches de compréhension de documents. Le modèle pré-entraîné et le code seront disponibles publiquement.

Ce modèle a été contribué par nielsr. Le code d'origine peut être trouvé ici.

Conseils d'utilisation

  • En plus de input_ids, forward() s'attend à deux entrées supplémentaires, à savoir xpath_tags_seq et xpath_subs_seq. Ce sont respectivement les balises XPATH et les indices de sous-chaîne pour chaque jeton de la séquence d'entrée.
  • On peut utiliser MarkupLMProcessor pour préparer toutes les données du modèle. Consultez le guide d'utilisation pour plus d'informations.
drawing MarkupLM architecture. Taken from the original paper.

Utilisation : MarkupLMProcessor

La façon la plus simple de préparer les données pour le modèle est d’utiliser MarkupLMProcessor, qui combine en interne un extracteur de caractéristiques (MarkupLMFeatureExtractor) et un tokeniseur (MarkupLMTokenizer ou MarkupLMTokenizerFast). L’extracteur de caractéristiques est utilisé pour extraire tous les nœuds et chemins XPath des chaînes HTML, qui sont ensuite fournis au tokeniseur, les convertissant en entrées au niveau des jetons pour le modèle (input_ids, etc.). Notez que vous pouvez toujours utiliser l’extracteur de caractéristiques et le tokeniseur séparément, si vous ne souhaitez traiter que l’une des deux tâches.

from transformers import MarkupLMFeatureExtractor, MarkupLMProcessor, MarkupLMTokenizerFast


feature_extractor = MarkupLMFeatureExtractor()
tokenizer = MarkupLMTokenizerFast.from_pretrained("microsoft/markuplm-base")
processor = MarkupLMProcessor(feature_extractor, tokenizer)

En résumé, on peut fournir des chaînes HTML (et éventuellement des données supplémentaires) à MarkupLMProcessor, et il créera les entrées attendues par le modèle. En interne, le processeur utilise d'abord MarkupLMFeatureExtractor pour obtenir une liste de nœuds et les xpaths correspondants. Les nœuds et les xpaths sont ensuite transmis à MarkupLMTokenizer ou MarkupLMTokenizerFast, qui les convertit en input_ids, attention_mask, token_type_ids, xpath_subs_seq, xpath_tags_seq au niveau des jetons. Facultativement, on peut fournir des étiquettes de nœuds au processeur, qui sont transformées en labels au niveau des jetons.

MarkupLMFeatureExtractor utilise Beautiful Soup, une bibliothèque Python permettant d’extraire des données de fichiers HTML et XML, en interne. Notez que vous pouvez toujours utiliser votre propre solution d’analyse et fournir vous-même les nœuds et les xpaths à MarkupLMTokenizer ou MarkupLMTokenizerFast.

Au total, le processeur prend en charge 5 cas d'utilisation. Nous les listons tous ci-dessous. Notez que chacun de ces cas d'utilisation fonctionne pour les entrées en lot comme pour les entrées non en lot (nous les illustrons pour des entrées non en lot).

Cas d'usage 1 : classification de pages web (entraînement, inférence) + classification de jetons (inférence), parse_html = True

C'est le cas le plus simple, dans lequel le processeur utilise l'extracteur de caractéristiques pour obtenir tous les nœuds et les xpaths à partir du HTML.

from transformers import MarkupLMProcessor


processor = MarkupLMProcessor.from_pretrained("microsoft/markuplm-base")

html_string = """
 <!DOCTYPE html>
 <html>
 <head>
 <title>Hello world</title>
 </head>
 <body>
 <h1>Welcome</h1>
 <p>Here is my website.</p>
 </body>
 </html>"""

# note that you can also add provide all tokenizer parameters here such as padding, truncation
encoding = processor(html_string, return_tensors="pt").to(model.device)
print(encoding.keys())
dict_keys(['input_ids', 'token_type_ids', 'attention_mask', 'xpath_tags_seq', 'xpath_subs_seq'])

Cas d'utilisation 2 : classification de pages web (entraînement, inférence) + classification de jetons (inférence), parse_html=False

Si l’on a déjà obtenu tous les nœuds et les xpaths, le feature extractor n’est pas nécessaire. Dans ce cas, il faut fournir soi-même les nœuds et les xpaths correspondants au processeur, et s’assurer de définir parse_html sur False.

from transformers import MarkupLMProcessor


processor = MarkupLMProcessor.from_pretrained("microsoft/markuplm-base")
processor.parse_html = False

nodes = ["hello", "world", "how", "are"]
xpaths = ["/html/body/div/li[1]/div/span", "/html/body/div/li[1]/div/span", "html/body", "html/body/div"]
encoding = processor(nodes=nodes, xpaths=xpaths, return_tensors="pt").to(model.device)
print(encoding.keys())
dict_keys(['input_ids', 'token_type_ids', 'attention_mask', 'xpath_tags_seq', 'xpath_subs_seq'])

Cas d'usage 3 : classification de jetons (entraînement), parse_html=False

Pour les tâches de classification de jetons (telles que SWDE), il est également possible de fournir les étiquettes de nœuds correspondantes afin d’entraîner un modèle. Le processeur convertira ensuite ces étiquettes en étiquettes au niveau des jetons, labels. Par défaut, il n’étiquette que le premier wordpiece d’un mot et attribue -100 aux wordpieces restants, ce qui correspond à l’ignore_index de CrossEntropyLoss de PyTorch. Si vous souhaitez que tous les wordpieces d’un mot soient étiquetés, vous pouvez initialiser le tokeniseur avec only_label_first_subword défini sur False.

from transformers import MarkupLMProcessor


processor = MarkupLMProcessor.from_pretrained("microsoft/markuplm-base")
processor.parse_html = False

nodes = ["hello", "world", "how", "are"]
xpaths = ["/html/body/div/li[1]/div/span", "/html/body/div/li[1]/div/span", "html/body", "html/body/div"]
node_labels = [1, 2, 2, 1]
encoding = processor(nodes=nodes, xpaths=xpaths, node_labels=node_labels, return_tensors="pt").to(model.device)
print(encoding.keys())
dict_keys(['input_ids', 'token_type_ids', 'attention_mask', 'xpath_tags_seq', 'xpath_subs_seq', 'labels'])

Cas d'usage 4 : réponse à des questions sur une page web (inférence), parse_html=True

Pour les tâches de réponse à des questions sur des pages web, vous pouvez fournir une question au processeur. Par défaut, le processeur utilise l’extracteur de caractéristiques pour obtenir tous les nœuds et les xpaths, et crée [CLS] jetons de question [SEP] jetons de mots [SEP].

from transformers import MarkupLMProcessor


processor = MarkupLMProcessor.from_pretrained("microsoft/markuplm-base")

html_string = """
 <!DOCTYPE html>
 <html>
 <head>
 <title>Hello world</title>
 </head>
 <body>
 <h1>Welcome</h1>
 <p>My name is Niels.</p>
 </body>
 </html>"""

question = "What's his name?"
encoding = processor(html_string, questions=question, return_tensors="pt").to(model.device)
print(encoding.keys())
dict_keys(['input_ids', 'token_type_ids', 'attention_mask', 'xpath_tags_seq', 'xpath_subs_seq'])

Cas d'usage 5 : réponse à des questions sur une page web (inférence), parse_html=False

Pour les tâches de question-réponse (telles que WebSRC), vous pouvez fournir une question au processeur. Si vous avez extrait vous-même tous les nœuds et les xpaths, vous pouvez les fournir directement au processeur. Assurez-vous de définir parse_html sur False.

from transformers import MarkupLMProcessor


processor = MarkupLMProcessor.from_pretrained("microsoft/markuplm-base")
processor.parse_html = False

nodes = ["hello", "world", "how", "are"]
xpaths = ["/html/body/div/li[1]/div/span", "/html/body/div/li[1]/div/span", "html/body", "html/body/div"]
question = "What's his name?"
encoding = processor(nodes=nodes, xpaths=xpaths, questions=question, return_tensors="pt").to(model.device)
print(encoding.keys())
dict_keys(['input_ids', 'token_type_ids', 'attention_mask', 'xpath_tags_seq', 'xpath_subs_seq'])

Ressources

MarkupLMConfig

classe transformers.MarkupLMConfig

< >

( 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 = 30522hidden_size: int = 768num_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-12pad_token_id: int | None = 0bos_token_id: int | None = 0eos_token_id: int | list[int] | None = 2max_xpath_tag_unit_embeddings: int = 256max_xpath_subs_unit_embeddings: int = 1024tag_pad_id: int = 216subs_pad_id: int = 1001xpath_unit_hidden_size: int = 32max_depth: int = 50use_cache: bool = Trueclassifier_dropout: float | int | None = None )

Paramètres

  • vocab_size (int, facultatif, par défaut 30522) — Taille du vocabulaire du modèle. Définit le nombre de jetons différents qui peuvent être représentés par input_ids.
  • hidden_size (int, facultatif, par défaut 768) — Dimension des représentations cachées.
  • num_hidden_layers (int, facultatif, par défaut 12) — Nombre de couches cachées dans le décodeur Transformer.
  • num_attention_heads (int, facultatif, valeur par défaut 12) — Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer.
  • intermediate_size (int, facultatif, par défaut 3072) — Dimension des représentations du MLP.
  • hidden_act (str, facultatif, par défaut gelu) — 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éfaut 0.1) — La probabilité de dropout pour toutes les couches entièrement connectées des embeddings, de l'encodeur et du pooler.
  • attention_probs_dropout_prob (Union[float, int], facultatif, par défaut 0.1) — Le taux de dropout appliqué aux probabilités d'attention.
  • max_position_embeddings (int, facultatif, par défaut 512) — La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé.
  • type_vocab_size (int, facultatif, par défaut 2) — La taille du vocabulaire des token_type_ids.
  • initializer_range (float, facultatif, par défaut 0.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éfaut 1e-12) — L'épsilon utilisé par les couches de normalisation de couche.
  • pad_token_id (int, facultatif, par défaut 0) — Identifiant du jeton utilisé pour le bourrage dans le vocabulaire.
  • bos_token_id (int, facultatif, par défaut 0) — Identifiant du jeton utilisé pour le début de flux dans le vocabulaire.
  • eos_token_id (Union[int, list[int]], facultatif, par défaut 2) — Identifiant du jeton utilisé pour la fin de flux dans le vocabulaire.
  • max_xpath_tag_unit_embeddings (int, facultatif, valeur par défaut 256) — La valeur maximale que l'embedding d'unité de balise xpath pourrait atteindre. Il est généralement recommandé de définir cette valeur sur un nombre élevé par précaution (par exemple, 256).
  • max_xpath_subs_unit_embeddings (int, facultatif, valeur par défaut 1024) — La valeur maximale que l'embedding d'unité de souscription xpath pourrait atteindre. Il est généralement recommandé de définir cette valeur sur un nombre élevé par précaution (par exemple, 1024).
  • tag_pad_id (int, facultatif, valeur par défaut 216) — L'identifiant du jeton de bourrage dans les balises xpath.
  • subs_pad_id (int, facultatif, valeur par défaut 1001) — L'identifiant du jeton de bourrage dans les sous-indices xpath.
  • xpath_unit_hidden_size (int, facultatif, valeur par défaut 32) — La taille cachée de chaque unité dans xpath.
  • max_depth (int, facultatif, valeur par défaut 50) — La profondeur maximale dans xpath.
  • use_cache (bool, facultatif, valeur par défaut True) — Indique si le modèle doit retourner les dernières attentions clés/valeurs (non utilisé par tous les modèles). N’est pertinent que si config.is_decoder=True ou si le modèle est un modèle génératif uniquement décodeur.
  • classifier_dropout (Union[float, int], facultatif) — Le taux de dropout pour le classifieur.

Ceci est la classe de configuration destinée à stocker la configuration d'un MarkupLMModel. Elle est utilisée pour instancier un modèle Markuplm 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 microsoft/markuplm-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.

Exemples :

>>> from transformers import MarkupLMModel, MarkupLMConfig

>>> # Initializing a MarkupLM microsoft/markuplm-base style configuration
>>> configuration = MarkupLMConfig()

>>> # Initializing a model from the microsoft/markuplm-base style configuration
>>> model = MarkupLMModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

MarkupLMFeatureExtractor

classe transformers.MarkupLMFeatureExtractor

< >

( **kwargs )

Construit un extracteur de fonctionnalités MarkupLM. Il peut être utilisé pour obtenir une liste de nœuds et les xpaths correspondants à partir de chaînes HTML.

Cet extracteur de fonctionnalités hérite de PreTrainedFeatureExtractor(), 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.

__call__

< >

( html_strings ) → BatchFeature

Paramètres

  • html_strings (str, list[str]) — La chaîne HTML ou le lot de chaînes HTML à partir desquels extraire les nœuds et les xpaths correspondants.

Retourne

BatchFeature

Un BatchFeature avec les champs suivants :

  • nodes — Nœuds.
  • xpaths — Xpaths correspondants.

Méthode principale pour préparer une ou plusieurs chaînes HTML pour le modèle.

Exemples :

>>> from transformers import MarkupLMFeatureExtractor

>>> page_name_1 = "page1.html"
>>> page_name_2 = "page2.html"
>>> page_name_3 = "page3.html"

>>> with open(page_name_1) as f:
...     single_html_string = f.read()

>>> feature_extractor = MarkupLMFeatureExtractor()

>>> # single example
>>> encoding = feature_extractor(single_html_string)
>>> print(encoding.keys())
>>> # dict_keys(['nodes', 'xpaths'])

>>> # batched example

>>> multi_html_strings = []

>>> with open(page_name_2) as f:
...     multi_html_strings.append(f.read())
>>> with open(page_name_3) as f:
...     multi_html_strings.append(f.read())

>>> encoding = feature_extractor(multi_html_strings)
>>> print(encoding.keys())
>>> # dict_keys(['nodes', 'xpaths'])

MarkupLMTokenizer

classe transformers.MarkupLMTokenizer

< >

( tags_dictvocab: str | dict[str, int] | list[tuple[str, float]] | None = Nonemerges: str | list[str] | 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 = Falsemax_depth = 50max_width = 1000pad_width = 1001pad_token_label = -100only_label_first_subword = Truetrim_offsets = False**kwargs )

Paramètres

  • vocab (str ou dict[str, int], facultatif) — Dictionnaire de vocabulaire personnalisé. S'il n'est pas fourni, le vocabulaire est chargé depuis vocab_file.
  • merges (str ou list[str], facultatif) — Liste de fusions personnalisée. Si non fournie, les fusions sont chargées depuis merges_file.
  • 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éfaut False) — Indique s'il faut ajouter un espace initial à l'entrée. Cela permet de traiter le mot initial comme n'importe quel autre mot. (Le tokenizer RoBERTa détecte le début des mots par l'espace qui les précède).

Construit un tokenizer MarkupLM. Basé sur l'encodage par paires de bytes (Byte-Pair-Encoding, BPE) au niveau des octets.

MarkupLMTokenizer peut être utilisé pour convertir des chaînes HTML en input_ids, attention_mask, token_type_ids, xpath_tags_seq et xpath_tags_seq au niveau des jetons. Ce tokeniseur hérite de TokenizersBackend, qui contient la plupart des méthodes principales et garantit qu’un backend tokenizers est toujours instancié.

Les utilisateurs doivent se référer à cette superclasse pour plus d'informations sur ces méthodes.

build_inputs_with_special_tokens

< >

( token_ids_0: listtoken_ids_1: list[int] | None = None ) → list[int]

Paramètres

  • token_ids_0 (list[int]) — Liste des ID auxquels les jetons spéciaux seront ajoutés.
  • token_ids_1 (list[int], facultatif) — Deuxième liste d'identifiants facultative pour les paires de séquences.

Retourne

list[int]

Liste des identifiants d'entrée avec les jetons spéciaux appropriés.

Construire les entrées du modèle à partir d'une séquence ou d'une paire de séquences pour les tâches de classification de séquences en les concaténant et en ajoutant des jetons spéciaux. Une séquence RoBERTa a le format suivant :

  • séquence unique : <s> X </s>
  • paire de séquences : <s> A </s></s> B </s>

get_special_tokens_mask

< >

( token_ids_0: list[int]token_ids_1: list[int] | None = Nonealready_has_special_tokens: bool = False ) → A list of integers in the range [0, 1]

Paramètres

  • token_ids_0 — Liste des identifiants de la séquence (éventuellement déjà formatée).
  • token_ids_1 — Non utilisé lorsque already_has_special_tokens=True. Doit être None dans ce cas.
  • already_has_special_tokens — Indique si la séquence est déjà formatée avec des jetons spéciaux.

Retourne

Une liste d'entiers dans l'intervalle [0, 1]

1 pour un jeton spécial, 0 pour un jeton de séquence.

Récupérer les identifiants de séquences à partir d'une liste de jetons à laquelle aucun jeton spécial n'a été ajouté.

Pour les tokenizers rapides, les data collators appellent cette fonction avec already_has_special_tokens=True pour construire un masque sur une séquence déjà formatée. Dans ce cas, nous calculons le masque en vérifiant l’appartenance à all_special_ids.

create_token_type_ids_from_sequences

< >

( token_ids_0: listtoken_ids_1: list[int] | None = None ) → list[int]

Paramètres

  • token_ids_0 (list[int]) — Liste d'identifiants.
  • token_ids_1 (list[int], facultatif) — Deuxième liste d'identifiants facultative pour les paires de séquences.

Retourne

list[int]

Liste de zéros.

Crée un masque à partir des deux séquences passées, à utiliser dans une tâche de classification de paires de séquences. RoBERTa n’utilise pas les identifiants de type de jeton, une liste de zéros est donc renvoyée.

save_vocabulary

< >

( save_directory: strfilename_prefix: str | None = None )

MarkupLMTokenizerFast

classe transformers.MarkupLMTokenizer

< >

( tags_dictvocab: str | dict[str, int] | list[tuple[str, float]] | None = Nonemerges: str | list[str] | 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 = Falsemax_depth = 50max_width = 1000pad_width = 1001pad_token_label = -100only_label_first_subword = Truetrim_offsets = False**kwargs )

Paramètres

  • vocab (str ou dict[str, int], facultatif) — Dictionnaire de vocabulaire personnalisé. S'il n'est pas fourni, le vocabulaire est chargé depuis vocab_file.
  • merges (str ou list[str], facultatif) — Liste de fusions personnalisée. Si non fournie, les fusions sont chargées depuis merges_file.
  • 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éfaut False) — Indique s'il faut ajouter un espace initial à l'entrée. Cela permet de traiter le mot initial comme n'importe quel autre mot. (Le tokenizer RoBERTa détecte le début des mots par l'espace qui les précède).

Construit un tokenizer MarkupLM. Basé sur l'encodage par paires de bytes (Byte-Pair-Encoding, BPE) au niveau des octets.

MarkupLMTokenizer peut être utilisé pour convertir des chaînes HTML en input_ids, attention_mask, token_type_ids, xpath_tags_seq et xpath_tags_seq au niveau des jetons. Ce tokeniseur hérite de TokenizersBackend, qui contient la plupart des méthodes principales et garantit qu’un backend tokenizers est toujours instancié.

Les utilisateurs doivent se référer à cette superclasse pour plus d'informations sur ces méthodes.

batch_encode_plus

< >

( batch_text_or_text_pairs: list[str] | list[tuple[str, str]] | list[list[str]]is_pair: bool | None = Nonexpaths: list[list[list[int]]] | None = Nonenode_labels: list[int] | list[list[int]] | 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 = Nonestride: int = 0pad_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 )

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 :

  • True ou 'longest' : Ajuster à la séquence la plus longue du lot (ou aucun ajustement si une seule séquence est fournie).

  • 'max_length' : Remplir jusqu'à une longueur maximale spécifiée par l'argument max_length ou jusqu'à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni.

  • False ou 'do_not_pad' (par défaut) : aucun bourrage (c.-à-d. peut produire un lot avec des séquences de longueurs différentes). truncation (bool, str ou TruncationStrategy, facultatif, par défaut False) : Active et contrôle la troncature. Accepte les valeurs suivantes :

  • True ou 'longest_first' : Tronquer à une longueur maximale spécifiée avec l’argument max_length ou à 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'argument max_length ou à 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'argument max_length ou à 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.

  • False ou '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 objets torch.Tensor de PyTorch.
  • 'np' : Renvoie des objets Numpy np.ndarray.

add_special_tokens (bool, facultatif, par défaut True) : Indique s'il faut ou non encoder les séquences avec les jetons spéciaux relatifs à leur modèle. padding (bool, str ou PaddingStrategy, facultatif, par défaut False) : Active et contrôle le bourrage. Accepte les valeurs suivantes :

  • True ou 'longest' : Ajuster à la séquence la plus longue du lot (ou aucun ajustement si une seule séquence est fournie).

  • 'max_length' : Remplir jusqu'à une longueur maximale spécifiée par l'argument max_length ou jusqu'à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni.

  • False ou 'do_not_pad' (par défaut) : aucun bourrage (c.-à-d. peut produire un lot avec des séquences de longueurs différentes). truncation (bool, str ou TruncationStrategy, facultatif, par défaut False) : Active et contrôle la troncature. Accepte les valeurs suivantes :

  • True ou 'longest_first' : Tronquer à une longueur maximale spécifiée avec l’argument max_length ou à 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'argument max_length ou à 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'argument max_length ou à 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.

  • False ou 'do_not_truncate' (par défaut) : aucune troncature (c.-à-d. peut produire un lot dont les longueurs de séquences sont 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. S'il n'est pas défini ou s'il est défini sur None, la longueur maximale prédéfinie du modèle sera utilisée si un paramètre de troncature/remplissage en a besoin. Si le modèle n'a pas de longueur d'entrée maximale spécifique (comme XLNet), la troncature/remplissage à une longueur maximale sera désactivée. stride (int, facultatif, par défaut 0) : S'il est 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 les séquences en dépassement. La valeur de cet argument définit le nombre de jetons en chevauchement. is_split_into_words (bool, facultatif, par défaut False) : Indique si l'entrée est déjà pré-tokenisée (par exemple, découpée en mots). Définissez cette valeur sur True si vous passez des entrées pré-tokenisées pour éviter une tokenisation supplémentaire. pad_to_multiple_of (int, facultatif) : S'il est défini, remplit la séquence jusqu'à un multiple de la valeur fournie. Cela est particulièrement utile pour permettre l'utilisation des Tensor Cores sur le matériel NVIDIA avec une capacité de calcul >= 7.5 (Volta). return_tensors (str ou TensorType, facultatif) : S'il est défini, renvoie des tenseurs au lieu d'une liste d'entiers Python. Les valeurs acceptables sont :

  • 'pt' : Renvoie des objets torch.Tensor de PyTorch.

  • 'np' : Renvoie des objets Numpy np.ndarray.

build_inputs_with_special_tokens

< >

( token_ids_0: listtoken_ids_1: list[int] | None = None ) → list[int]

Paramètres

  • token_ids_0 (list[int]) — Liste des ID auxquels les jetons spéciaux seront ajoutés.
  • token_ids_1 (list[int], facultatif) — Deuxième liste d'identifiants facultative pour les paires de séquences.

Retourne

list[int]

Liste des identifiants d'entrée avec les jetons spéciaux appropriés.

Construire les entrées du modèle à partir d'une séquence ou d'une paire de séquences pour les tâches de classification de séquences en les concaténant et en ajoutant des jetons spéciaux. Une séquence RoBERTa a le format suivant :

  • séquence unique : <s> X </s>
  • paire de séquences : <s> A </s></s> B </s>

create_token_type_ids_from_sequences

< >

( token_ids_0: listtoken_ids_1: list[int] | None = None ) → list[int]

Paramètres

  • token_ids_0 (list[int]) — Liste d'identifiants.
  • token_ids_1 (list[int], facultatif) — Deuxième liste d'identifiants facultative pour les paires de séquences.

Retourne

list[int]

Liste de zéros.

Crée un masque à partir des deux séquences passées, à utiliser dans une tâche de classification de paires de séquences. RoBERTa n’utilise pas les identifiants de type de jeton, une liste de zéros est donc renvoyée.

encode_plus

< >

( text: str | list[str]text_pair: list[str] | None = Nonexpaths: list[list[int]] | None = Nonenode_labels: list[int] | 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 = Nonestride: int = 0pad_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 )

Paramètres

  • text (str, list[str], list[list[str]]) — La première séquence à encoder. Il peut s’agir d’une chaîne de caractères, d’une liste de chaînes de caractères ou d’une liste de listes de chaînes de caractères.
  • text_pair (list[str] ou list[int], facultatif) — Deuxième séquence facultative à encoder. Il peut s'agir d'une liste de chaînes de caractères (mots d'un exemple unique) ou d'une liste de listes de chaînes de caractères (mots d'un lot d'exemples).
  • 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. Cela est utile si vous souhaitez ajouter automatiquement des jetons bos ou eos.
  • padding (bool, str ou PaddingStrategy, facultatif, défaut : False) — Active et contrôle le padding. Accepte les valeurs suivantes :
    • True ou 'longest' : Ajuster à la séquence la plus longue du lot (ou aucun ajustement si une seule séquence est fournie).
    • 'max_length' : Remplir jusqu'à une longueur maximale spécifiée par l'argument max_length ou jusqu'à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni.
    • False ou 'do_not_pad' (par défaut) : aucun padding (c’est-à-dire, peut produire un lot avec des séquences de longueurs différentes).
  • truncation (bool, str ou TruncationStrategy, facultatif, défaut : False) — Active et contrôle la troncature. Accepte les valeurs suivantes :
    • True ou 'longest_first' : Tronquer à une longueur maximale spécifiée avec l’argument max_length ou à 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'argument max_length ou à 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'argument max_length ou à 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.
    • False ou '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'un des paramètres de troncature/remplissage exige une longueur maximale. 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 à 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 les séquences en dépassement. La valeur de cet argument définit le nombre de jetons en chevauchement.
  • is_split_into_words (bool, facultatif, 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 à 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) et la tokenise. Cela est utile pour la NER ou la classification de tokens.
  • pad_to_multiple_of (int, facultatif) — Si défini, la séquence est rembourrée 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 appliquer le bourrage. Doit être choisi parmi [‘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 acceptées sont :
    • 'pt' : Renvoie des objets torch.Tensor de PyTorch.
    • 'np' : Renvoie des objets Numpy np.ndarray.
  • add_special_tokens (bool, facultatif, par défaut True) — Indique s'il faut ou non encoder les séquences avec les jetons spéciaux relatifs à leur modèle.
  • padding (bool, str ou PaddingStrategy, facultatif, défaut : False) — Active et contrôle le padding. Accepte les valeurs suivantes :
    • True ou 'longest' : Ajuster à la séquence la plus longue du lot (ou aucun ajustement si une seule séquence est fournie).
    • 'max_length' : Remplir jusqu'à une longueur maximale spécifiée par l'argument max_length ou jusqu'à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni.
    • False ou 'do_not_pad' (par défaut) : aucun padding (c’est-à-dire, peut produire un lot avec des séquences de longueurs différentes).
  • truncation (bool, str ou TruncationStrategy, facultatif, défaut : False) — Active et contrôle la troncature. Accepte les valeurs suivantes :
    • True ou 'longest_first' : Tronquer à une longueur maximale spécifiée avec l’argument max_length ou à 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'argument max_length ou à 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'argument max_length ou à 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.
    • False ou '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. S'il n'est pas défini ou s'il est défini sur None, la longueur maximale prédéfinie du modèle sera utilisée si l'un des paramètres de troncature/remplissage exige une longueur maximale. 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 à 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 les séquences en dépassement. La valeur de cet argument définit le nombre de jetons en chevauchement.
  • is_split_into_words (bool, facultatif, par défaut False) — Indique si l'entrée est déjà pré-tokenisée (par exemple, découpée en mots). Définissez cette valeur sur True si vous transmettez des entrées pré-tokenisées afin d'éviter une tokenisation supplémentaire.
  • pad_to_multiple_of (int, facultatif) — Si défini, la séquence sera rembourdée jusqu'à un multiple de la valeur fournie. Cela est particulièrement utile pour permettre l'utilisation des Tensor Cores sur le matériel NVIDIA avec une capacité de calcul >= 7.5 (Volta).
  • return_tensors (str ou TensorType, facultatif) — Si défini, renvoie des tenseurs au lieu d'une liste d'entiers Python. Les valeurs acceptées sont :
    • 'pt' : Renvoie des objets torch.Tensor de PyTorch.
    • 'np' : Renvoie des objets Numpy np.ndarray.

Tokenise et prépare pour le modèle une séquence ou une paire de séquences. .. warning:: Cette méthode est obsolète, __call__ doit être utilisée à la place.

get_xpath_seq

< >

( xpath )

Étant donné l'expression xpath d'un nœud particulier (comme « /html/body/div/li[1]/div/span[2] »), renvoyer une liste d'identifiants de balises et des indices correspondants, en tenant compte de la profondeur maximale.

MarkupLMProcessor

classe transformers.MarkupLMProcessor

< >

( feature_extractortokenizer )

Paramètres

  • feature_extractor (feature_extractor_class) — L'extracteur de caractéristiques est une entrée obligatoire.
  • tokenizer (MarkupLMTokenizer) — Le tokenizer est une entrée obligatoire.

Construit un MarkupLMProcessor qui encapsule un extracteur de caractéristiques et un tokeniseur en un seul processeur.

MarkupLMProcessor offre toutes les fonctionnalités de feature_extractor_class et de MarkupLMTokenizer. Consultez ~feature_extractor_class et ~MarkupLMTokenizer pour plus d’informations.

__call__

< >

( html_strings = Nonenodes = Nonexpaths = Nonenode_labels = Nonequestions = Noneadd_special_tokens: bool = Truepadding: bool | str | transformers.utils.generic.PaddingStrategy = Falsetruncation: bool | str | transformers.tokenization_utils_base.TruncationStrategy = Nonemax_length: int | None = Nonestride: int = 0pad_to_multiple_of: int | 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 = Truereturn_tensors: str | transformers.utils.generic.TensorType | None = None**kwargs ) → ~tokenization_utils_base.BatchEncoding

Paramètres

  • html_strings (str ou list[str], facultatif) — Chaînes HTML brutes à analyser et traiter. Lorsque parse_html=True (par défaut), ces chaînes sont analysées pour extraire automatiquement les nœuds et les xpaths. Si fournies, nodes, xpaths et node_labels ne doivent pas être fournies. Obligatoire lorsque parse_html=True.
  • nodes (list[list[str]], facultatif) — Nœuds HTML pré-extraits sous forme d'une liste de listes, où chaque liste interne contient le contenu textuel des nœuds pour un document unique. Obligatoire lorsque parse_html=False. Ne doit pas être fourni lorsque parse_html=True.
  • xpaths (list[list[str]], facultatif) — Expressions XPath pré-extraites correspondant aux nœuds. Doit être une liste de listes ayant la même structure que nodes, où chaque XPath identifie l'emplacement du nœud correspondant dans l'arborescence HTML. Obligatoire lorsque parse_html=False. Ne doit pas être fourni lorsque parse_html=True.
  • node_labels (list[list[int]], facultatif) — Étiquettes des nœuds, généralement utilisées pour les tâches d’entraînement ou de fine-tuning. Doit être une liste de listes ayant la même structure que nodes, où chaque étiquette correspond à un nœud. Facultatif et utilisé uniquement lorsque parse_html=False.
  • questions (str or list[str], optional) — Question strings for question-answering tasks. When provided, the tokenizer processes questions as the first sequence and nodes as the second sequence (text_pair). If a single string is provided, it is converted to a list to match the batch dimension of the parsed HTML.
  • 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. Cela est utile si vous souhaitez ajouter automatiquement des jetons bos ou eos.
  • padding (bool, str ou PaddingStrategy, facultatif, défaut False) — Active et contrôle le padding. Accepte les valeurs suivantes :
    • True ou 'longest' : Ajuster à la séquence la plus longue du lot (ou aucun ajustement si une seule séquence est fournie).
    • 'max_length' : Remplir jusqu'à une longueur maximale spécifiée par l'argument max_length ou jusqu'à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni.
    • False ou 'do_not_pad' (par défaut) : aucun padding (c’est-à-dire, peut produire un lot avec des séquences de longueurs différentes).
  • truncation (bool, str ou TruncationStrategy, facultatif) — Active et contrôle la troncature. Accepte les valeurs suivantes :
    • True ou 'longest_first' : Tronquer à une longueur maximale spécifiée avec l’argument max_length ou à 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'argument max_length ou à 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'argument max_length ou à 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.
    • False ou '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'un des paramètres de troncature/remplissage exige une longueur maximale. 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, par défaut 0) — Si défini avec une valeur numérique en plus de 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 les séquences en dépassement. La valeur de cet argument définit le nombre de jetons en chevauchement.
  • pad_to_multiple_of (int, facultatif) — Si défini, la séquence est rembourrée 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).
  • return_token_type_ids (bool, facultatif) — Indique s'il faut renvoyer les identifiants de type de jeton. Si la valeur par défaut est conservée, les identifiants de type de jeton sont renvoyé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 tokenizer 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 retourner 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 retourner les jetons en dépassement.
  • return_special_tokens_mask (bool, facultatif, par défaut False) — Indique s'il faut ou non retourner les informations du masque des jetons spéciaux.
  • return_offsets_mapping (bool, facultatif, par défaut False) — Indique s'il faut renvoyer (char_start, char_end) pour chaque jeton.

    Cela 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 retourner les longueurs des entrées encodées.
  • verbose (bool, facultatif, par défaut True) — Indique s'il faut afficher plus d'informations et d'avertissements.
  • return_tensors (Union[str, ~utils.generic.TensorType], facultatif) — Si défini, renvoie des tenseurs d'un framework particulier. Les valeurs acceptables sont :
    • 'pt' : Renvoie des objets torch.Tensor de PyTorch.
    • 'np' : Renvoie des objets NumPy np.ndarray.

Retourne

~tokenization_utils_base.BatchEncoding

  • data (dict, facultatif) — Dictionnaire de listes/tableaux/tenseurs renvoyé par les méthodes __call__/encode_plus/batch_encode_plus (‘input_ids’, ‘attention_mask’, etc.).
  • encoding (tokenizers.Encoding ou Sequence[tokenizers.Encoding], facultatif) — Si le tokenizer est un fast tokenizer qui fournit des informations supplémentaires, comme la correspondance entre l’espace des mots/caractères et l’espace des jetons, l’instance tokenizers.Encoding ou la liste d’instances (pour les lots) contient ces informations.
  • tensor_type (Union[None, str, TensorType], facultatif) — Vous pouvez spécifier un tensor_type ici pour convertir les listes d'entiers en tenseurs PyTorch/Numpy lors de l'initialisation.
  • prepend_batch_axis (bool, facultatif, par défaut False) — Indique s'il faut ou non ajouter un axe de lot lors de la conversion en tenseurs (voir tensor_type ci-dessus). Notez que ce paramètre a un effet si le paramètre tensor_type est défini, sinon il n'a aucun effet.
  • n_sequences (int, facultatif) — Le nombre de séquences d'entrée représentées par chaque encodage (None pour inconnu, 1 pour une seule séquence et 2 pour une paire de séquences).

MarkupLMModel

classe transformers.MarkupLMModel

< >

( config: MarkupLMConfigadd_pooling_layer = True )

Paramètres

  • config (MarkupLMConfig) — 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éfaut True) — Indique s'il faut ajouter une couche de pooling

Le modèle Markuplm brut, qui produit des états cachés bruts sans aucune tête spécifique au sommet.

Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)

Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Nonexpath_tags_seq: typing.Optional[torch.LongTensor] = Nonexpath_subs_seq: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.Tensor)

Paramètres

  • input_ids (torch.LongTensor de forme (batch_size, sequence_length), facultatif) — Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut.

    Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.

    Qu'est-ce que les identifiants d'entrée ?

  • xpath_tags_seq (torch.LongTensor de forme (batch_size, sequence_length, config.max_depth), facultatif) — Identifiants de balises pour chaque jeton de la séquence d’entrée, complétés jusqu’à config.max_depth.
  • xpath_subs_seq (torch.LongTensor de forme (batch_size, sequence_length, config.max_depth), facultatif) — Identifiants de sous-indices pour chaque jeton de la séquence d'entrée, complétés jusqu'à config.max_depth.
  • attention_mask (torch.Tensor de forme (batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans [0, 1]:
    • 1 pour les jetons qui ne sont pas masqués,
    • 0 pour les jetons masqués.

    Qu'est-ce que les masques d'attention ?

  • token_type_ids (torch.LongTensor de 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.

    Qu'est-ce que les identifiants de type de jeton ?

  • position_ids (torch.LongTensor de forme (batch_size, sequence_length), facultatif) — Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle [0, config.n_positions - 1].

    Qu'est-ce que les identifiants de position ?

  • inputs_embeds (torch.Tensor de forme (batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passer input_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices input_ids en vecteurs associés que la matrice de recherche d’intégration interne du modèle.

Retourne

BaseModelOutputWithPooling ou tuple(torch.Tensor)

Un BaseModelOutputWithPooling 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 (MarkupLMConfig) et des entrées.

La méthode forward de MarkupLMModel surcharge la méthode spéciale __call__.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance Module plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

  • last_hidden_state (torch.Tensor de forme (batch_size, sequence_length, hidden_size)) — Séquence d'états cachés à la sortie de la dernière couche du modèle.

  • pooler_output (torch.Tensor de forme (batch_size, hidden_size)) — État caché de la dernière couche du premier jeton de la séquence (jeton de classification) après un traitement supplémentaire par les couches utilisées pour la tâche de pré-entraînement auxiliaire. Par exemple, pour les modèles de la famille BERT, cela renvoie le jeton de classification après traitement par une couche linéaire et une fonction d'activation tanh. Les poids de la couche linéaire sont entraînés à partir de l'objectif de prédiction de la phrase suivante (classification) pendant le pré-entraînement.

  • hidden_states (tuple(torch.Tensor), facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.Tensor (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme (batch_size, sequence_length, hidden_size).

    États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.

  • attentions (tuple(torch.Tensor), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.Tensor (un par couche) de forme (batch_size, num_heads, sequence_length, 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 AutoProcessor, MarkupLMModel

>>> processor = AutoProcessor.from_pretrained("microsoft/markuplm-base")
>>> model = MarkupLMModel.from_pretrained("microsoft/markuplm-base")

>>> html_string = "<html> <head> <title>Page Title</title> </head> </html>"

>>> encoding = processor(html_string, return_tensors="pt")

>>> outputs = model(**encoding)
>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 4, 768]

MarkupLMForSequenceClassification

classe transformers.MarkupLMForSequenceClassification

< >

( config: MarkupLMConfig )

Paramètres

  • config (MarkupLMConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.

Modèle MarkupLM transformer 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

< >

( input_ids: typing.Optional[torch.Tensor] = Nonexpath_tags_seq: typing.Optional[torch.Tensor] = Nonexpath_subs_seq: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → SequenceClassifierOutput or tuple(torch.Tensor)

Paramètres

  • input_ids (torch.Tensor de forme (batch_size, sequence_length), facultatif) — Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut.

    Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.

    Qu'est-ce que les identifiants d'entrée ?

  • xpath_tags_seq (torch.LongTensor de forme (batch_size, sequence_length, config.max_depth), facultatif) — Identifiants de balises pour chaque jeton de la séquence d’entrée, complétés jusqu’à config.max_depth.
  • xpath_subs_seq (torch.LongTensor de forme (batch_size, sequence_length, config.max_depth), facultatif) — Identifiants de sous-indices pour chaque jeton de la séquence d'entrée, complétés jusqu'à config.max_depth.
  • attention_mask (torch.Tensor de forme (batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans [0, 1]:
    • 1 pour les jetons qui ne sont pas masqués,
    • 0 pour les jetons masqués.

    Qu'est-ce que les masques d'attention ?

  • token_type_ids (torch.Tensor de 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.

    Qu'est-ce que les identifiants de type de jeton ?

  • position_ids (torch.Tensor de forme (batch_size, sequence_length), facultatif) — Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle [0, config.n_positions - 1].

    Qu'est-ce que les identifiants de position ?

  • inputs_embeds (torch.Tensor de forme (batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passer input_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices input_ids en vecteurs associés que la matrice de recherche d’intégration interne du modèle.
  • labels (torch.LongTensor de forme (batch_size,), facultatif) — Étiquettes pour le calcul de la perte de classification/régression de séquence. Les indices doivent être dans [0, ..., config.num_labels - 1]. Si config.num_labels == 1, une perte de régression est calculée (perte du carré moyen). Si config.num_labels > 1, une perte de classification est calculée (entropie croisée).

Retourne

SequenceClassifierOutput ou tuple(torch.Tensor)

Un SequenceClassifierOutput 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 (MarkupLMConfig) et des entrées.

La méthode forward de MarkupLMForSequenceClassification redéfinit la méthode spéciale __call__.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance Module plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

  • loss (torch.Tensor de forme (1,), facultatif, renvoyé lorsque labels est fourni) — Perte de classification (ou de régression si config.num_labels==1).

  • logits (torch.Tensor de forme (batch_size, config.num_labels)) — Scores de classification (ou de régression si config.num_labels==1) (avant SoftMax).

  • hidden_states (tuple(torch.Tensor), facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.Tensor (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme (batch_size, sequence_length, hidden_size).

    États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.

  • attentions (tuple(torch.Tensor), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.Tensor (un par couche) de forme (batch_size, num_heads, sequence_length, 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 AutoProcessor, AutoModelForSequenceClassification
>>> import torch

>>> processor = AutoProcessor.from_pretrained("microsoft/markuplm-base")
>>> model = AutoModelForSequenceClassification.from_pretrained("microsoft/markuplm-base", num_labels=7)

>>> html_string = "<html> <head> <title>Page Title</title> </head> </html>"
>>> encoding = processor(html_string, return_tensors="pt")

>>> with torch.no_grad():
...     outputs = model(**encoding)

>>> loss = outputs.loss
>>> logits = outputs.logits

MarkupLMForTokenClassification

classe transformers.MarkupLMForTokenClassification

< >

( config: MarkupLMConfig )

Paramètres

  • config (MarkupLMConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.

Modèle MarkupLM avec une tête token_classification au sommet.

Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)

Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.

forward

< >

( input_ids: typing.Optional[torch.Tensor] = Nonexpath_tags_seq: typing.Optional[torch.Tensor] = Nonexpath_subs_seq: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → MaskedLMOutput or tuple(torch.Tensor)

Paramètres

  • input_ids (torch.Tensor de forme (batch_size, sequence_length), facultatif) — Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut.

    Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.

    Qu'est-ce que les identifiants d'entrée ?

  • xpath_tags_seq (torch.LongTensor de forme (batch_size, sequence_length, config.max_depth), facultatif) — Identifiants de balises pour chaque jeton de la séquence d’entrée, complétés jusqu’à config.max_depth.
  • xpath_subs_seq (torch.LongTensor de forme (batch_size, sequence_length, config.max_depth), facultatif) — Identifiants de sous-indices pour chaque jeton de la séquence d'entrée, complétés jusqu'à config.max_depth.
  • attention_mask (torch.Tensor de forme (batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans [0, 1]:
    • 1 pour les jetons qui ne sont pas masqués,
    • 0 pour les jetons masqués.

    Qu'est-ce que les masques d'attention ?

  • token_type_ids (torch.Tensor de 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.

    Qu'est-ce que les identifiants de type de jeton ?

  • position_ids (torch.Tensor de forme (batch_size, sequence_length), facultatif) — Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle [0, config.n_positions - 1].

    Qu'est-ce que les identifiants de position ?

  • inputs_embeds (torch.Tensor de forme (batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passer input_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices input_ids en vecteurs associés que la matrice de recherche d’intégration interne du modèle.
  • labels (torch.LongTensor de forme (batch_size, sequence_length), facultatif) — Étiquettes pour le calcul de la perte de classification de jetons. Les indices doivent être dans [0, ..., config.num_labels - 1].

Retourne

MaskedLMOutput ou tuple(torch.Tensor)

Un MaskedLMOutput 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 (MarkupLMConfig) et des entrées.

La méthode forward de MarkupLMForTokenClassification redéfinit la méthode spéciale __call__.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance Module plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

  • loss (torch.Tensor de forme (1,), facultatif, renvoyé lorsque labels est fourni) — Perte de modélisation de langage masquée (MLM).

  • logits (torch.Tensor de forme (batch_size, sequence_length, config.vocab_size)) — Scores de prédiction de la tête de modélisation du langage (scores pour chaque jeton du vocabulaire avant SoftMax).

  • hidden_states (tuple(torch.Tensor), facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.Tensor (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme (batch_size, sequence_length, hidden_size).

    États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.

  • attentions (tuple(torch.Tensor), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.Tensor (un par couche) de forme (batch_size, num_heads, sequence_length, 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 AutoProcessor, AutoModelForTokenClassification
>>> import torch

>>> processor = AutoProcessor.from_pretrained("microsoft/markuplm-base")
>>> processor.parse_html = False
>>> model = AutoModelForTokenClassification.from_pretrained("microsoft/markuplm-base", num_labels=7)

>>> nodes = ["hello", "world"]
>>> xpaths = ["/html/body/div/li[1]/div/span", "/html/body/div/li[1]/div/span"]
>>> node_labels = [1, 2]
>>> encoding = processor(nodes=nodes, xpaths=xpaths, node_labels=node_labels, return_tensors="pt")

>>> with torch.no_grad():
...     outputs = model(**encoding)

>>> loss = outputs.loss
>>> logits = outputs.logits

MarkupLMForQuestionAnswering

classe transformers.MarkupLMForQuestionAnswering

< >

( config: MarkupLMConfig )

Paramètres

  • config (MarkupLMConfig) — 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 transformer Markuplm 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

< >

( input_ids: typing.Optional[torch.Tensor] = Nonexpath_tags_seq: typing.Optional[torch.Tensor] = Nonexpath_subs_seq: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonestart_positions: typing.Optional[torch.Tensor] = Noneend_positions: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → QuestionAnsweringModelOutput or tuple(torch.Tensor)

Paramètres

  • input_ids (torch.Tensor de forme (batch_size, sequence_length), facultatif) — Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut.

    Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.

    Qu'est-ce que les identifiants d'entrée ?

  • xpath_tags_seq (torch.LongTensor de forme (batch_size, sequence_length, config.max_depth), facultatif) — Identifiants de balises pour chaque jeton de la séquence d’entrée, complétés jusqu’à config.max_depth.
  • xpath_subs_seq (torch.LongTensor de forme (batch_size, sequence_length, config.max_depth), facultatif) — Identifiants de sous-indices pour chaque jeton de la séquence d'entrée, complétés jusqu'à config.max_depth.
  • attention_mask (torch.Tensor de forme (batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans [0, 1]:
    • 1 pour les jetons qui ne sont pas masqués,
    • 0 pour les jetons masqués.

    Qu'est-ce que les masques d'attention ?

  • token_type_ids (torch.Tensor de 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.

    Qu'est-ce que les identifiants de type de jeton ?

  • position_ids (torch.Tensor de forme (batch_size, sequence_length), facultatif) — Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle [0, config.n_positions - 1].

    Qu'est-ce que les identifiants de position ?

  • inputs_embeds (torch.Tensor de forme (batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passer input_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices input_ids en vecteurs associés que la matrice de recherche d’intégration interne du modèle.
  • start_positions (torch.Tensor de forme (batch_size,), facultatif) — Étiquettes pour la position (index) du début de l'interval étiqueté, utilisées pour le calcul de la perte de classification de jetons. Les positions sont limitées à la longueur de la séquence (sequence_length). Les positions situées en dehors de la séquence ne sont pas prises en compte pour le calcul de la perte.
  • end_positions (torch.Tensor de forme (batch_size,), facultatif) — Étiquettes pour la position (index) de fin de l'intervalle étiqueté, utilisées pour le calcul de la perte de classification de jetons. Les positions sont 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.

Retourne

QuestionAnsweringModelOutput ou tuple(torch.Tensor)

Un QuestionAnsweringModelOutput ou un tuple de torch.Tensor (si return_dict=False est passé ou si config.return_dict=False) comprenant divers éléments en fonction de la configuration (MarkupLMConfig) et des entrées.

La méthode forward de MarkupLMForQuestionAnswering redéfinit la méthode spéciale __call__.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance Module plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

  • loss (torch.Tensor de forme (1,), facultatif, renvoyé lorsque labels est fourni) — La perte totale d'extraction de span est la somme d'une entropie croisée pour les positions de début et de fin.

  • start_logits (torch.Tensor de forme (batch_size, sequence_length)) — Scores de début de segment (avant SoftMax).

  • end_logits (torch.Tensor de forme (batch_size, sequence_length)) — Scores de fin de segment (avant SoftMax).

  • hidden_states (tuple(torch.Tensor), facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.Tensor (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme (batch_size, sequence_length, hidden_size).

    États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.

  • attentions (tuple(torch.Tensor), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.Tensor (un par couche) de forme (batch_size, num_heads, sequence_length, 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 AutoProcessor, MarkupLMForQuestionAnswering
>>> import torch

>>> processor = AutoProcessor.from_pretrained("microsoft/markuplm-base-finetuned-websrc")
>>> model = MarkupLMForQuestionAnswering.from_pretrained("microsoft/markuplm-base-finetuned-websrc")

>>> html_string = "<html> <head> <title>My name is Niels</title> </head> </html>"
>>> question = "What's his name?"

>>> encoding = processor(html_string, questions=question, return_tensors="pt")

>>> with torch.no_grad():
...     outputs = model(**encoding)

>>> answer_start_index = outputs.start_logits.argmax()
>>> answer_end_index = outputs.end_logits.argmax()

>>> predict_answer_tokens = encoding.input_ids[0, answer_start_index : answer_end_index + 1]
>>> processor.decode(predict_answer_tokens).strip()
'Niels'
Update on GitHub

←MarianMT MBart et MBart-50→