Transformers 文件
MarkupLM
並獲得增強的文件體驗
開始使用
MarkupLM
概述
MarkupLM 模型由 Junlong Li、Yiheng Xu、Lei Cui 和 Furu Wei 在 MarkupLM: Pre-training of Text and Markup Language for Visually-rich Document Understanding 中提出。MarkupLM 是 BERT 的一個變體，但應用於 HTML 頁面而非原始文字文件。該模型引入了額外的嵌入層以提高效能，類似於 LayoutLM。
該模型可用於網頁問答或網頁資訊提取等任務。它在兩個重要基準測試中取得了最先進的結果：
論文摘要如下：
將文字、佈局和影像多模態預訓練已在富視覺文件理解 (VrDU) 方面取得了顯著進展，尤其是掃描文件影像等固定佈局文件。然而，仍有大量數字文件的佈局資訊不固定，需要互動式動態渲染才能視覺化，這使得現有的基於佈局的預訓練方法難以應用。在本文中，我們提出了 MarkupLM 用於以標記語言（如 HTML/XML 文件）為骨幹的文件理解任務，其中文字和標記資訊被聯合預訓練。實驗結果表明，預訓練的 MarkupLM 在多個文件理解任務中顯著優於現有的強大基線模型。預訓練模型和程式碼將公開發布。
使用技巧
- 除了
input_ids，forward() 還需要 2 個額外的輸入，即xpath_tags_seq和xpath_subs_seq。這些分別是輸入序列中每個標記的 XPATH 標籤和下標。 - 可以使用 MarkupLMProcessor 為模型準備所有資料。有關更多資訊，請參閱使用指南。
MarkupLM 架構。摘自原始論文。用法：MarkupLMProcessor
為模型準備資料的最簡單方法是使用 MarkupLMProcessor，它內部結合了特徵提取器（MarkupLMFeatureExtractor）和分詞器（MarkupLMTokenizer 或 MarkupLMTokenizerFast）。特徵提取器用於從 HTML 字串中提取所有節點和 xpath，然後將其提供給分詞器，分詞器將其轉換為模型的標記級輸入（input_ids 等）。請注意，如果您只想處理兩個任務中的一個，仍然可以單獨使用特徵提取器和分詞器。
from transformers import MarkupLMFeatureExtractor, MarkupLMTokenizerFast, MarkupLMProcessor
feature_extractor = MarkupLMFeatureExtractor()
tokenizer = MarkupLMTokenizerFast.from_pretrained("microsoft/markuplm-base")
processor = MarkupLMProcessor(feature_extractor, tokenizer)簡而言之，您可以向 MarkupLMProcessor 提供 HTML 字串（以及可能的附加資料），它將建立模型期望的輸入。在內部，處理器首先使用 MarkupLMFeatureExtractor 獲取節點列表和相應的 xpath。然後將節點和 xpath 提供給 MarkupLMTokenizer 或 MarkupLMTokenizerFast，後者將其轉換為標記級 input_ids、attention_mask、token_type_ids、xpath_subs_seq、xpath_tags_seq。可選地，可以向處理器提供節點標籤，這些標籤將轉換為標記級 labels。
MarkupLMFeatureExtractor 在內部使用 Beautiful Soup，一個用於從 HTML 和 XML 檔案中提取資料的 Python 庫。請注意，您仍然可以使用自己選擇的解析解決方案，並將節點和 xpath 自己提供給 MarkupLMTokenizer 或 MarkupLMTokenizerFast。
總共有 5 種處理器支援的用例。下面，我們將列出所有這些用例。請注意，每個用例都適用於批次和非批次輸入（我們將以非批次輸入為例進行說明）。
用例 1：網頁分類（訓練、推理）+ 標記分類（推理），parse_html = True
這是最簡單的情況，其中處理器將使用特徵提取器從 HTML 中獲取所有節點和 xpath。
>>> 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")
>>> print(encoding.keys())
dict_keys(['input_ids', 'token_type_ids', 'attention_mask', 'xpath_tags_seq', 'xpath_subs_seq'])用例 2：網頁分類（訓練、推理）+ 標記分類（推理），parse_html=False
如果已經獲取了所有節點和 xpath，則不需要特徵提取器。在這種情況下，應將節點和相應的 xpath 提供給處理器，並確保將 parse_html 設定為 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")
>>> print(encoding.keys())
dict_keys(['input_ids', 'token_type_ids', 'attention_mask', 'xpath_tags_seq', 'xpath_subs_seq'])用例 3：標記分類（訓練），parse_html=False
對於標記分類任務（例如 SWDE），還可以提供相應的節點標籤來訓練模型。然後，處理器將這些標籤轉換為標記級 labels。預設情況下，它只會標記單詞的第一個詞片段，並將剩餘的詞片段標記為 -100，這是 PyTorch 的 CrossEntropyLoss 的 ignore_index。如果您希望標記單詞的所有詞片段，可以將分詞器初始化為 only_label_first_subword 設定為 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")
>>> print(encoding.keys())
dict_keys(['input_ids', 'token_type_ids', 'attention_mask', 'xpath_tags_seq', 'xpath_subs_seq', 'labels'])用例 4：網頁問答（推理），parse_html=True
對於網頁上的問答任務，您可以向處理器提供一個問題。預設情況下，處理器將使用特徵提取器獲取所有節點和 xpath，並建立 [CLS] 問題標記 [SEP] 單詞標記 [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")
>>> print(encoding.keys())
dict_keys(['input_ids', 'token_type_ids', 'attention_mask', 'xpath_tags_seq', 'xpath_subs_seq'])用例 5：網頁問答（推理），parse_html=False
對於問答任務（例如 WebSRC），您可以向處理器提供一個問題。如果您已自行提取所有節點和 xpath，則可以直接將它們提供給處理器。請務必將 parse_html 設定為 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")
>>> print(encoding.keys())
dict_keys(['input_ids', 'token_type_ids', 'attention_mask', 'xpath_tags_seq', 'xpath_subs_seq'])資源
MarkupLMConfig
類 transformers.MarkupLMConfig
< 來源 >( vocab_size = 30522 hidden_size = 768 num_hidden_layers = 12 num_attention_heads = 12 intermediate_size = 3072 hidden_act = 'gelu' hidden_dropout_prob = 0.1 attention_probs_dropout_prob = 0.1 max_position_embeddings = 512 type_vocab_size = 2 initializer_range = 0.02 layer_norm_eps = 1e-12 pad_token_id = 0 bos_token_id = 0 eos_token_id = 2 max_xpath_tag_unit_embeddings = 256 max_xpath_subs_unit_embeddings = 1024 tag_pad_id = 216 subs_pad_id = 1001 xpath_unit_hidden_size = 32 max_depth = 50 position_embedding_type = 'absolute' use_cache = True classifier_dropout = None **kwargs )
引數
- vocab_size (
int, 可選, 預設為 30522) — MarkupLM 模型的詞彙表大小。定義了傳遞給 MarkupLMModel 的 forward 方法的 inputs_ids 可以表示的不同標記。 - hidden_size (
int, 可選, 預設為 768) — 編碼器層和池化器層的維度。 - num_hidden_layers (
int, 可選, 預設為 12) — Transformer 編碼器中的隱藏層數量。 - num_attention_heads (
int, 可選, 預設為 12) — Transformer 編碼器中每個注意力層的注意力頭數量。 - intermediate_size (
int, 可選, 預設為 3072) — Transformer 編碼器中“中間”（即前饋）層的維度。 - hidden_act (
str或function, 可選, 預設為"gelu") — 編碼器和池化器中的非線性啟用函式（函式或字串）。如果為字串，支援"gelu"、"relu"、"silu"和"gelu_new"。 - hidden_dropout_prob (
float, 可選, 預設為 0.1) — 嵌入、編碼器和池化器中所有全連線層的 dropout 機率。 - attention_probs_dropout_prob (
float, 可選, 預設為 0.1) — 注意力機率的 dropout 比率。 - max_position_embeddings (
int, 可選, 預設為 512) — 此模型可能使用的最大序列長度。通常為了以防萬一，將其設定為一個較大的值（例如 512、1024 或 2048）。 - type_vocab_size (
int, 可選, 預設為 2) — 傳遞到 MarkupLMModel 的token_type_ids的詞彙表大小。 - initializer_range (
float, 可選, 預設為 0.02) — 用於初始化所有權重矩陣的 truncated_normal_initializer 的標準差。 - layer_norm_eps (
float, 可選, 預設為 1e-12) — 層歸一化層使用的 epsilon 值。 - max_tree_id_unit_embeddings (
int, 可選, 預設為 1024) — 樹 ID 單元嵌入可能使用的最大值。通常為了以防萬一，將其設定為一個較大的值（例如 1024）。 - max_xpath_tag_unit_embeddings (
int, 可選, 預設為 256) — xpath 標籤單元嵌入可能使用的最大值。通常為了以防萬一，將其設定為一個較大的值（例如 256）。 - max_xpath_subs_unit_embeddings (
int, optional, defaults to 1024) — xpath 下標單元嵌入可能使用的最大值。通常將其設定為一個較大的值以防萬一（例如 1024）。 - tag_pad_id (
int, optional, defaults to 216) — xpath 標籤中的填充標記 ID。 - subs_pad_id (
int, optional, defaults to 1001) — xpath 下標中的填充標記 ID。 - xpath_tag_unit_hidden_size (
int, optional, defaults to 32) — 每個樹 ID 單元的隱藏大小。一個完整的樹索引將具有 (50*xpath_tag_unit_hidden_size)-dim。 - max_depth (
int, optional, defaults to 50) — xpath 中的最大深度。
這是用於儲存 MarkupLMModel 配置的配置類。它用於根據指定的引數例項化 MarkupLM 模型，定義模型架構。使用預設值例項化配置將生成與 MarkupLM microsoft/markuplm-base 架構類似的配置。
配置物件繼承自 BertConfig，可用於控制模型輸出。有關這些方法的更多資訊，請參閱 BertConfig 的文件。
示例
>>> 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.configMarkupLMFeatureExtractor
構造 MarkupLM 特徵提取器。這可用於從 HTML 字串中獲取節點列表和相應的 xpath。
此特徵提取器繼承自 PreTrainedFeatureExtractor()，其中包含大多數主要方法。使用者應參考此超類以獲取有關這些方法的更多資訊。
__call__
< source >( html_strings ) → BatchFeature
準備一個或多個 HTML 字串以供模型使用的主要方法。
示例
>>> 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
class transformers.MarkupLMTokenizer
< source >( vocab_file merges_file tags_dict errors = '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 = False max_depth = 50 max_width = 1000 pad_width = 1001 pad_token_label = -100 only_label_first_subword = True **kwargs )
引數
- vocab_file (
str) — 詞彙表文件的路徑。 - merges_file (
str) — 合併檔案的路徑。 - errors (
str, optional, defaults to"replace") — 解碼位元組到 UTF-8 時遵循的正規化。有關更多資訊，請參閱 bytes.decode。 - bos_token (
str, optional, defaults to"<s>") — 預訓練期間使用的序列開始標記。可用作序列分類器標記。當使用特殊標記構建序列時，這不是用於序列開始的標記。使用的標記是
cls_token。 - eos_token (
str, optional, defaults to"</s>") — 序列結束標記。當使用特殊標記構建序列時，這不是用於序列結束的標記。使用的標記是
sep_token。 - sep_token (
str, optional, defaults to"</s>") — 分隔符標記，用於從多個序列構建序列時，例如用於序列分類的兩個序列或用於問答的文字和問題。它也用作使用特殊標記構建的序列的最後一個標記。 - cls_token (
str, optional, defaults to"<s>") — 分類器標記，用於序列分類（整個序列的分類而非每個標記的分類）。當使用特殊標記構建序列時，它是序列的第一個標記。 - unk_token (
str, optional, defaults to"<unk>") — 未知標記。不在詞彙表中的標記不能轉換為 ID，而是設定為此標記。 - pad_token (
str, optional, defaults to"<pad>") — 用於填充的標記，例如在對不同長度的序列進行批處理時。 - mask_token (
str, optional, defaults to"<mask>") — 用於遮蔽值的標記。這是在訓練此模型時使用掩碼語言建模時使用的標記。這是模型將嘗試預測的標記。 - add_prefix_space (
bool, optional, defaults toFalse) — 是否在輸入中新增初始空格。這允許將首字視作任何其他單詞。（RoBERTa tokenizer 透過前導空格檢測單詞的開頭）。
構造 MarkupLM 分詞器。基於位元組級位元組對編碼（BPE）。MarkupLMTokenizer 可用於將 HTML 字串轉換為標記級的 input_ids、attention_mask、token_type_ids、xpath_tags_seq 和 xpath_tags_seq。此分詞器繼承自 PreTrainedTokenizer，其中包含大多數主要方法。使用者應參考此超類以獲取有關這些方法的更多資訊。
build_inputs_with_special_tokens
< source >( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None ) → list[int]
透過連線和新增特殊標記，從序列或序列對構建序列分類任務的模型輸入。RoBERTa 序列的格式如下：
- 單個序列：
<s> X </s> - 序列對：
<s> A </s></s> B </s>
get_special_tokens_mask
< source >( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None already_has_special_tokens: bool = False ) → list[int]
引數
- Retrieve 從未新增特殊標記的標記列表中檢索序列 ID。當使用分詞器
prepare_for_model方法新增 — - special 標記時呼叫此方法。 — token_ids_0 (
list[int]): ID 列表。 token_ids_1 (list[int], optional): 可選的第二個 ID 列表，用於序列對。 already_has_special_tokens (bool, optional, defaults toFalse): 標記列表是否已按模型特殊標記格式化。
返回
list[int]
一個範圍為 [0, 1] 的整數列表：1 表示特殊標記，0 表示序列標記。
create_token_type_ids_from_sequences
< source >( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None ) → list[int]
從傳遞給序列對分類任務的兩個序列建立掩碼。RoBERTa 不使用標記型別 ID，因此返回一個零列表。
MarkupLMTokenizerFast
class transformers.MarkupLMTokenizerFast
< source >( vocab_file merges_file tags_dict tokenizer_file = None errors = '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 = False max_depth = 50 max_width = 1000 pad_width = 1001 pad_token_label = -100 only_label_first_subword = True trim_offsets = False **kwargs )
引數
- vocab_file (
str) — 詞彙表文件的路徑。 - merges_file (
str) — 合併檔案的路徑。 - errors (
str, optional, defaults to"replace") — 解碼位元組到 UTF-8 時遵循的正規化。有關更多資訊，請參閱 bytes.decode。 - bos_token (
str, optional, defaults to"<s>") — 預訓練期間使用的序列開始標記。可用作序列分類器標記。當使用特殊標記構建序列時，這不是用於序列開始的標記。使用的標記是
cls_token。 - eos_token (
str, optional, defaults to"</s>") — 序列結束標記。當使用特殊標記構建序列時，這不是用於序列結束的標記。使用的標記是
sep_token。 - sep_token (
str, optional, defaults to"</s>") — 分隔符標記，用於從多個序列構建序列時，例如用於序列分類的兩個序列或用於問答的文字和問題。它也用作使用特殊標記構建的序列的最後一個標記。 - cls_token (
str, optional, defaults to"<s>") — 分類器標記，用於序列分類（整個序列的分類而非每個標記的分類）。當使用特殊標記構建序列時，它是序列的第一個標記。 - unk_token (
str, optional, defaults to"<unk>") — 未知標記。不在詞彙表中的標記不能轉換為 ID，而是設定為此標記。 - pad_token (
str, optional, defaults to"<pad>") — 用於填充的標記，例如在對不同長度的序列進行批處理時。 - mask_token (
str, optional, defaults to"<mask>") — 用於遮蔽值的標記。這是在訓練此模型時使用掩碼語言建模時使用的標記。這是模型將嘗試預測的標記。 - add_prefix_space (
bool, optional, defaults toFalse) — 是否在輸入中新增初始空格。這允許將首字視作任何其他單詞。（RoBERTa tokenizer 透過前導空格檢測單詞的開頭）。
構造 MarkupLM 分詞器。基於位元組級位元組對編碼（BPE）。
MarkupLMTokenizerFast 可用於將 HTML 字串轉換為標記級的 input_ids、attention_mask、token_type_ids、xpath_tags_seq 和 xpath_tags_seq。此分詞器繼承自 PreTrainedTokenizer，其中包含大多數主要方法。
使用者應查閱此超類以獲取有關這些方法的更多資訊。
batch_encode_plus
< 來源 >( batch_text_or_text_pairs: typing.Union[list[str], list[tuple[str, str]], list[list[str]]] is_pair: typing.Optional[bool] = None xpaths: typing.Optional[list[list[list[int]]]] = None node_labels: typing.Union[list[int], list[list[int]], NoneType] = None add_special_tokens: bool = True padding: typing.Union[bool, str, transformers.utils.generic.PaddingStrategy] = False truncation: typing.Union[bool, str, transformers.tokenization_utils_base.TruncationStrategy] = None max_length: typing.Optional[int] = None stride: int = 0 pad_to_multiple_of: typing.Optional[int] = None padding_side: typing.Optional[str] = None return_tensors: typing.Union[str, transformers.utils.generic.TensorType, NoneType] = None return_token_type_ids: typing.Optional[bool] = None return_attention_mask: typing.Optional[bool] = None return_overflowing_tokens: bool = False return_special_tokens_mask: bool = False return_offsets_mapping: bool = False return_length: bool = False verbose: bool = True **kwargs )
add_special_tokens (bool, 可選, 預設為 True): 編碼序列時是否新增特殊標記。這將使用底層 PretrainedTokenizerBase.build_inputs_with_special_tokens 函式，該函式定義了哪些標記會自動新增到輸入 ID 中。如果您想自動新增 bos 或 eos 標記，這將很有用。padding (bool, str 或 PaddingStrategy, 可選, 預設為 False): 啟用並控制填充。接受以下值
True或'longest': 填充到批次中最長的序列（如果只提供一個序列，則不填充）。'max_length': 填充到由引數max_length指定的最大長度，如果未提供該引數，則填充到模型可接受的最大輸入長度。False或'do_not_pad'(預設): 不填充（即，可以輸出具有不同長度序列的批次）。截斷 (bool,str或 TruncationStrategy, 可選, 預設為False): 啟用並控制截斷。接受以下值True或'longest_first': 截斷到由引數max_length指定的最大長度，如果未提供該引數，則截斷到模型可接受的最大輸入長度。如果提供了一對序列（或一批對），這將逐個截斷標記，從對中最長的序列中刪除一個標記。'only_first': 截斷到由引數max_length指定的最大長度，如果未提供該引數，則截斷到模型可接受的最大輸入長度。如果提供了一對序列（或一批對），這將只截斷對的第一個序列。'only_second': 截斷到由引數max_length指定的最大長度，如果未提供該引數，則截斷到模型可接受的最大輸入長度。如果提供了一對序列（或一批對），這將只截斷對的第二個序列。False或'do_not_truncate'(預設): 不截斷（即，可以輸出序列長度大於模型最大可接受輸入大小的批次）。max_length (int, 可選): 控制截斷/填充引數之一要使用的最大長度。
如果未設定或設定為 None，則如果截斷/填充引數之一需要最大長度，則將使用預定義模型最大長度。如果模型沒有特定的最大輸入長度（如 XLNet），則將停用截斷/填充到最大長度。stride (int, 可選, 預設為 0): 如果設定為一個數字，並且同時設定了 max_length，則當 return_overflowing_tokens=True 時返回的溢位標記將包含來自截斷序列末尾的一些標記，以提供截斷序列和溢位序列之間的一些重疊。此引數的值定義了重疊標記的數量。is_split_into_words (bool, 可選, 預設為 False): 輸入是否已經預分詞（例如，分成單詞）。如果設定為 True，分詞器將假定輸入已經分成單詞（例如，透過在空白處分割），然後對其進行分詞。這對於 NER 或標記分類很有用。pad_to_multiple_of (int, 可選): 如果設定，將序列填充到所提供值的倍數。需要啟用 padding。這對於在計算能力 >= 7.5 (Volta) 的 NVIDIA 硬體上啟用 Tensor Core 的使用特別有用。padding_side (str, 可選): 模型應應用填充的側面。應在 ['right', 'left'] 之間選擇。預設值從同名類屬性中選取。return_tensors (str 或 TensorType, 可選): 如果設定，將返回張量而不是 Python 整數列表。可接受的值為
'tf': 返回 TensorFlowtf.constant物件。'pt': 返回 PyTorchtorch.Tensor物件。'np': 返回 Numpynp.ndarray物件。
add_special_tokens (bool, 可選, 預設為 True): 是否使用與模型相關的特殊標記編碼序列。padding (bool, str 或 PaddingStrategy, 可選, 預設為 False): 啟用並控制填充。接受以下值
True或'longest': 填充到批次中最長的序列（如果只提供一個序列，則不填充）。'max_length': 填充到由引數max_length指定的最大長度，如果未提供該引數，則填充到模型可接受的最大輸入長度。False或'do_not_pad'(預設): 不填充（即，可以輸出具有不同長度序列的批次）。截斷 (bool,str或 TruncationStrategy, 可選, 預設為False): 啟用並控制截斷。接受以下值True或'longest_first': 截斷到由引數max_length指定的最大長度，如果未提供該引數，則截斷到模型可接受的最大輸入長度。如果提供了一對序列（或一批對），這將逐個截斷標記，從對中最長的序列中刪除一個標記。'only_first': 截斷到由引數max_length指定的最大長度，如果未提供該引數，則截斷到模型可接受的最大輸入長度。如果提供了一對序列（或一批對），這將只截斷對的第一個序列。'only_second': 截斷到由引數max_length指定的最大長度，如果未提供該引數，則截斷到模型可接受的最大輸入長度。如果提供了一對序列（或一批對），這將只截斷對的第二個序列。False或'do_not_truncate'(預設): 不截斷（即，可以輸出序列長度大於模型最大可接受輸入大小的批次）。max_length (int, 可選): 控制截斷/填充引數之一要使用的最大長度。如果未設定或設定為None，則如果截斷/填充引數之一需要最大長度，則將使用預定義模型最大長度。如果模型沒有特定的最大輸入長度（如 XLNet），則將停用截斷/填充到最大長度。stride (int, 可選, 預設為 0): 如果設定為一個數字，並且同時設定了max_length，則當return_overflowing_tokens=True時返回的溢位標記將包含來自截斷序列末尾的一些標記，以提供截斷序列和溢位序列之間的一些重疊。此引數的值定義了重疊標記的數量。pad_to_multiple_of (int, 可選): 如果設定，將序列填充到所提供值的倍數。這對於在計算能力>= 7.5(Volta) 的 NVIDIA 硬體上啟用 Tensor Core 的使用特別有用。return_tensors (str或 TensorType, 可選): 如果設定，將返回張量而不是 Python 整數列表。可接受的值為'tf': 返回 TensorFlowtf.constant物件。'pt': 返回 PyTorchtorch.Tensor物件。'np': 返回 Numpynp.ndarray物件。
build_inputs_with_special_tokens
< 來源 >( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None ) → list[int]
透過連線和新增特殊標記，從序列或序列對構建序列分類任務的模型輸入。RoBERTa 序列的格式如下：
- 單個序列：
<s> X </s> - 序列對：
<s> A </s></s> B </s>
create_token_type_ids_from_sequences
< 來源 >( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None ) → list[int]
從傳遞給序列對分類任務的兩個序列建立掩碼。RoBERTa 不使用標記型別 ID，因此返回一個零列表。
encode_plus
< 來源 >( text: typing.Union[str, list[str]] text_pair: typing.Optional[list[str]] = None xpaths: typing.Optional[list[list[int]]] = None node_labels: typing.Optional[list[int]] = None add_special_tokens: bool = True padding: typing.Union[bool, str, transformers.utils.generic.PaddingStrategy] = False truncation: typing.Union[bool, str, transformers.tokenization_utils_base.TruncationStrategy] = None max_length: typing.Optional[int] = None stride: int = 0 pad_to_multiple_of: typing.Optional[int] = None padding_side: typing.Optional[str] = None return_tensors: typing.Union[str, transformers.utils.generic.TensorType, NoneType] = None return_token_type_ids: typing.Optional[bool] = None return_attention_mask: typing.Optional[bool] = None return_overflowing_tokens: bool = False return_special_tokens_mask: bool = False return_offsets_mapping: bool = False return_length: bool = False verbose: bool = True **kwargs )
引數
- text (
str,list[str],list[list[str]]) — 要編碼的第一個序列。這可以是字串、字串列表或字串列表的列表。 - text_pair (
list[str]或list[int], 可選) — 要編碼的可選第二個序列。這可以是字串列表（單個示例的單詞）或字串列表的列表（一批示例的單詞）。 - add_special_tokens (
bool, 可選, 預設為True) — 編碼序列時是否新增特殊標記。這將使用底層PretrainedTokenizerBase.build_inputs_with_special_tokens函式，該函式定義了哪些標記會自動新增到輸入 ID 中。如果您想自動新增bos或eos標記，這將很有用。 - padding (
bool,str或 PaddingStrategy, 可選, 預設為False) — 啟用並控制填充。接受以下值：True或'longest': 填充到批次中最長的序列（如果只提供一個序列，則不填充）。'max_length': 填充到由引數max_length指定的最大長度，如果未提供該引數，則填充到模型可接受的最大輸入長度。False或'do_not_pad'(預設): 不填充（即，可以輸出具有不同長度序列的批次）。
- truncation (
bool,str或 TruncationStrategy, 可選, 預設為False) — 啟用並控制截斷。接受以下值：True或'longest_first': 截斷到由引數max_length指定的最大長度，如果未提供該引數，則截斷到模型可接受的最大輸入長度。如果提供了一對序列（或一批對），這將逐個截斷標記，從對中最長的序列中刪除一個標記。'only_first': 截斷到由引數max_length指定的最大長度，如果未提供該引數，則截斷到模型可接受的最大輸入長度。如果提供了一對序列（或一批對），這將只截斷對的第一個序列。'only_second': 截斷到由引數max_length指定的最大長度，如果未提供該引數，則截斷到模型可接受的最大輸入長度。這將只截斷對的第二個序列（如果提供了一對序列（或一批對））。False或'do_not_truncate'(預設): 不截斷（即，可以輸出序列長度大於模型最大可接受輸入大小的批次）。
- max_length (
int, 可選) — 控制截斷/填充引數之一要使用的最大長度。如果未設定或設定為
None，則如果截斷/填充引數之一需要最大長度，則將使用預定義模型最大長度。如果模型沒有特定的最大輸入長度（如 XLNet），則將停用截斷/填充到最大長度。 - stride (
int, 可選, 預設為 0) — 如果設定為一個數字，並且同時設定了max_length，則當return_overflowing_tokens=True時返回的溢位標記將包含來自截斷序列末尾的一些標記，以提供截斷序列和溢位序列之間的一些重疊。此引數的值定義了重疊標記的數量。 - is_split_into_words (
bool, 可選, 預設為False) — 輸入是否已經預分詞（例如，分成單詞）。如果設定為True，分詞器將假定輸入已經分成單詞（例如，透過在空白處分割），然後對其進行分詞。這對於 NER 或標記分類很有用。 - pad_to_multiple_of (
int, 可選) — 如果設定，將序列填充到所提供值的倍數。需要啟用padding。這對於在計算能力>= 7.5(Volta) 的 NVIDIA 硬體上啟用 Tensor Core 的使用特別有用。 - padding_side (
str, 可選) — 模型應應用填充的側面。應在 ['right', 'left'] 之間選擇。預設值從同名類屬性中選取。 - return_tensors (
str或 TensorType, 可選) — 如果設定，將返回張量而不是 Python 整數列表。可接受的值為：'tf': 返回 TensorFlowtf.constant物件。'pt': 返回 PyTorchtorch.Tensor物件。'np': 返回 Numpynp.ndarray物件。
- add_special_tokens (
bool, 可選, 預設為True) — 是否使用與模型相關的特殊標記編碼序列。 - padding (
bool,str或 PaddingStrategy, 可選, 預設為False) — 啟用並控制填充。接受以下值：True或'longest': 填充到批次中最長的序列（如果只提供一個序列，則不填充）。'max_length': 填充到由引數max_length指定的最大長度，如果未提供該引數，則填充到模型可接受的最大輸入長度。False或'do_not_pad'(預設): 不填充（即，可以輸出具有不同長度序列的批次）。
- truncation (
bool,str或 TruncationStrategy, 可選, 預設為False) — 啟用並控制截斷。接受以下值：True或'longest_first': 截斷到由引數max_length指定的最大長度，如果未提供該引數，則截斷到模型可接受的最大輸入長度。如果提供了一對序列（或一批對），這將逐個截斷標記，從對中最長的序列中刪除一個標記。'only_first': 截斷到由引數max_length指定的最大長度，如果未提供該引數，則截斷到模型可接受的最大輸入長度。如果提供了一對序列（或一批對），這將只截斷對的第一個序列。'only_second': 截斷到由引數max_length指定的最大長度，如果未提供該引數，則截斷到模型可接受的最大輸入長度。這將只截斷對的第二個序列（如果提供了一對序列（或一批對））。False或'do_not_truncate'(預設): 不截斷（即，可以輸出序列長度大於模型最大可接受輸入大小的批次）。
- max_length (
int, 可選) — 控制截斷/填充引數之一要使用的最大長度。如果未設定或設定為None，則如果截斷/填充引數之一需要最大長度，則將使用預定義模型最大長度。如果模型沒有特定的最大輸入長度（如 XLNet），則將停用截斷/填充到最大長度。 - stride (
int, 可選, 預設為 0) — 如果設定為一個數字，並且同時設定了max_length，則當return_overflowing_tokens=True時返回的溢位標記將包含來自截斷序列末尾的一些標記，以提供截斷序列和溢位序列之間的一些重疊。此引數的值定義了重疊標記的數量。 - pad_to_multiple_of (
int, 可選) — 如果設定，將序列填充到所提供值的倍數。這對於在計算能力>= 7.5(Volta) 的 NVIDIA 硬體上啟用 Tensor Core 的使用特別有用。 - return_tensors (
str或 TensorType, 可選) — 如果設定，將返回張量而不是 Python 整數列表。可接受的值為：'tf': 返回 TensorFlowtf.constant物件。'pt': 返回 PyTorchtorch.Tensor物件。'np': 返回 Numpynp.ndarray物件。
對序列或序列對進行分詞併為模型準備。.. 警告:: 此方法已棄用，應改用 __call__。
給定一個特定節點（如“/html/body/div/li[1]/div/span[2]”）的 xpath 表示式，返回一個標記 ID 及其相應下標的列表，同時考慮到最大深度。
MarkupLMProcessor
class transformers.MarkupLMProcessor
< 來源 >( *args **kwargs )
引數
- feature_extractor (
MarkupLMFeatureExtractor) — MarkupLMFeatureExtractor 的一個例項。特徵提取器是必需的輸入。 - tokenizer (
MarkupLMTokenizer或MarkupLMTokenizerFast) — MarkupLMTokenizer 或 MarkupLMTokenizerFast 的一個例項。分詞器是必需的輸入。 - parse_html (
bool, 可選, 預設為True) — 是否使用MarkupLMFeatureExtractor將 HTML 字串解析為節點和相應的 xpath。
構建一個 MarkupLM 處理器，它將 MarkupLM 特徵提取器和 MarkupLM 分詞器組合成一個單一的處理器。
MarkupLMProcessor 提供了準備模型資料所需的所有功能。
它首先使用 MarkupLMFeatureExtractor 從一個或多個 HTML 字串中提取節點和相應的 xpath。接下來，這些內容連同附加引數一起提供給 MarkupLMTokenizer 或 MarkupLMTokenizerFast，後者將它們轉換為標記級別的 input_ids、attention_mask、token_type_ids、xpath_tags_seq 和 xpath_subs_seq。
__call__
< 來源 >( html_strings = None nodes = None xpaths = None node_labels = None questions = None add_special_tokens: bool = True padding: typing.Union[bool, str, transformers.utils.generic.PaddingStrategy] = False truncation: typing.Union[bool, str, transformers.tokenization_utils_base.TruncationStrategy] = None max_length: typing.Optional[int] = None stride: int = 0 pad_to_multiple_of: typing.Optional[int] = None return_token_type_ids: typing.Optional[bool] = None return_attention_mask: typing.Optional[bool] = None return_overflowing_tokens: bool = False return_special_tokens_mask: bool = False return_offsets_mapping: bool = False return_length: bool = False verbose: bool = True return_tensors: typing.Union[str, transformers.utils.generic.TensorType, NoneType] = None **kwargs )
此方法首先將 html_strings 引數轉發到 call()。接下來，它將 nodes 和 xpaths 以及附加引數傳遞給 __call__() 並返回輸出。
（可選）還可以提供 text 引數，該引數作為第一個序列傳遞。
有關更多資訊，請參閱上述兩種方法的文件字串。
MarkupLMModel
class transformers.MarkupLMModel
< 來源 >( config add_pooling_layer = True )
引數
- config (MarkupLMModel) — 包含模型所有引數的模型配置類。使用配置檔案初始化不會載入與模型相關的權重，只加載配置。請查閱 from_pretrained() 方法載入模型權重。
- add_pooling_layer (
bool, 可選, 預設為True) — 是否新增池化層
裸 MarkupLM 模型，輸出原始隱藏狀態，頂部沒有任何特定頭部。
此模型繼承自 PreTrainedModel。查閱超類文件，瞭解庫為其所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、剪枝頭部等）。
此模型也是 PyTorch torch.nn.Module 子類。將其作為常規 PyTorch 模組使用，並查閱 PyTorch 文件以瞭解與一般用法和行為相關的所有事項。
forward
< 來源 >( input_ids: typing.Optional[torch.LongTensor] = None xpath_tags_seq: typing.Optional[torch.LongTensor] = None xpath_subs_seq: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.FloatTensor] = None token_type_ids: typing.Optional[torch.LongTensor] = None position_ids: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions 或 tuple(torch.FloatTensor)
引數
- input_ids (
torch.LongTensor，形狀為(batch_size, sequence_length)，可選) — 詞彙表中輸入序列標記的索引。預設情況下會忽略填充。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- xpath_tags_seq (
torch.LongTensor，形狀為(batch_size, sequence_length, config.max_depth)，可選) — 輸入序列中每個標記的標籤 ID，填充至 config.max_depth。 - xpath_subs_seq (
torch.LongTensor，形狀為(batch_size, sequence_length, config.max_depth)，可選) — 輸入序列中每個標記的下標 ID，填充至 config.max_depth。 - attention_mask (
torch.FloatTensor，形狀為(batch_size, sequence_length)，可選) — 用於避免對填充標記索引執行注意力操作的掩碼。掩碼值選擇範圍為[0, 1]：- 1 表示標記未被掩碼，
- 0 表示標記已被掩碼。
- token_type_ids (
torch.LongTensor，形狀為(batch_size, sequence_length)，可選) — 用於指示輸入的第一部分和第二部分的片段標記索引。索引選擇範圍為[0, 1]：- 0 對應於句子 A 標記，
- 1 對應於句子 B 標記。
- position_ids (
torch.LongTensor，形狀為(batch_size, sequence_length)，可選) — 每個輸入序列標記在位置嵌入中的位置索引。選擇範圍為[0, config.n_positions - 1]。 - head_mask (
torch.FloatTensor，形狀為(num_heads,)或(num_layers, num_heads)，可選) — 用於使自注意力模組的選定頭部無效的掩碼。掩碼值選擇範圍為[0, 1]：- 1 表示頭部未被掩碼，
- 0 表示頭部已被掩碼。
- inputs_embeds (
torch.FloatTensor，形狀為(batch_size, sequence_length, hidden_size)，可選) — 另外，除了傳遞input_ids，你也可以選擇直接傳遞一個嵌入表示。如果你希望對如何將input_ids索引轉換為相關向量擁有比模型內部嵌入查詢矩陣更多的控制權，這將很有用。 - output_attentions (
bool，可選) — 是否返回所有注意力層的注意力張量。更多詳細資訊請參閱返回張量中的attentions。 - output_hidden_states (
bool，可選) — 是否返回所有層的隱藏狀態。更多詳細資訊請參閱返回張量中的hidden_states。 - return_dict (
bool，可選) — 是否返回 ModelOutput 而不是普通元組。
返回
transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions 或 tuple(torch.FloatTensor)
一個 transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions 或一個 torch.FloatTensor 元組（如果傳遞 return_dict=False 或 config.return_dict=False），包含根據配置（MarkupLMConfig）和輸入而定的各種元素。
-
last_hidden_state (
torch.FloatTensor, 形狀為(batch_size, sequence_length, hidden_size)) — 模型最後一層輸出的隱藏狀態序列。 -
pooler_output (
torch.FloatTensor，形狀為(batch_size, hidden_size)) — 經過用於輔助預訓練任務的層進一步處理後，序列中第一個標記（分類標記）的最後一層隱藏狀態。例如，對於 BERT 家族模型，這會返回經過線性層和 tanh 啟用函式處理後的分類標記。線性層權重在預訓練期間透過下一個句子預測（分類）目標進行訓練。 -
hidden_states (
tuple(torch.FloatTensor)，可選，當傳遞output_hidden_states=True或config.output_hidden_states=True時返回) —torch.FloatTensor元組（如果模型有嵌入層，則為嵌入層輸出一個，每個層輸出一個），形狀為(batch_size, sequence_length, hidden_size)。模型在每個層輸出的隱藏狀態以及可選的初始嵌入輸出。
-
attentions (
tuple(torch.FloatTensor)，可選，當傳遞output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor元組（每個層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。
-
cross_attentions (
tuple(torch.FloatTensor)，可選，當傳遞output_attentions=True和config.add_cross_attention=True或config.output_attentions=True時返回) —torch.FloatTensor元組（每個層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。解碼器交叉注意力層的注意力權重，在注意力 softmax 之後，用於計算交叉注意力頭中的加權平均。
-
past_key_values (
Cache，可選，當傳遞use_cache=True或config.use_cache=True時返回) — 這是一個 Cache 例項。有關更多詳細資訊，請參閱我們的 kv 快取指南。包含預先計算的隱藏狀態（自注意力塊中的鍵和值，如果
config.is_encoder_decoder=True，則可選地包含交叉注意力塊中的鍵和值），可用於（請參閱past_key_values輸入）加快順序解碼。
MarkupLMModel 的 forward 方法，覆蓋了 __call__ 特殊方法。
儘管前向傳播的實現需要在該函式中定義，但之後應呼叫 Module 例項而不是此函式，因為前者負責執行預處理和後處理步驟，而後者會默默忽略它們。
示例
>>> 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
class transformers.MarkupLMForSequenceClassification
< 來源 >( config )
引數
- config (MarkupLMForSequenceClassification) — 包含模型所有引數的模型配置類。使用配置檔案初始化不會載入與模型相關的權重，只加載配置。請檢視 from_pretrained() 方法來載入模型權重。
MarkupLM 模型 Transformer，頂部帶有序列分類/迴歸頭部（池化輸出頂部的一個線性層），例如用於 GLUE 任務。
此模型繼承自 PreTrainedModel。查閱超類文件，瞭解庫為其所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、剪枝頭部等）。
此模型也是 PyTorch torch.nn.Module 子類。將其作為常規 PyTorch 模組使用，並查閱 PyTorch 文件以瞭解與一般用法和行為相關的所有事項。
forward
< 來源 >( input_ids: typing.Optional[torch.Tensor] = None xpath_tags_seq: typing.Optional[torch.Tensor] = None xpath_subs_seq: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None token_type_ids: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None labels: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.SequenceClassifierOutput 或 tuple(torch.FloatTensor)
引數
- input_ids (
torch.Tensor，形狀為(batch_size, sequence_length)，可選) — 詞彙表中輸入序列標記的索引。預設情況下會忽略填充。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- xpath_tags_seq (
torch.LongTensor，形狀為(batch_size, sequence_length, config.max_depth)，可選) — 輸入序列中每個標記的標籤 ID，填充至 config.max_depth。 - xpath_subs_seq (
torch.LongTensor，形狀為(batch_size, sequence_length, config.max_depth)，可選) — 輸入序列中每個標記的下標 ID，填充至 config.max_depth。 - attention_mask (
torch.Tensor，形狀為(batch_size, sequence_length)，可選) — 用於避免對填充標記索引執行注意力操作的掩碼。掩碼值選擇範圍為[0, 1]：- 1 表示標記未被掩碼，
- 0 表示標記已被掩碼。
- token_type_ids (
torch.Tensor，形狀為(batch_size, sequence_length)，可選) — 用於指示輸入的第一部分和第二部分的片段標記索引。索引選擇範圍為[0, 1]：- 0 對應於句子 A 標記，
- 1 對應於句子 B 標記。
- position_ids (
torch.Tensor，形狀為(batch_size, sequence_length)，可選) — 每個輸入序列標記在位置嵌入中的位置索引。選擇範圍為[0, config.n_positions - 1]。 - head_mask (
torch.Tensor，形狀為(num_heads,)或(num_layers, num_heads)，可選) — 用於使自注意力模組的選定頭部無效的掩碼。掩碼值選擇範圍為[0, 1]：- 1 表示頭部未被掩碼，
- 0 表示頭部已被掩碼。
- inputs_embeds (
torch.Tensor，形狀為(batch_size, sequence_length, hidden_size)，可選) — 另外，除了傳遞input_ids，你也可以選擇直接傳遞一個嵌入表示。如果你希望對如何將input_ids索引轉換為相關向量擁有比模型內部嵌入查詢矩陣更多的控制權，這將很有用。 - labels (
torch.LongTensor，形狀為(batch_size,)，可選) — 用於計算序列分類/迴歸損失的標籤。索引應在[0, ..., config.num_labels - 1]範圍內。如果config.num_labels == 1，則計算迴歸損失 (均方誤差損失)；如果config.num_labels > 1，則計算分類損失 (交叉熵)。 - output_attentions (
bool，可選) — 是否返回所有注意力層的注意力張量。更多詳細資訊請參閱返回張量中的attentions。 - output_hidden_states (
bool，可選) — 是否返回所有層的隱藏狀態。更多詳細資訊請參閱返回張量中的hidden_states。 - return_dict (
bool，可選) — 是否返回 ModelOutput 而不是普通元組。
返回
transformers.modeling_outputs.SequenceClassifierOutput 或 tuple(torch.FloatTensor)
一個 transformers.modeling_outputs.SequenceClassifierOutput 或一個 torch.FloatTensor 元組（如果傳遞 return_dict=False 或 config.return_dict=False），包含根據配置（MarkupLMConfig）和輸入而定的各種元素。
-
loss (形狀為
(1,)的torch.FloatTensor，可選，當提供labels時返回) — 分類損失（如果 config.num_labels==1，則為迴歸損失）。 -
logits (形狀為
(batch_size, config.num_labels)的torch.FloatTensor) — 分類（如果 config.num_labels==1，則為迴歸）分數（SoftMax 之前）。 -
hidden_states (
tuple(torch.FloatTensor)，可選，當傳遞output_hidden_states=True或config.output_hidden_states=True時返回) —torch.FloatTensor元組（如果模型有嵌入層，則為嵌入層輸出一個，每個層輸出一個），形狀為(batch_size, sequence_length, hidden_size)。模型在每個層輸出的隱藏狀態以及可選的初始嵌入輸出。
-
attentions (
tuple(torch.FloatTensor)，可選，當傳遞output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor元組（每個層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。
MarkupLMForSequenceClassification 的 forward 方法，覆蓋了 __call__ 特殊方法。
儘管前向傳播的實現需要在該函式中定義，但之後應呼叫 Module 例項而不是此函式，因為前者負責執行預處理和後處理步驟，而後者會默默忽略它們。
示例
>>> 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.logitsMarkupLMForTokenClassification
class transformers.MarkupLMForTokenClassification
< 來源 >( config )
引數
- config (MarkupLMForTokenClassification) — 包含模型所有引數的模型配置類。使用配置檔案初始化不會載入與模型相關的權重，只加載配置。請檢視 from_pretrained() 方法來載入模型權重。
MarkupLM 模型，頂部帶有 token_classification 頭部。
此模型繼承自 PreTrainedModel。查閱超類文件，瞭解庫為其所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、剪枝頭部等）。
此模型也是 PyTorch torch.nn.Module 子類。將其作為常規 PyTorch 模組使用，並查閱 PyTorch 文件以瞭解與一般用法和行為相關的所有事項。
forward
< 來源 >( input_ids: typing.Optional[torch.Tensor] = None xpath_tags_seq: typing.Optional[torch.Tensor] = None xpath_subs_seq: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None token_type_ids: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None labels: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.MaskedLMOutput 或 tuple(torch.FloatTensor)
引數
- input_ids (
torch.Tensor，形狀為(batch_size, sequence_length)，可選) — 詞彙表中輸入序列標記的索引。預設情況下會忽略填充。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- xpath_tags_seq (
torch.LongTensor，形狀為(batch_size, sequence_length, config.max_depth)，可選) — 輸入序列中每個標記的標籤 ID，填充至 config.max_depth。 - xpath_subs_seq (
torch.LongTensor，形狀為(batch_size, sequence_length, config.max_depth)，可選) — 輸入序列中每個標記的下標 ID，填充至 config.max_depth。 - attention_mask (
torch.Tensor，形狀為(batch_size, sequence_length)，可選) — 用於避免對填充標記索引執行注意力操作的掩碼。掩碼值選擇範圍為[0, 1]：- 1 表示標記未被掩碼，
- 0 表示標記已被掩碼。
- token_type_ids (
torch.Tensor，形狀為(batch_size, sequence_length)，可選) — 用於指示輸入的第一部分和第二部分的片段標記索引。索引選擇範圍為[0, 1]：- 0 對應於句子 A 標記，
- 1 對應於句子 B 標記。
- position_ids (
torch.Tensor，形狀為(batch_size, sequence_length)，可選) — 每個輸入序列標記在位置嵌入中的位置索引。選擇範圍為[0, config.n_positions - 1]。 - head_mask (
torch.Tensor，形狀為(num_heads,)或(num_layers, num_heads)，可選) — 用於使自注意力模組的選定頭部無效的掩碼。掩碼值選擇範圍為[0, 1]：- 1 表示頭部未被掩碼，
- 0 表示頭部已被掩碼。
- inputs_embeds (
torch.Tensor，形狀為(batch_size, sequence_length, hidden_size)，可選) — 另外，除了傳遞input_ids，你也可以選擇直接傳遞一個嵌入表示。如果你希望對如何將input_ids索引轉換為相關向量擁有比模型內部嵌入查詢矩陣更多的控制權，這將很有用。 - labels (
torch.LongTensor，形狀為(batch_size, sequence_length)，可選) — 用於計算標記分類損失的標籤。索引應在[0, ..., config.num_labels - 1]範圍內。 - output_attentions (
bool，可選) — 是否返回所有注意力層的注意力張量。更多詳細資訊請參閱返回張量中的attentions。 - output_hidden_states (
bool, 可選) — 是否返回所有層的隱藏狀態。更多詳細資訊請參閱返回張量中的hidden_states。 - return_dict (
bool, 可選) — 是否返回ModelOutput而不是普通元組。
返回
transformers.modeling_outputs.MaskedLMOutput 或 tuple(torch.FloatTensor)
一個transformers.modeling_outputs.MaskedLMOutput或一個torch.FloatTensor元組（如果傳入return_dict=False或config.return_dict=False），包含根據配置（MarkupLMConfig）和輸入的不同元素。
-
loss (形狀為
(1,)的torch.FloatTensor，可選，當提供labels時返回) — 掩碼語言建模 (MLM) 損失。 -
logits (形狀為
(batch_size, sequence_length, config.vocab_size)的torch.FloatTensor) — 語言建模頭部的預測分數（SoftMax 之前的每個詞彙標記的分數）。 -
hidden_states (
tuple(torch.FloatTensor)，可選，當傳遞output_hidden_states=True或config.output_hidden_states=True時返回) —torch.FloatTensor元組（如果模型有嵌入層，則為嵌入層輸出一個，每個層輸出一個），形狀為(batch_size, sequence_length, hidden_size)。模型在每個層輸出的隱藏狀態以及可選的初始嵌入輸出。
-
attentions (
tuple(torch.FloatTensor)，可選，當傳遞output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor元組（每個層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。
MarkupLMForTokenClassification的前向方法，覆蓋了__call__特殊方法。
儘管前向傳播的實現需要在該函式中定義，但之後應呼叫 Module 例項而不是此函式，因為前者負責執行預處理和後處理步驟，而後者會默默忽略它們。
示例
>>> 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.logitsMarkupLMForQuestionAnswering
class transformers.MarkupLMForQuestionAnswering
< source >( config )
引數
- config (MarkupLMForQuestionAnswering) — 包含模型所有引數的模型配置類。使用配置檔案初始化不會載入與模型關聯的權重，只加載配置。請檢視from_pretrained()方法來載入模型權重。
Markuplm Transformer模型，其上帶有一個用於SQuAD等抽取式問答任務的跨度分類頭部（在隱藏狀態輸出上新增一個線性層來計算跨度起始 logits和跨度結束 logits）。
此模型繼承自 PreTrainedModel。查閱超類文件，瞭解庫為其所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、剪枝頭部等）。
此模型也是 PyTorch torch.nn.Module 子類。將其作為常規 PyTorch 模組使用，並查閱 PyTorch 文件以瞭解與一般用法和行為相關的所有事項。
forward
< source >( input_ids: typing.Optional[torch.Tensor] = None xpath_tags_seq: typing.Optional[torch.Tensor] = None xpath_subs_seq: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None token_type_ids: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None start_positions: typing.Optional[torch.Tensor] = None end_positions: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.QuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)
引數
- input_ids (
torch.Tensor形狀為(batch_size, sequence_length), 可選) — 詞彙表中輸入序列 token 的索引。預設情況下會忽略填充。可以使用AutoTokenizer獲取索引。有關詳細資訊，請參閱PreTrainedTokenizer.encode()和PreTrainedTokenizer.call()。
- xpath_tags_seq (
torch.LongTensor形狀為(batch_size, sequence_length, config.max_depth), 可選) — 輸入序列中每個 token 的標籤 ID，填充至 config.max_depth。 - xpath_subs_seq (
torch.LongTensor形狀為(batch_size, sequence_length, config.max_depth), 可選) — 輸入序列中每個 token 的下標 ID，填充至 config.max_depth。 - attention_mask (
torch.Tensor形狀為(batch_size, sequence_length), 可選) — 用於避免對填充 token 索引執行注意力操作的掩碼。掩碼值在[0, 1]中選擇：- 1 表示 token 未被掩蓋，
- 0 表示 token 已被掩蓋。
- token_type_ids (
torch.Tensor形狀為(batch_size, sequence_length), 可選) — 用於指示輸入的第一部分和第二部分的片段 token 索引。索引在[0, 1]中選擇：- 0 對應於句子 A token，
- 1 對應於句子 B token。
- position_ids (
torch.Tensor形狀為(batch_size, sequence_length), 可選) — 位置嵌入中每個輸入序列 token 的位置索引。在[0, config.n_positions - 1]範圍內選擇。 - head_mask (
torch.Tensor形狀為(num_heads,)或(num_layers, num_heads), 可選) — 用於使自注意力模組的選定頭部無效的掩碼。掩碼值在[0, 1]中選擇：- 1 表示頭部未被掩蓋，
- 0 表示頭部已被掩蓋。
- inputs_embeds (
torch.Tensor形狀為(batch_size, sequence_length, hidden_size), 可選) — 可選地，您可以選擇直接傳入嵌入表示，而不是傳入input_ids。如果您希望對如何將input_ids索引轉換為關聯向量有比模型內部嵌入查詢矩陣更多的控制，這將很有用。 - start_positions (
torch.Tensor形狀為(batch_size,), 可選) — 用於計算 token 分類損失的已標記跨度起始位置（索引）的標籤。位置被限制為序列的長度（sequence_length）。序列外的位置不計入損失計算。 - end_positions (
torch.Tensor形狀為(batch_size,), 可選) — 用於計算 token 分類損失的已標記跨度結束位置（索引）的標籤。位置被限制為序列的長度（sequence_length）。序列外的位置不計入損失計算。 - output_attentions (
bool, 可選) — 是否返回所有注意力層的注意力張量。更多詳細資訊請參閱返回張量中的attentions。 - output_hidden_states (
bool, 可選) — 是否返回所有層的隱藏狀態。更多詳細資訊請參閱返回張量中的hidden_states。 - return_dict (
bool, 可選) — 是否返回ModelOutput而不是普通元組。
返回
transformers.modeling_outputs.QuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)
一個transformers.modeling_outputs.QuestionAnsweringModelOutput或一個torch.FloatTensor元組（如果傳入return_dict=False或config.return_dict=False），包含根據配置（MarkupLMConfig）和輸入的不同元素。
-
loss (
torch.FloatTensorof shape(1,), 可選, 當提供labels時返回) — 總範圍提取損失是起始位置和結束位置的交叉熵之和。 -
start_logits (
torch.FloatTensorof shape(batch_size, sequence_length)) — 範圍起始分數（SoftMax 之前）。 -
end_logits (
torch.FloatTensorof shape(batch_size, sequence_length)) — 範圍結束分數（SoftMax 之前）。 -
hidden_states (
tuple(torch.FloatTensor)，可選，當傳遞output_hidden_states=True或config.output_hidden_states=True時返回) —torch.FloatTensor元組（如果模型有嵌入層，則為嵌入層輸出一個，每個層輸出一個），形狀為(batch_size, sequence_length, hidden_size)。模型在每個層輸出的隱藏狀態以及可選的初始嵌入輸出。
-
attentions (
tuple(torch.FloatTensor)，可選，當傳遞output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor元組（每個層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。
MarkupLMForQuestionAnswering的前向方法，覆蓋了__call__特殊方法。
儘管前向傳播的實現需要在該函式中定義，但之後應呼叫 Module 例項而不是此函式，因為前者負責執行預處理和後處理步驟，而後者會默默忽略它們。
示例
>>> 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'