Transformers documentation
MarkupLM
该模型于 2021-10-16 在 HF papers 上发布，并于 2022-09-30 贡献至 Hugging Face Transformers。
MarkupLM
概述
MarkupLM: Pre-training of Text and Markup Language for Visually-rich Document Understanding 一文中，Junlong Li、Yiheng Xu、Lei Cui 和 Furu Wei 提出了 MarkupLM 模型。MarkupLM 是 BERT，但应用于 HTML 页面而非原始文本文档。该模型引入了额外的嵌入层以提升性能，类似于 LayoutLM。
该模型可用于网页问答或从网页中提取信息等任务。它在 2 个重要基准测试上取得了最先进的结果：
该论文的摘要如下：
基于文本、版式和图像的多模态预训练在视觉丰富文档理解（VrDU）领域取得了显著进展，尤其适用于扫描文档图像等固定版式文档。然而，仍有大量数字文档的版式信息并非固定，需要交互式、动态地渲染以进行可视化，这使得现有的基于版式的预训练方法难以直接应用。本文提出了 MarkupLM，用于以标记语言（如基于 HTML/XML 的文档）为骨干的文档理解任务，其中文本和标记信息被联合预训练。实验结果表明，预训练的 MarkupLM 在多个文档理解任务上显著优于现有的强基线模型。预训练模型和代码将公开可用。
使用技巧
- 除了
input_ids之外，forward() 还需要两个额外的输入，即xpath_tags_seq和xpath_subs_seq。 它们分别是输入序列中每个 token 的 XPATH 标签和下标。 - 可以使用 MarkupLMProcessor 为模型准备所有数据。有关更多信息，请参阅使用指南。
MarkupLM architecture. Taken from the original paper. 用法：MarkupLMProcessor
为模型准备数据最简单的方式是使用 MarkupLMProcessor，它在内部组合了特征提取器
（MarkupLMFeatureExtractor）和分词器（MarkupLMTokenizer 或 MarkupLMTokenizerFast）。特征提取器用于
从 HTML 字符串中提取所有节点和 xpath，然后将其提供给分词器，分词器会将其转换为模型的 token 级输入（input_ids 等）。请注意，如果你只想处理这两项任务中的一项，仍然可以单独使用特征提取器和分词器。
from transformers import MarkupLMFeatureExtractor, MarkupLMProcessor, MarkupLMTokenizerFast
feature_extractor = MarkupLMFeatureExtractor()
tokenizer = MarkupLMTokenizerFast.from_pretrained("microsoft/markuplm-base")
processor = MarkupLMProcessor(feature_extractor, tokenizer)简而言之，可以向 MarkupLMProcessor 提供 HTML 字符串（以及可能的附加数据），它会生成模型所需的输入。在内部，处理器首先使用 MarkupLMFeatureExtractor 获取节点列表及对应的 xpath。随后，这些节点和 xpath 会被提供给 MarkupLMTokenizer 或 MarkupLMTokenizerFast，由它们将其转换为 token 级别的 input_ids、attention_mask、token_type_ids、xpath_subs_seq 和 xpath_tags_seq。可选地，还可以向处理器提供节点标签，这些标签会被转换为 token 级别的 labels。
MarkupLMFeatureExtractor 底层使用了 Beautiful Soup，这是一个用于从 HTML 和 XML 文件中提取数据的 Python 库。请注意，您仍然可以使用自己选择的解析方案，并自行向 MarkupLMTokenizer 或 MarkupLMTokenizerFast 提供节点和 xpath。
总共，该处理器支持 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").to(model.device)
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").to(model.device)
print(encoding.keys())
dict_keys(['input_ids', 'token_type_ids', 'attention_mask', 'xpath_tags_seq', 'xpath_subs_seq'])用例 3：token 分类（训练），parse_html=False
对于词元分类任务（例如 SWDE），也可以提供对应的节点标签来训练模型。处理器随后会将其转换为词元级别的 labels。默认情况下，它只会为单词的第一个 wordpiece 打标签，并将其余 wordpiece 标记为 -100，即 PyTorch 的 CrossEntropyLoss 中的 ignore_index。如果你希望为单词的所有 wordpiece 打标签，可以在初始化分词器时将 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").to(model.device)
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").to(model.device)
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").to(model.device)
print(encoding.keys())
dict_keys(['input_ids', 'token_type_ids', 'attention_mask', 'xpath_tags_seq', 'xpath_subs_seq'])资源
MarkupLMConfig
class transformers.MarkupLMConfig
< source >( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonevocab_size: int = 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 )
参数
- vocab_size (
int，可选，默认为30522) — 模型的词汇表大小。定义了input_ids可以表示的不同 token 数量。 - hidden_size (
int，可选，默认为768) — 隐藏表示的维度。 - num_hidden_layers (
int, 可选, 默认为12) — Transformer 解码器中的隐藏层数量。 - num_attention_heads (
int，可选，默认为12) — Transformer 解码器中每个注意力层的注意力头数量。 - intermediate_size (
int，可选，默认为3072) — MLP 表示的维度。 - hidden_act (
str，可选，默认为gelu) — 解码器中的非线性激活函数（函数或字符串）。例如，"gelu"、"relu"、"silu"等。 - hidden_dropout_prob (
Union[float, int]，可选，默认为0.1) — 嵌入层、编码器和池化层中所有全连接层的 dropout 概率。 - attention_probs_dropout_prob (
Union[float, int]，可选，默认为0.1) — 注意力概率的 dropout 比率。 - max_position_embeddings (
int，可选，默认为512) — 该模型可能使用的最大序列长度。 - type_vocab_size (
int，可选，默认为2) —token_type_ids的词汇表大小。 - initializer_range (
float，可选，默认为0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。 - layer_norm_eps (
float，可选，默认为1e-12) — 层归一化层所使用的 epsilon 值。 - pad_token_id (
int, 可选，默认为0) — 词表中用于填充的 token id。 - bos_token_id (
int，可选，默认为0) — 词汇表中用于表示流起始的 Token id。 - eos_token_id (
Union[int, list[int]]，可选，默认为2) — 词汇表中用于表示流结束（end-of-stream）的 token id。 - max_xpath_tag_unit_embeddings (
int，可选，默认值为 256) — xpath 标签单元嵌入可能使用的最大值。通常建议将其设置为一个较大的值以防万一（例如 256）。 - max_xpath_subs_unit_embeddings (
int, 可选，默认值为 1024) — xpath 下标单元嵌入可能使用的最大值。通常建议将其设置为一个较大的值以防万一（例如 1024）。 - tag_pad_id (
int，可选，默认为 216) — xpath 标签中填充标记的 id。 - subs_pad_id (
int，可选，默认为 1001) — xpath 下标中填充 token 的 id。 - xpath_unit_hidden_size (
int，可选，默认值为 32) — xpath 中每个单元的隐藏层大小。 - max_depth (
int，可选，默认为 50) — xpath 的最大深度。 - use_cache (
bool，可选，默认为True) — 模型是否应返回最后一次键/值注意力（并非所有模型都使用）。仅当config.is_decoder=True或模型为仅解码器生成式模型时相关。 - classifier_dropout (
Union[float, int], 可选) — 分类器的 dropout 比率。
这是用于存储 MarkupLMModel 配置的类。它根据指定的参数实例化 Markuplm 模型，并定义模型架构。使用默认值实例化配置将生成与 microsoft/markuplm-base 类似的配置。
配置对象继承自 PreTrainedConfig，可用于控制模型输出。有关更多信息，请参阅 PreTrainedConfig 的文档。
示例：
>>> 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 >( 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 )
参数
- vocab (
str或dict[str, int]，可选) — 自定义词汇表。如果未提供，则从vocab_file加载词汇表。 - merges（
str或list[str]，可选）— 自定义合并列表。如果未提供，则从merges_file加载合并列表。 - errors (
str，可选，默认为"replace") — 将字节解码为 UTF-8 时遵循的策略。更多信息请参阅 bytes.decode。 - bos_token (
str, 可选, 默认为"<s>") — 预训练期间使用的序列起始标记。也可用作序列分类标记。在构建序列时，如果使用了特殊标记，序列开头使用的并不是这个标记。实际使用的标记是
cls_token。 - eos_token (
str, 可选, 默认为"</s>") — 序列结束标记。在构建包含特殊标记的序列时，序列结束使用的并非此标记，而是 sep_token。在构建包含特殊标记的序列时，序列末尾使用的并不是这个标记。 实际使用的是
sep_token。 - sep_token (
str，可选，默认为"</s>") — 分隔符 token，用于从多个序列构建序列时，例如用于序列分类的两个序列，或用于问答的文本和问题。它也用作使用特殊 token 构建的序列的最后一个 token。 - cls_token (
str，可选，默认为"<s>") — 用于序列分类（对整个序列进行分类，而非逐 token 分类）的分类器 token。当使用特殊 token 构建序列时，它是序列的第一个 token。 - unk_token (
str，可选，默认为"<unk>") — 未知标记。不在词汇表中的标记无法转换为 ID，因此会被设置为该标记。 - pad_token (
str，可选，默认为"<pad>") — 用于填充的标记，例如在对长度不同的序列进行批处理时。 - mask_token (
str, 可选，默认为"<mask>") — 用于掩码值的标记。这是在以掩码语言建模方式训练该模型时所使用的标记，也是模型将尝试预测的标记。 - add_prefix_space (
bool，可选，默认为False) — 是否要在输入前添加一个初始空格。这样可以将开头的单词视为与其他单词相同。（RoBERTa 分词器通过前面的空格来检测单词的开头）。
构建一个 MarkupLM 分词器。基于字节级 Byte-Pair-Encoding (BPE)。
MarkupLMTokenizer 可将 HTML 字符串转换为 token 级别的 input_ids、attention_mask、token_type_ids、xpath_tags_seq 和 xpath_tags_seq。该 tokenizer 继承自 TokenizersBackend，后者包含大部分主要方法，并确保始终实例化一个 tokenizers 后端。
用户应参考该父类以获取有关这些方法的更多信息。
build_inputs_with_special_tokens
< source >( token_ids_0: listtoken_ids_1: list[int] | None = None ) → list[int]
通过拼接并添加特殊标记，从单个序列或序列对构建用于序列分类任务的模型输入。RoBERTa 序列的格式如下：
- 单条序列：
<s> X </s> - 序列对：
<s> A </s></s> B </s>
get_special_tokens_mask
< source >( 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]
从未添加特殊标记的标记列表中检索序列 ID。
对于快速分词器，数据整理器会传入 already_has_special_tokens=True 来调用此方法，以在已格式化的序列上构建掩码。在这种情况下，我们通过检查元素是否属于 all_special_ids 来计算掩码。
create_token_type_ids_from_sequences
< source >( token_ids_0: listtoken_ids_1: list[int] | None = None ) → list[int]
根据传入的两个序列创建掩码，用于序列对分类任务。RoBERTa 不使用 token type ids，因此返回一个全零列表。
MarkupLMTokenizerFast
class transformers.MarkupLMTokenizer
< source >( 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 )
参数
- vocab (
str或dict[str, int]，可选) — 自定义词汇表。如果未提供，则从vocab_file加载词汇表。 - merges（
str或list[str]，可选）— 自定义合并列表。如果未提供，则从merges_file加载合并列表。 - errors (
str，可选，默认为"replace") — 将字节解码为 UTF-8 时遵循的策略。更多信息请参阅 bytes.decode。 - bos_token (
str, 可选, 默认为"<s>") — 预训练期间使用的序列起始标记。也可用作序列分类标记。在构建序列时，如果使用了特殊标记，序列开头使用的并不是这个标记。实际使用的标记是
cls_token。 - eos_token (
str, 可选, 默认为"</s>") — 序列结束标记。在构建包含特殊标记的序列时，序列结束使用的并非此标记，而是 sep_token。在构建包含特殊标记的序列时，序列末尾使用的并不是这个标记。 实际使用的是
sep_token。 - sep_token (
str，可选，默认为"</s>") — 分隔符 token，用于从多个序列构建序列时，例如用于序列分类的两个序列，或用于问答的文本和问题。它也用作使用特殊 token 构建的序列的最后一个 token。 - cls_token (
str，可选，默认为"<s>") — 用于序列分类（对整个序列进行分类，而非逐 token 分类）的分类器 token。当使用特殊 token 构建序列时，它是序列的第一个 token。 - unk_token (
str，可选，默认为"<unk>") — 未知标记。不在词汇表中的标记无法转换为 ID，因此会被设置为该标记。 - pad_token (
str，可选，默认为"<pad>") — 用于填充的标记，例如在对长度不同的序列进行批处理时。 - mask_token (
str, 可选，默认为"<mask>") — 用于掩码值的标记。这是在以掩码语言建模方式训练该模型时所使用的标记，也是模型将尝试预测的标记。 - add_prefix_space (
bool，可选，默认为False) — 是否要在输入前添加一个初始空格。这样可以将开头的单词视为与其他单词相同。（RoBERTa 分词器通过前面的空格来检测单词的开头）。
构建一个 MarkupLM 分词器。基于字节级 Byte-Pair-Encoding (BPE)。
MarkupLMTokenizer 可将 HTML 字符串转换为 token 级别的 input_ids、attention_mask、token_type_ids、xpath_tags_seq 和 xpath_tags_seq。该 tokenizer 继承自 TokenizersBackend，后者包含大部分主要方法，并确保始终实例化一个 tokenizers 后端。
用户应参考该父类以获取有关这些方法的更多信息。
batch_encode_plus
< source >( 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，可选，默认为 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指定的最大长度，或者如果未提供该参数，则截断至模型可接受的最大输入长度。这将逐个 token 进行截断，如果提供了一对序列（或一批序列对），则会从该对中最长的序列中移除一个 token。'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 时返回的溢出 token 将包含来自截断序列末尾的一些 token，以在截断序列和溢出序列之间提供一些重叠。此参数的值定义了重叠 token 的数量。
is_split_into_words (bool, 可选，默认为 False)：
输入是否已经预先分词（例如，已拆分为单词）。如果设置为 True，分词器将假设输入已拆分为单词（例如，通过按空白字符拆分），然后对其进行分词。这对于 NER 或 token 分类非常有用。
pad_to_multiple_of (int, 可选)：
如果设置，则将序列填充为所提供值的倍数。需要启用 padding。
这对于在具有计算能力 >= 7.5（Volta）的 NVIDIA 硬件上启用 Tensor Cores 的使用特别有用。
padding_side (str, 可选)：
应在模型的哪一侧应用填充。应在 [‘right’, ‘left’] 之间进行选择。
默认值取自同名的类属性。
return_tensors (str 或 TensorType, 可选)：
如果设置，将返回张量而不是 Python 整数列表。可接受的值是：
'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指定的最大长度，或者如果未提供该参数，则截断至模型可接受的最大输入长度。这将逐个 token 进行截断，如果提供了一对序列（或一批序列对），则会从该对中最长的序列中移除一个 token。'only_first'：截断至由参数max_length指定的最大长度，或者在未提供该参数时，截断至模型可接受的最大输入长度。如果提供了一对序列（或一批序列对），则仅截断其中的第一个序列。'only_second'：截断至由参数max_length指定的最大长度，或者如果未提供该参数，则截断至模型可接受的最大输入长度。仅当提供了一对序列（或一批序列对）时，才会截断其中的第二个序列。Falseor'do_not_truncate'(default): No truncation (i.e., can output batch with sequence lengths greater than the model maximum admissible input size). max_length (int, optional): Controls the maximum length to use by one of the truncation/padding parameters. If left unset or set toNone, this will use the predefined model maximum length if a maximum length is required by one of the truncation/padding parameters. If the model has no specific maximum input length (like XLNet) truncation/padding to a maximum length will be deactivated. stride (int, optional, defaults to 0): If set to a number along withmax_length, the overflowing tokens returned whenreturn_overflowing_tokens=Truewill contain some tokens from the end of the truncated sequence returned to provide some overlap between truncated and overflowing sequences. The value of this argument defines the number of overlapping tokens. is_split_into_words (bool, optional, defaults toFalse): Whether or not the input is already pretokenized (e.g. split into words). Set this toTrueif you are passing pretokenized inputs to avoid additional tokenization. pad_to_multiple_of (int, optional): If set will pad the sequence to a multiple of the provided value. This is especially useful to enable the use of Tensor Cores on NVIDIA hardware with compute capability>= 7.5(Volta). return_tensors (stror TensorType, optional): If set, will return tensors instead of list of python integers. Acceptable values are:'pt'：返回 PyTorchtorch.Tensor对象。'np'：返回 Numpynp.ndarray对象。
build_inputs_with_special_tokens
< source >( token_ids_0: listtoken_ids_1: list[int] | None = None ) → list[int]
通过拼接并添加特殊标记，从单个序列或序列对构建用于序列分类任务的模型输入。RoBERTa 序列的格式如下：
- 单条序列：
<s> X </s> - 序列对：
<s> A </s></s> B </s>
create_token_type_ids_from_sequences
< source >( token_ids_0: listtoken_ids_1: list[int] | None = None ) → list[int]
根据传入的两个序列创建掩码，用于序列对分类任务。RoBERTa 不使用 token type ids，因此返回一个全零列表。
encode_plus
< source >( 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 )
参数
- 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指定的最大长度，或者如果未提供该参数，则截断至模型可接受的最大输入长度。这将逐个 token 进行截断，如果提供了一对序列（或一批序列对），则会从该对中最长的序列中移除一个 token。'only_first'：截断至由参数max_length指定的最大长度，或者在未提供该参数时，截断至模型可接受的最大输入长度。如果提供了一对序列（或一批序列对），则仅截断其中的第一个序列。'only_second'：截断至由参数max_length指定的最大长度，或者如果未提供该参数，则截断至模型可接受的最大输入长度。仅当提供了一对序列（或一批序列对）时，才会截断其中的第二个序列。False或'do_not_truncate'（默认值）：不进行截断（即，可以输出序列长度大于模型最大可接受输入大小的批次）。
- max_length (
int, 可选) — 控制截断/填充参数之一所使用的最大长度。如果未设置或设置为 None，则当截断/填充参数需要最大长度时，将使用预定义的最大模型长度。如果模型没有特定的最大输入长度（如 XLNet），则禁用截断/填充到最大长度的功能。如果未设置或设置为
None，当截断/填充参数需要最大长度时，将使用预定义的最大模型长度。如果模型没有特定的最大输入长度（例如 XLNet），则禁用截断/填充至最大长度的功能。 - stride (
int，可选，默认为 0) — 如果与max_length一起设置为某个数值，则当return_overflowing_tokens=True时，返回的溢出 token 将包含截断序列末尾的若干 token，以在截断序列和溢出序列之间提供一定的重叠。此参数的值定义了重叠 token 的数量。 - is_split_into_words (
bool，可选，默认为False) — 输入是否已经预先分词（例如，已拆分为单词）。如果设置为True，分词器将假设输入已经拆分为单词（例如，通过按空白字符拆分），然后对其进行分词。这对于命名实体识别（NER）或 token 分类非常有用。 - pad_to_multiple_of (
int, 可选) — 如果设置，则将序列填充为所提供值的倍数。需要启用padding。 这对于在计算能力为>= 7.5（Volta）的 NVIDIA 硬件上启用 Tensor Cores 的使用特别有用。 - padding_side (
str, 可选) — 模型应应用填充的一侧。应在 [‘right’, ‘left’] 之间进行选择。 默认值取自同名的类属性。 - return_tensors (
str或 TensorType, 可选) — 如果设置，将返回张量而不是 Python 整数列表。可接受的值为：'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指定的最大长度，或者如果未提供该参数，则截断至模型可接受的最大输入长度。这将逐个 token 进行截断，如果提供了一对序列（或一批序列对），则会从该对中最长的序列中移除一个 token。'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时，返回的溢出 token 将包含截断序列末尾的若干 token，以在截断序列和溢出序列之间提供一定的重叠。此参数的值定义了重叠 token 的数量。 - is_split_into_words (
bool，可选，默认为False) — 输入是否已经预先分词（例如已拆分为单词）。如果传入的是预先分词的输入，请将其设置为True，以避免进行额外的分词处理。 - pad_to_multiple_of (
int, 可选) — 如果设置，则将序列填充为所提供值的倍数。这对于在计算能力>= 7.5（Volta）的 NVIDIA 硬件上启用 Tensor Cores 特别有用。 - return_tensors (
str或 TensorType, 可选) — 如果设置，将返回张量而不是 Python 整数列表。可接受的值为：'pt'：返回 PyTorchtorch.Tensor对象。'np'：返回 Numpynp.ndarray对象。
对单个序列或序列对进行分词，并将其准备为模型输入。 .. warning:: 此方法已弃用，应改用 __call__。
给定某个特定节点的 xpath 表达式（例如 “/html/body/div/li[1]/div/span[2]”），返回标签 ID 及对应下标的列表，并考虑最大深度。
MarkupLMProcessor
class transformers.MarkupLMProcessor
< source >( feature_extractortokenizer )
构建一个 MarkupLMProcessor，它将一个特征提取器和一个分词器封装为单个处理器。
MarkupLMProcessor 提供了 feature_extractor_class 和 MarkupLMTokenizer 的所有功能。有关更多信息，请参阅 ~feature_extractor_class 和 ~MarkupLMTokenizer。
__call__
< source >( 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
参数
- html_strings (
str或list[str]，可选) — 要解析和处理的原始 HTML 字符串。当parse_html=True（默认值）时，这些字符串会被解析以自动提取节点和 xpath。如果提供了该参数，则不应提供nodes、xpaths和node_labels。当parse_html=True时，此参数为必填项。 - nodes (
list[list[str]]，可选) — 预提取的 HTML 节点，表示为列表的列表，其中每个内部列表包含单个文档中各节点的文本内容。当parse_html=False时必填。当parse_html=True时不应提供。 - xpaths (
list[list[str]]，可选) — 预先提取的、与节点对应的 XPath 表达式。应为一个列表的列表，其结构与nodes相同，其中每个 XPath 标识对应节点在 HTML 树中的位置。当parse_html=False时必填。当parse_html=True时不应提供。 - node_labels (
list[list[int]]，可选) — 节点的标签，通常用于训练或微调任务。应为与nodes结构相同的列表的列表，其中每个标签对应一个节点。该参数为可选，仅在parse_html=False时使用。 - questions (
str或list[str]，可选) — 用于问答任务的问题字符串。提供时，分词器将问题作为第一个序列、节点作为第二个序列（text_pair）进行处理。如果提供的是单个字符串，则会将其转换为列表，以匹配解析后 HTML 的批次维度。 - 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, ，可选) —
启用并控制截断。接受以下值：
True或'longest_first'：截断至由参数max_length指定的最大长度，或者如果未提供该参数，则截断至模型可接受的最大输入长度。这将逐个 token 进行截断，如果提供了一对序列（或一批序列对），则会从该对中最长的序列中移除一个 token。'only_first'：截断至由参数max_length指定的最大长度，或者在未提供该参数时，截断至模型可接受的最大输入长度。如果提供了一对序列（或一批序列对），则仅截断其中的第一个序列。'only_second'：截断至由参数max_length指定的最大长度，或者如果未提供该参数，则截断至模型可接受的最大输入长度。仅当提供了一对序列（或一批序列对）时，才会截断其中的第二个序列。False或'do_not_truncate'（默认值）：不进行截断（即，可以输出序列长度大于模型最大可接受输入大小的批次）。
- max_length (
int, 可选) — 控制截断/填充参数之一所使用的最大长度。如果未设置或设置为 None，则当截断/填充参数需要最大长度时，将使用预定义的最大模型长度。如果模型没有特定的最大输入长度（如 XLNet），则禁用截断/填充到最大长度的功能。如果未设置或设置为
None，当截断/填充参数需要最大长度时，将使用预定义的最大模型长度。如果模型没有特定的最大输入长度（例如 XLNet），则禁用截断/填充至最大长度的功能。 - stride (
int，可选，默认为0) — 如果与max_length一起设置为某个数值，则当return_overflowing_tokens=True时，返回的溢出 token 将包含截断序列末尾的某些 token，以在截断序列和溢出序列之间提供一些重叠。此参数的值定义了重叠 token 的数量。 - pad_to_multiple_of (
int, 可选) — 如果设置，则将序列填充为所提供值的倍数。需要启用padding。 这对于在具有计算能力>= 7.5（Volta）的 NVIDIA 硬件上启用 Tensor Cores 特别有用。 - return_token_type_ids (
bool, 可选) — 是否返回 token type ID。如果保持默认值，将根据特定分词器的默认设置返回 token type ID，该设置由return_outputs属性定义。 - return_attention_mask (
bool, 可选) — 是否返回注意力掩码。如果保持默认值，将根据特定分词器的默认设置返回注意力掩码，该设置由return_outputs属性定义。 - return_overflowing_tokens (
bool，可选，默认为False) — 是否返回溢出的 token 序列。如果提供了输入 id 的序列对（或序列对批次），且truncation_strategy = longest_first或True，则会抛出错误，而不是返回溢出的 token。 - return_special_tokens_mask (
bool，可选，默认为False) — 是否返回特殊 token 掩码信息。 - return_offsets_mapping (
bool, 可选, 默认为False) — 是否返回(char_start, char_end)每个 token 的。此功能仅在继承自 PreTrainedTokenizerFast 的快速分词器上可用。如果使用 Python 分词器，此方法将抛出
NotImplementedError。 - return_length (
bool，可选，默认为False) — 是否返回编码后输入的长度。 - verbose (
bool，可选，默认为True) — 是否打印更多信息和警告。 - return_tensors (
Union[str, ~utils.generic.TensorType], 可选) — 如果设置，将返回特定框架的张量。可接受的值为：'pt'：返回 PyTorchtorch.Tensor对象。'np'：返回 NumPynp.ndarray对象。
返回值
~tokenization_utils_base.BatchEncoding
- data (
dict，可选) — 由__call__/encode_plus/batch_encode_plus方法返回的列表/数组/张量字典 （‘input_ids’、‘attention_mask’ 等）。 - encoding（
tokenizers.Encoding或Sequence[tokenizers.Encoding]，可选）— 如果分词器是快速分词器，并且会输出诸如从词/字符空间到 token 空间的映射等附加信息，则tokenizers.Encoding实例或实例列表（用于批次）将保存这些信息。 - tensor_type (
Union[None, str, TensorType], 可选) — 您可以在此处指定 tensor_type，以便在初始化时将 PyTorch/Numpy 张量中的整数列表进行转换。 - prepend_batch_axis (
bool，可选，默认为False) — 在转换为张量时是否添加批次维度（参见上文中的tensor_type）。请注意，仅当参数tensor_type被设置时，该参数才会生效，否则无效。 - n_sequences (
int，可选) — 每个编码所表示的输入序列数量（None表示未知，1表示单个序列，2表示一对序列）。
MarkupLMModel
class transformers.MarkupLMModel
< source >( config: MarkupLMConfigadd_pooling_layer = True )
参数
- config (MarkupLMConfig) — 模型的配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。
- add_pooling_layer (
bool，可选，默认为True) — 是否添加池化层
基础模型，输出原始隐藏状态，顶部未添加任何特定头。
该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。
forward
< source >( 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)
参数
- input_ids (
torch.LongTensor形状为(batch_size, sequence_length), ，可选) — 输入序列中各 token 在词汇表中的索引。默认情况下，填充（padding）将被忽略。可以使用 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，
- 对于被掩码的 token，值为 0。
- token_type_ids (
torch.LongTensor形状为(batch_size, sequence_length), ，可选) — 用于指示输入中第一和第二部分的片段 token 索引。索引取值范围为[0, 1]:- 0 对应 sentence A 标记，
- 1 对应于 sentence B 标记。
- position_ids (
torch.LongTensor形状为(batch_size, sequence_length), 可选) — 输入序列中每个 token 在位置嵌入中的位置索引。取值范围为[0, config.n_positions - 1]. - inputs_embeds（形状为
(batch_size, sequence_length, hidden_size)的torch.Tensor，可选） — 可选地，您可以选择直接传入嵌入表示，而不是传入input_ids。如果您希望对input_ids索引如何转换为相应向量拥有比模型内部嵌入查找矩阵更多的控制权，这将非常有用。
返回值
BaseModelOutputWithPooling 或 tuple(torch.Tensor)
一个 BaseModelOutputWithPooling 或 torch.Tensor 元组（如果传入了 return_dict=False 或 config.return_dict=False），其包含的元素取决于配置（MarkupLMConfig）和输入。
MarkupLMModel 的 forward 方法重写了 __call__ 特殊方法。
尽管前向传播的实现需要在此函数中定义，但之后应调用
Module实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。
last_hidden_state（形状为
(batch_size, sequence_length, hidden_size)的torch.Tensor）— 模型最后一层输出的隐藏状态序列。pooler_output (
torch.Tensor，形状为(batch_size, hidden_size)) — 序列中第一个 token（分类 token）的最后一层隐藏状态，经过用于辅助预训练任务的层进一步处理后得到。例如，对于 BERT 系列模型，这返回的是分类 token 经过线性层和 tanh 激活函数处理后的结果。线性层的权重在预训练期间通过下一句预测（分类）目标进行训练。hidden_states (
tuple(torch.Tensor)，可选，当传入output_hidden_states=True或config.output_hidden_states=True时返回) — 一个torch.Tensor元组（如果模型具有嵌入层，则包含嵌入层的输出，以及每一层的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
attentions (
tuple(torch.Tensor)，可选，当传入output_attentions=True或config.output_attentions=True时返回) — 一个torch.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
示例：
>>> 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
< source >( config: MarkupLMConfig )
参数
- config (MarkupLMConfig) — 模型的配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。
MarkupLM 模型，顶部带有序列分类/回归头（在池化输出之上添加一个线性层），例如用于 GLUE 任务。
该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。
forward
< source >( 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)
参数
- input_ids (
torch.Tensor形状为(batch_size, sequence_length), 可选) — 输入序列中各 token 在词表中的索引。默认情况下，填充（padding）将被忽略。可以使用 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，
- 对于被掩码的 token，值为 0。
- token_type_ids (
torch.Tensor形状为(batch_size, sequence_length), ，可选) — 用于指示输入中第一和第二部分的片段标记索引。索引取自[0, 1]:- 0 对应 sentence A 标记，
- 1 对应于 sentence B 标记。
- position_ids (
torch.Tensor形状为(batch_size, sequence_length), 可选) — 输入序列中每个 token 在位置嵌入中的位置索引。取值范围为[0, config.n_positions - 1]. - inputs_embeds（形状为
(batch_size, sequence_length, hidden_size)的torch.Tensor，可选） — 可选地，您可以选择直接传入嵌入表示，而不是传入input_ids。如果您希望对input_ids索引如何转换为相应向量拥有比模型内部嵌入查找矩阵更多的控制权，这将非常有用。 - labels (
torch.LongTensor，形状为(batch_size,)，可选) — 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels == 1，则计算回归损失（均方损失）；如果config.num_labels > 1，则计算分类损失（交叉熵）。
返回值
SequenceClassifierOutput 或 tuple(torch.Tensor)
一个 SequenceClassifierOutput 或 torch.Tensor 元组（如果传入了 return_dict=False 或 config.return_dict=False），其包含的元素取决于配置（MarkupLMConfig）和输入。
MarkupLMForSequenceClassification 的 forward 方法重写了 __call__ 特殊方法。
尽管前向传播的实现需要在此函数中定义，但之后应调用
Module实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。
loss (
torch.Tensor，形状为(1,)，可选，当提供labels时返回) — 分类损失（如果 config.num_labels==1，则为回归损失）。logits（形状为
(batch_size, config.num_labels)的torch.Tensor）— 分类（或当 config.num_labels==1 时为回归）得分（SoftMax 之前）。hidden_states (
tuple(torch.Tensor)，可选，当传入output_hidden_states=True或config.output_hidden_states=True时返回) — 一个torch.Tensor元组（如果模型具有嵌入层，则包含嵌入层的输出，以及每一层的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
attentions (
tuple(torch.Tensor)，可选，当传入output_attentions=True或config.output_attentions=True时返回) — 一个torch.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
示例：
>>> 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
< source >( config: MarkupLMConfig )
参数
- config (MarkupLMConfig) — 模型的配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。
带有 token_classification 头的 MarkupLM 模型。
该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。
forward
< source >( 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)
参数
- input_ids (
torch.Tensor形状为(batch_size, sequence_length), 可选) — 输入序列中各 token 在词表中的索引。默认情况下，填充（padding）将被忽略。可以使用 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，
- 对于被掩码的 token，值为 0。
- token_type_ids (
torch.Tensor形状为(batch_size, sequence_length), ，可选) — 用于指示输入中第一和第二部分的片段标记索引。索引取自[0, 1]:- 0 对应 sentence A 标记，
- 1 对应于 sentence B 标记。
- position_ids (
torch.Tensor形状为(batch_size, sequence_length), 可选) — 输入序列中每个 token 在位置嵌入中的位置索引。取值范围为[0, config.n_positions - 1]. - inputs_embeds（形状为
(batch_size, sequence_length, hidden_size)的torch.Tensor，可选） — 可选地，您可以选择直接传入嵌入表示，而不是传入input_ids。如果您希望对input_ids索引如何转换为相应向量拥有比模型内部嵌入查找矩阵更多的控制权，这将非常有用。 - labels（形状为
(batch_size, sequence_length)的torch.LongTensor，可选） — 用于计算 token 分类损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。
返回值
MaskedLMOutput 或 tuple(torch.Tensor)
一个 MaskedLMOutput 或 torch.Tensor 元组（如果传入了 return_dict=False 或 config.return_dict=False），其包含的元素取决于配置（MarkupLMConfig）和输入。
MarkupLMForTokenClassification 的 forward 方法重写了 __call__ 特殊方法。
尽管前向传播的实现需要在此函数中定义，但之后应调用
Module实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。
loss (
torch.Tensor，形状为(1,)，可选，当提供labels时返回) — 掩码语言建模（MLM）损失。logits（形状为
(batch_size, sequence_length, config.vocab_size)的torch.Tensor）— 语言建模头的预测分数（SoftMax 之前每个词汇表 token 的分数）。hidden_states (
tuple(torch.Tensor)，可选，当传入output_hidden_states=True或config.output_hidden_states=True时返回) — 一个torch.Tensor元组（如果模型具有嵌入层，则包含嵌入层的输出，以及每一层的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
attentions (
tuple(torch.Tensor)，可选，当传入output_attentions=True或config.output_attentions=True时返回) — 一个torch.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
示例：
>>> 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: MarkupLMConfig )
参数
- config (MarkupLMConfig) — 模型的配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。
带有跨度分类头的 Markuplm 变换器，用于 SQuAD 等抽取式问答任务（在隐藏状态输出之上添加一个线性层，以计算 span start logits 和 span end logits）。
该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。
forward
< source >( 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)
参数
- input_ids (
torch.Tensor形状为(batch_size, sequence_length), 可选) — 输入序列中各 token 在词表中的索引。默认情况下，填充（padding）将被忽略。可以使用 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，
- 对于被掩码的 token，值为 0。
- token_type_ids (
torch.Tensor形状为(batch_size, sequence_length), ，可选) — 用于指示输入中第一和第二部分的片段标记索引。索引取自[0, 1]:- 0 对应 sentence A 标记，
- 1 对应于 sentence B 标记。
- position_ids (
torch.Tensor形状为(batch_size, sequence_length), 可选) — 输入序列中每个 token 在位置嵌入中的位置索引。取值范围为[0, config.n_positions - 1]. - inputs_embeds（形状为
(batch_size, sequence_length, hidden_size)的torch.Tensor，可选） — 可选地，您可以选择直接传入嵌入表示，而不是传入input_ids。如果您希望对input_ids索引如何转换为相应向量拥有比模型内部嵌入查找矩阵更多的控制权，这将非常有用。 - start_positions (
torch.Tensor，形状为(batch_size,)，可选) — 用于计算 token 分类损失的标注片段起始位置（索引）的标签。 位置会被截断到序列长度（sequence_length）。序列之外的位置在计算损失时不予考虑。 - end_positions (
torch.Tensor，形状为(batch_size,)，可选) — 用于计算 token 分类损失的标注片段结束位置（索引）的标签。 位置会被截断到序列长度（sequence_length）。序列之外的位置在计算损失时不予考虑。
返回值
QuestionAnsweringModelOutput 或 tuple(torch.Tensor)
QuestionAnsweringModelOutput 或 torch.Tensor 元组（如果传入了 return_dict=False 或 config.return_dict=False），其包含的元素取决于配置（MarkupLMConfig）和输入。
MarkupLMForQuestionAnswering 的 forward 方法重写了 __call__ 特殊方法。
尽管前向传播的实现需要在此函数中定义，但之后应调用
Module实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。
loss (
torch.Tensor，形状为(1,)，可选，当提供labels时返回) — 总跨度提取损失是起始位置和结束位置的交叉熵之和。start_logits（形状为
(batch_size, sequence_length)的torch.Tensor）— 跨度起始分数（SoftMax 之前）。end_logits（形状为
(batch_size, sequence_length)的torch.Tensor）— 跨度结束分数（SoftMax 之前）。hidden_states (
tuple(torch.Tensor)，可选，当传入output_hidden_states=True或config.output_hidden_states=True时返回) — 一个torch.Tensor元组（如果模型具有嵌入层，则包含嵌入层的输出，以及每一层的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
attentions (
tuple(torch.Tensor)，可选，当传入output_attentions=True或config.output_attentions=True时返回) — 一个torch.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。
示例：
>>> 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'