Transformers 4.37 中文文档（八十八）

原文：huggingface.co/docs/transformers

LayoutLM

原文链接：huggingface.co/docs/transformers/v4.37.2/en/model_doc/layoutlm

概述

LayoutLM 模型是由 Yiheng Xu，Minghao Li，Lei Cui，Shaohan Huang，Furu Wei 和 Ming Zhou 在论文LayoutLM: Pre-training of Text and Layout for Document Image Understanding中提出的。这是一种简单但有效的文本和布局预训练方法，用于文档图像理解和信息提取任务，如表单理解和收据理解。它在几个下游任务上取得了最先进的结果：

• 表单理解：FUNSD数据集（包含 199 个带有超过 30,000 个单词的注释表单）。
• 收据理解：SROIE数据集（包含 626 张收据用于训练和 347 张收据用于测试）。
• 文档图像分类：RVL-CDIP数据集（包含 400,000 张图像，属于 16 个类别之一）。

论文摘要如下：

近年来，预训练技术在各种 NLP 任务中取得了成功。尽管预训练模型在 NLP 应用中被广泛使用，但它们几乎完全专注于文本级别的操作，而忽略了对于文档图像理解至关重要的布局和样式信息。在本文中，我们提出了 LayoutLM，以共同建模扫描文档图像中文本和布局信息之间的交互，这对于许多真实世界的文档图像理解任务（如从扫描文档中提取信息）是有益的。此外，我们还利用图像特征将单词的视觉信息整合到 LayoutLM 中。据我们所知，这是文本和布局首次在单个框架中共同学习以进行文档级预训练。它在几个下游任务中取得了最新的最先进结果，包括表单理解（从 70.72 到 79.27）、收据理解（从 94.02 到 95.24）和文档图像分类（从 93.07 到 94.42）。

使用提示

• 除了input_ids之外，forward()还需要输入bbox，这是输入标记的边界框（即 2D 位置）。这些可以使用外部 OCR 引擎（如 Google 的Tesseract）获取（有一个Python 包装器可用）。每个边界框应该采用（x0，y0，x1，y1）格式，其中（x0，y0）对应于边界框左上角的位置，（x1，y1）表示右下角的位置。请注意，首先需要将边界框归一化为 0-1000 的比例。要进行归一化，可以使用以下函数：

def normalize_bbox(bbox, width, height):
    return [
        int(1000 * (bbox[0] / width)),
        int(1000 * (bbox[1] / height)),
        int(1000 * (bbox[2] / width)),
        int(1000 * (bbox[3] / height)),
    ]

这里，width和height对应于标记出现的原始文档的宽度和高度。可以使用 Python Image Library（PIL）库来获取这些，例如：

from PIL import Image

# Document can be a png, jpg, etc. PDFs must be converted to images.
image = Image.open(name_of_your_document).convert("RGB")

width, height = image.size

资源

官方 Hugging Face 和社区（由🌎表示）资源列表，可帮助您开始使用 LayoutLM。如果您有兴趣提交资源以包含在此处，请随时打开 Pull Request，我们将进行审查！资源应该理想地展示一些新东西，而不是重复现有资源。

文档问答

• 一篇关于使用 Keras 和 Hugging Face Transformers 对 LayoutLM 进行文档理解微调的博文。
• 一篇关于如何仅使用 Hugging Face Transformers 对 LayoutLM 进行文档理解微调的博文。
• 关于如何在 FUNSD 数据集上使用图像嵌入来微调 LayoutLM 模型的笔记本。
• 另请参阅：文档问答任务指南

文本分类

• 关于如何在 RVL-CDIP 数据集上微调 LayoutLM 用于序列分类的笔记本。
• 文本分类任务指南

标记分类

• 关于如何在 FUNSD 数据集上微调 LayoutLM 用于标记分类的笔记本。
• 标记分类任务指南

其他资源

• 掩码语言建模任务指南

🚀 部署

• 关于如何使用 Hugging Face 推理端点部署 LayoutLM的博客文章。

LayoutLMConfig

class transformers.LayoutLMConfig

<来源>

( 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 position_embedding_type = 'absolute' use_cache = True max_2d_position_embeddings = 1024 **kwargs )

参数

• vocab_size (int, optional, defaults to 30522) — LayoutLM 模型的词汇表大小。定义了可以由传递给 LayoutLMModel 的inputs_ids表示的不同标记。
• hidden_size (int, optional, defaults to 768) — 编码器层和池化器层的维度。
• num_hidden_layers (int, optional, defaults to 12) — Transformer 编码器中的隐藏层数量。
• num_attention_heads (int, optional, defaults to 12) — Transformer 编码器中每个注意力层的注意力头数。
• intermediate_size (int, optional, defaults to 3072) — Transformer 编码器中“中间”（即前馈）层的维度。
• hidden_act (str or function, optional, defaults to "gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"、"relu"、"silu"和"gelu_new"。
• hidden_dropout_prob (float, optional, defaults to 0.1) — 嵌入层、编码器和池化器中所有全连接层的丢弃概率。
• attention_probs_dropout_prob (float, optional, defaults to 0.1) — 注意力概率的丢弃比率。
• max_position_embeddings (int, optional, defaults to 512) — 此模型可能使用的最大序列长度。通常将其设置为较大的值以防万一（例如，512、1024 或 2048）。
• type_vocab_size (int, optional, defaults to 2) — 传递给 LayoutLMModel 的token_type_ids的词汇表大小。
• initializer_range (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
• layer_norm_eps (float, optional, defaults to 1e-12) — 层归一化层使用的 epsilon。
• pad_token_id (int, optional, defaults to 0) — 用于填充input_ids的值。
• position_embedding_type (str, optional, defaults to "absolute") — 位置嵌入的类型。选择"absolute"、"relative_key"、"relative_key_query"中的一个。对于位置嵌入，请使用"absolute"。有关"relative_key"的更多信息，请参考具有相对位置表示的自注意力（Shaw 等人）。有关"relative_key_query"的更多信息，请参考[使用更好的相对位置嵌入改进 Transformer 模型（Huang 等人）]中的方法 4（https://arxiv.org/abs/2009.13658）。
• use_cache (bool, optional, defaults to True) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）。仅在config.is_decoder=True时相关。
• max_2d_position_embeddings (int, optional, defaults to 1024) — 2D 位置嵌入可能使用的最大值。通常将其设置为较大的值以防万一（例如，1024）。

这是配置类，用于存储 LayoutLMModel 的配置。它用于根据指定的参数实例化 LayoutLM 模型，定义模型架构。使用默认值实例化配置将产生类似于 LayoutLM microsoft/layoutlm-base-uncased架构的配置。

配置对象继承自 BertConfig，可用于控制模型输出。阅读来自 BertConfig 的文档以获取更多信息。

示例：

>>> from transformers import LayoutLMConfig, LayoutLMModel

>>> # Initializing a LayoutLM configuration
>>> configuration = LayoutLMConfig()

>>> # Initializing a model (with random weights) from the configuration
>>> model = LayoutLMModel(configuration)

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

LayoutLMTokenizer

class transformers.LayoutLMTokenizer

<来源>

( vocab_file do_lower_case = True do_basic_tokenize = True never_split = None unk_token = '[UNK]' sep_token = '[SEP]' pad_token = '[PAD]' cls_token = '[CLS]' mask_token = '[MASK]' tokenize_chinese_chars = True strip_accents = None **kwargs )

参数

• vocab_file (str) — 包含词汇表的文件。
• do_lower_case (bool, optional, defaults to True) — 是否在标记化时将输入转换为小写。
• do_basic_tokenize (bool, optional, defaults to True) — 是否在 WordPiece 之前进行基本标记化。
• never_split (Iterable, optional) — 在标记化过程中永远不会被拆分的标记集合。仅在do_basic_tokenize=True时生效。
• unk_token (str, optional, defaults to "[UNK]") — 未知标记。词汇表中不存在的标记无法转换为 ID，而是设置为此标记。
• sep_token (str, optional, defaults to "[SEP]") — 分隔符标记，在从多个序列构建序列时使用，例如用于序列分类的两个序列或用于文本和问题的问题回答。它也用作使用特殊标记构建的序列的最后一个标记。
• pad_token (str, optional, defaults to "[PAD]") — 用于填充的标记，例如在批处理不同长度的序列时使用。
• cls_token (str, optional, defaults to "[CLS]") — 分类器标记，用于进行序列分类（对整个序列进行分类，而不是每个标记的分类）。在构建带有特殊标记的序列时，它是序列的第一个标记。
• mask_token (str, optional, defaults to "[MASK]") — 用于屏蔽值的标记。这是在使用掩码语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。
• tokenize_chinese_chars (bool, optional, defaults to True) — 是否对中文字符进行标记化。 对于日语，这可能应该被停用（请参阅此问题）。
• strip_accents (bool, optional) — 是否去除所有重音符号。如果未指定此选项，则将由lowercase的值确定（与原始 LayoutLM 中的情况相同）。

构建一个基于 WordPiece 的 LayoutLM 分词器。

此分词器继承自 PreTrainedTokenizer，其中包含大部分主要方法。用户应参考此超类以获取有关这些方法的更多信息。

build_inputs_with_special_tokens

<来源>

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

• token_ids_0 (List[int]) — 将添加特殊标记的 ID 列表。
• token_ids_1 (List[int], 可选) — 序列对的第二个 ID 列表（可选）。

返回

List[int]

带有适当特殊标记的 input IDs 列表。

通过连接和添加特殊标记，从序列或序列对构建用于序列分类任务的模型输入。一个 LayoutLM 序列的格式如下：

• 单个序列：[CLS] X [SEP]
• 序列对：[CLS] A [SEP] B [SEP]

convert_tokens_to_string

<来源>

( tokens )

将一系列标记（字符串）转换为单个字符串。

create_token_type_ids_from_sequences

<来源>

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

• token_ids_0 (List[int]) — ID 列表。
• token_ids_1 (List[int], 可选) — 序列对的第二个 ID 列表（可选）。

返回

List[int]

根据给定序列的 token type IDs 列表。

从传递的两个序列创建一个用于序列对分类任务的掩码。一个 LayoutLM 序列

序列掩码的格式如下：

0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1
| first sequence    | second sequence |

如果token_ids_1为None，则此方法仅返回掩码的第一部分（0）。

get_special_tokens_mask

<来源>

( token_ids_0: List token_ids_1: Optional = None already_has_special_tokens: bool = False ) → export const metadata = 'undefined';List[int]

参数

• token_ids_0 (List[int]) — ID 列表。
• token_ids_1 (List[int], 可选) — 序列对的第二个 ID 列表（可选）。
• already_has_special_tokens (bool, 可选, 默认为 False) — 标记列表是否已经使用特殊标记格式化为模型。

返回

List[int]

一个整数列表，范围为[0, 1]：1 表示特殊标记，0 表示序列标记。

从没有添加特殊标记的标记列表中检索序列 ID。当使用分词器的prepare_for_model方法添加特殊标记时，将调用此方法。

LayoutLMTokenizerFast

class transformers.LayoutLMTokenizerFast

<来源>

( vocab_file = None tokenizer_file = None do_lower_case = True unk_token = '[UNK]' sep_token = '[SEP]' pad_token = '[PAD]' cls_token = '[CLS]' mask_token = '[MASK]' tokenize_chinese_chars = True strip_accents = None **kwargs )

参数

• vocab_file (str) — 包含词汇表的文件。
• do_lower_case (bool, 可选, 默认为 True) — 在分词时是否将输入转换为小写。
• unk_token (str, 可选, 默认为 "[UNK]") — 未知标记。词汇表中没有的标记无法转换为 ID，而是设置为此标记。
• sep_token (str, 可选, 默认为 "[SEP]") — 分隔符标记，在构建来自多个序列的序列时使用，例如用于序列分类的两个序列或用于文本和问题的问题回答。也用作使用特殊标记构建的序列的最后一个标记。
• pad_token (str, 可选, 默认为 "[PAD]") — 用于填充的标记，例如在批处理不同长度的序列时使用。
• cls_token (str, 可选, 默认为 "[CLS]") — 在进行序列分类（整个序列而不是每个标记的分类）时使用的分类器标记。构建时是序列的第一个标记。
• mask_token (str, optional, defaults to "[MASK]") — 用于屏蔽值的标记。这是在使用掩码语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。
• clean_text (bool, optional, defaults to True) — 是否在标记化之前清理文本，通过删除任何控制字符并将所有空格替换为经典空格。
• tokenize_chinese_chars (bool, optional, defaults to True) — 是否对中文字符进行分词。对于日语，这可能应该被禁用（参见此问题）。
• strip_accents (bool, optional) — 是否去除所有重音符号。如果未指定此选项，则将由lowercase的值确定（与原始 LayoutLM 中相同）。
• wordpieces_prefix (str, optional, defaults to "##") — 子词的前缀。

构建一个“快速”LayoutLM 标记器（由 HuggingFace 的tokenizers库支持）。基于 WordPiece。

此标记器继承自 PreTrainedTokenizerFast，其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。

build_inputs_with_special_tokens

<来源>

( token_ids_0 token_ids_1 = None ) → export const metadata = 'undefined';List[int]

参数

• token_ids_0 (List[int]) — 将添加特殊标记的 ID 列表。
• token_ids_1 (List[int], optional) — 序列对的可选第二个 ID 列表。

返回

List[int]

具有适当特殊标记的 input IDs 列表。

从序列或序列对构建用于序列分类任务的模型输入，通过连接和添加特殊标记。一个 LayoutLM 序列具有以下格式：

• 单个序列：[CLS] X [SEP]
• 序列对：[CLS] A [SEP] B [SEP]

create_token_type_ids_from_sequences

<来源>

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

• token_ids_0 (List[int]) — ID 列表。
• token_ids_1 (List[int], optional) — 序列对的可选第二个 ID 列表。

返回

List[int]

根据给定序列的 token type IDs 列表。

从传递的两个序列创建用于序列对分类任务的掩码。一个 LayoutLM 序列

序列掩码具有以下格式：

0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1
| first sequence    | second sequence |

如果token_ids_1为None，则此方法仅返回掩码的第一部分（0s）。

PytorchHide Pytorch 内容

LayoutLMModel

class transformers.LayoutLMModel

<来源>

( config )

参数

• config (LayoutLMConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只加载配置。查看 from_pretrained()方法以加载模型权重。

裸的 LayoutLM 模型变压器输出原始隐藏状态，没有特定的头部。LayoutLM 模型由 Yiheng Xu、Minghao Li、Lei Cui、Shaohan Huang、Furu Wei 和 Ming Zhou 在LayoutLM: Pre-training of Text and Layout for Document Image Understanding中提出。

此模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

<来源>

( input_ids: Optional = None bbox: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None encoder_hidden_states: Optional = None encoder_attention_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions or tuple(torch.FloatTensor)

参数

• input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是输入 ID？
• bbox (torch.LongTensor of shape (batch_size, sequence_length, 4), optional) — 每个输入序列标记的边界框。选择范围为[0, config.max_2d_position_embeddings-1]。每个边界框应该是(x0, y0, x1, y1)格式的归一化版本，其中(x0, y0)对应于边界框左上角的位置，(x1, y1)表示右下角的位置。有关归一化，请参阅概述。
• attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 用于避免在填充标记索引上执行注意力的掩码。选择在[0, 1]范围内的掩码值：1表示未被掩盖的标记，0表示被掩盖的标记。 什么是注意力掩码？
• token_type_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 段标记索引，指示输入的第一部分和第二部分。索引选择在[0, 1]：0对应于句子 A标记，1对应于句子 B标记 什么是标记类型 ID？
• position_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。 什么是位置 ID？
• head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于使自注意力模块的选定头部失效的掩码。选择的掩码值在[0, 1]范围内：1表示头部未被掩盖，0表示头部被掩盖。
• inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，您可以选择直接传递嵌入表示而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，这将非常有用，而不是使用模型的内部嵌入查找矩阵。
• output_attentions (bool, optional) — 如果设置为True，则返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
• output_hidden_states (bool, optional) — 如果设置为True，则返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
• return_dict (bool, optional) — 如果设置为True，模型将返回一个 ModelOutput 而不是一个普通的元组。

返回

transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions 或tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions 或者一个torch.FloatTensor的元组（如果传递了return_dict=False或者当config.return_dict=False时），包括根据配置（LayoutLMConfig）和输入而定的各种元素。

• last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor） — 模型最后一层的隐藏状态序列。
• pooler_output（形状为(batch_size, hidden_size)的torch.FloatTensor） — 序列中第一个标记（分类标记）的最后一层隐藏状态（经过用于辅助预训练任务的层进一步处理后）。例如，对于 BERT 系列模型，这返回经过线性层和 tanh 激活函数处理后的分类标记。线性层的权重是在预训练期间从下一个句子预测（分类）目标中训练的。
• hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或者当config.output_hidden_states=True时返回） — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入的输出一个 + 每个层的输出一个）。 模型在每个层的输出的隐藏状态加上可选的初始嵌入输出。
• attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或者当config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每个层一个）。 注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
• cross_attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True和config.add_cross_attention=True或者当config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每个层一个）。 解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
• past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或者当config.use_cache=True时返回） — 长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量，如果config.is_encoder_decoder=True还有额外的 2 个形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。 包含预先计算的隐藏状态（自注意力块中的键和值以及在交叉注意力块中可选地如果config.is_encoder_decoder=True）可以用来加速顺序解码的（见past_key_values输入）。

LayoutLMModel 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的步骤需要在这个函数内定义，但应该在之后调用Module实例而不是这个，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, LayoutLMModel
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/layoutlm-base-uncased")
>>> model = LayoutLMModel.from_pretrained("microsoft/layoutlm-base-uncased")

>>> words = ["Hello", "world"]
>>> normalized_word_boxes = [637, 773, 693, 782], [698, 773, 733, 782]

>>> token_boxes = []
>>> for word, box in zip(words, normalized_word_boxes):
...     word_tokens = tokenizer.tokenize(word)
...     token_boxes.extend([box] * len(word_tokens))
>>> # add bounding boxes of cls + sep tokens
>>> token_boxes = [[0, 0, 0, 0]] + token_boxes + [[1000, 1000, 1000, 1000]]

>>> encoding = tokenizer(" ".join(words), return_tensors="pt")
>>> input_ids = encoding["input_ids"]
>>> attention_mask = encoding["attention_mask"]
>>> token_type_ids = encoding["token_type_ids"]
>>> bbox = torch.tensor([token_boxes])

>>> outputs = model(
...     input_ids=input_ids, bbox=bbox, attention_mask=attention_mask, token_type_ids=token_type_ids
... )

>>> last_hidden_states = outputs.last_hidden_state

LayoutLMForMaskedLM

class transformers.LayoutLMForMaskedLM

< source >

( config )

参数

• config（LayoutLMConfig）— 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型关联的权重，只加载配置。查看 from_pretrained()方法以加载模型权重。

在顶部带有语言建模头的 LayoutLM 模型。LayoutLM 模型是由 Yiheng Xu、Minghao Li、Lei Cui、Shaohan Huang、Furu Wei 和 Ming Zhou 在LayoutLM: Pre-training of Text and Layout for Document Image Understanding中提出的。

此模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

<来源>

( input_ids: Optional = None bbox: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None encoder_hidden_states: Optional = None encoder_attention_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.MaskedLMOutput or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）— 词汇表中输入序列标记的索引。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是输入 ID？
• bbox（形状为(batch_size, sequence_length, 4)的torch.LongTensor，可选）— 每个输入序列标记的边界框。在范围[0, config.max_2d_position_embeddings-1]中选择。每个边界框应该是(x0, y0, x1, y1)格式的归一化版本，其中(x0, y0)对应于边界框左上角的位置，(x1, y1)表示右下角的位置。有关归一化，请参阅概述。
• attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）— 用于避免在填充标记索引上执行注意力的掩码。掩码值在[0, 1]中选择：1表示未被掩码的标记，0表示被掩码的标记。 什么是注意力掩码？
• token_type_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 段标记索引，用于指示输入的第一部分和第二部分。索引在[0, 1]中选择：0对应于句子 A的标记，1对应于句子 B的标记 什么是 token type IDs？
• position_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。 什么是位置 ID？
• head_mask（形状为(num_heads,)或(num_layers, num_heads)的torch.FloatTensor，可选）— 用于使自注意力模块中的选定头部失效的掩码。掩码值在[0, 1]中选择：1表示头部未被掩码，0表示头部被掩码。
• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。
• output_attentions（bool，可选）— 如果设置为True，则返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回的张量下的attentions。
• output_hidden_states（bool，可选）— 如果设置为True，则返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。
• return_dict（bool，可选）— 如果设置为True，模型将返回一个 ModelOutput 而不是一个普通元组。
• labels（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 用于计算掩码语言建模损失的标签。索引应在[-100, 0, ..., config.vocab_size]内（参见input_ids文档字符串）。索引设置为-100的标记将被忽略（掩码），损失仅计算具有标签在[0, ..., config.vocab_size]内的标记。

返回

transformers.modeling_outputs.MaskedLMOutput 或tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.MaskedLMOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False时）包含根据配置（LayoutLMConfig）和输入的各种元素。

• 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时返回）— 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入的输出，如果模型有一个嵌入层，+ 一个用于每个层的输出）。 模型在每一层输出的隐藏状态以及可选的初始嵌入输出。
• attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）— 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每个层一个）。 注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

LayoutLMForMaskedLM 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用Module实例，而不是这个，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, LayoutLMForMaskedLM
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/layoutlm-base-uncased")
>>> model = LayoutLMForMaskedLM.from_pretrained("microsoft/layoutlm-base-uncased")

>>> words = ["Hello", "[MASK]"]
>>> normalized_word_boxes = [637, 773, 693, 782], [698, 773, 733, 782]

>>> token_boxes = []
>>> for word, box in zip(words, normalized_word_boxes):
...     word_tokens = tokenizer.tokenize(word)
...     token_boxes.extend([box] * len(word_tokens))
>>> # add bounding boxes of cls + sep tokens
>>> token_boxes = [[0, 0, 0, 0]] + token_boxes + [[1000, 1000, 1000, 1000]]

>>> encoding = tokenizer(" ".join(words), return_tensors="pt")
>>> input_ids = encoding["input_ids"]
>>> attention_mask = encoding["attention_mask"]
>>> token_type_ids = encoding["token_type_ids"]
>>> bbox = torch.tensor([token_boxes])

>>> labels = tokenizer("Hello world", return_tensors="pt")["input_ids"]

>>> outputs = model(
...     input_ids=input_ids,
...     bbox=bbox,
...     attention_mask=attention_mask,
...     token_type_ids=token_type_ids,
...     labels=labels,
... )

>>> loss = outputs.loss

LayoutLMForSequenceClassification

class transformers.LayoutLMForSequenceClassification

<来源>

( config )

参数

• config（LayoutLMConfig）— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，只加载配置。查看 from_pretrained()方法以加载模型权重。

LayoutLM 模型在顶部使用序列分类头部（池化输出的顶部线性层），例如用于文档图像分类任务的RVL-CDIP数据集。

LayoutLM 模型由 Yiheng Xu、Minghao Li、Lei Cui、Shaohan Huang、Furu Wei 和 Ming Zhou 在LayoutLM: Pre-training of Text and Layout for Document Image Understanding中提出。

该模型是 PyTorch torch.nn.Module的子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有事项。

forward

<来源>

( input_ids: Optional = None bbox: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.SequenceClassifierOutput or tuple(torch.FloatTensor)

参数

• input_ids（torch.LongTensor，形状为(batch_size, sequence_length)）— 词汇表中输入序列标记的索引。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是输入 ID？
• bbox（torch.LongTensor，形状为(batch_size, sequence_length, 4)，可选）— 每个输入序列标记的边界框。在范围[0, config.max_2d_position_embeddings-1]中选择。每个边界框应该是(x0, y0, x1, y1)格式的归一化版本，其中(x0, y0)对应于边界框左上角的位置，(x1, y1)表示右下角的位置。有关归一化，请参阅概述。
• 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的标记 什么是标记类型 ID？
• position_ids（torch.LongTensor，形状为(batch_size, sequence_length)，可选）— 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。 什么是位置 ID？
• 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，可选）— 如果设置为True，则返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
• output_hidden_states（bool，可选）— 如果设置为True，则返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
• return_dict（bool，可选）— 如果设置为True，模型将返回一个 ModelOutput，而不是一个普通的元组。
• labels (torch.LongTensor，形状为(batch_size,)，可选) — 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels == 1，则计算回归损失（均方损失），如果config.num_labels > 1，则计算分类损失（交叉熵）。

返回

transformers.modeling_outputs.SequenceClassifierOutput 或tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.SequenceClassifierOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False时）包含各种元素，取决于配置（LayoutLMConfig）和输入。

• loss (torch.FloatTensor，形状为(1,)，可选，当提供labels时返回) — 分类（或回归，如果 config.num_labels==1）损失。
• logits (torch.FloatTensor，形状为(batch_size, config.num_labels)) — 分类（或回归，如果 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 后的值。

LayoutLMForSequenceClassification 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的方法需要在此函数内定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者会负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, LayoutLMForSequenceClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/layoutlm-base-uncased")
>>> model = LayoutLMForSequenceClassification.from_pretrained("microsoft/layoutlm-base-uncased")

>>> words = ["Hello", "world"]
>>> normalized_word_boxes = [637, 773, 693, 782], [698, 773, 733, 782]

>>> token_boxes = []
>>> for word, box in zip(words, normalized_word_boxes):
...     word_tokens = tokenizer.tokenize(word)
...     token_boxes.extend([box] * len(word_tokens))
>>> # add bounding boxes of cls + sep tokens
>>> token_boxes = [[0, 0, 0, 0]] + token_boxes + [[1000, 1000, 1000, 1000]]

>>> encoding = tokenizer(" ".join(words), return_tensors="pt")
>>> input_ids = encoding["input_ids"]
>>> attention_mask = encoding["attention_mask"]
>>> token_type_ids = encoding["token_type_ids"]
>>> bbox = torch.tensor([token_boxes])
>>> sequence_label = torch.tensor([1])

>>> outputs = model(
...     input_ids=input_ids,
...     bbox=bbox,
...     attention_mask=attention_mask,
...     token_type_ids=token_type_ids,
...     labels=sequence_label,
... )

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

LayoutLMForTokenClassification

class transformers.LayoutLMForTokenClassification

<来源>

( config )

参数

• config (LayoutLMConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，只加载配置。查看 from_pretrained()方法以加载模型权重。

LayoutLM 模型在顶部带有一个标记分类头（隐藏状态输出的顶部是一个线性层），例如用于序列标记（信息提取）任务，如FUNSD数据集和SROIE数据集。

LayoutLM 模型由 Yiheng Xu、Minghao Li、Lei Cui、Shaohan Huang、Furu Wei 和 Ming Zhou 在LayoutLM: Pre-training of Text and Layout for Document Image Understanding中提出。

此模型是 PyTorch torch.nn.Module 的子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

< source >

( input_ids: Optional = None bbox: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.TokenClassifierOutput or tuple(torch.FloatTensor)

参数

• input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参见 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是输入 ID？
• bbox (torch.LongTensor of shape (batch_size, sequence_length, 4), optional) — 每个输入序列标记的边界框。在范围 [0, config.max_2d_position_embeddings-1] 中选择。每个边界框应该是一个规范化版本，格式为 (x0, y0, x1, y1)，其中 (x0, y0) 对应于边界框左上角的位置，(x1, y1) 表示右下角的位置。有关规范化，请参见概述。
• attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值在 [0, 1] 中选择：1 表示未被掩码的标记，0 表示被掩码的标记。 什么是注意力掩码？
• token_type_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 段落标记索引，用于指示输入的第一部分和第二部分。索引在 [0, 1] 中选择：0 对应于 句子 A 标记，1 对应于 句子 B 标记 什么是标记类型 ID？
• position_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 每个输入序列标记在位置嵌入中的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。 什么是位置 ID？
• head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于使自注意力模块中的选定头部失效的掩码。掩码值在 [0, 1] 中选择：1 表示头部未被掩码，0 表示头部被掩码。
• inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您想要更多控制权，以便将 input_ids 索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。
• output_attentions (bool, optional) — 如果设置为 True，将返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的 attentions。
• output_hidden_states (bool, optional) — 如果设置为 True，将返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的 hidden_states。
• return_dict (bool, optional) — 如果设置为 True，模型将返回一个 ModelOutput，而不是一个普通的元组。
• labels (torch.LongTensor of shape (batch_size, sequence_length), optional) — 用于计算标记分类损失的标签。索引应在 [0, ..., config.num_labels - 1] 中。

返回

transformers.modeling_outputs.TokenClassifierOutput 或 tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.TokenClassifierOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含各种元素，取决于配置(LayoutLMConfig)和输入。

• loss (torch.FloatTensor，形状为(1,)，可选，当提供labels时返回) — 分类损失。
• logits (torch.FloatTensor，形状为(batch_size, sequence_length, config.num_labels)) — 分类分数（SoftMax 之前）。
• hidden_states (tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入输出的输出+每层的输出）。 模型在每一层输出的隐藏状态以及可选的初始嵌入输出。
• attentions (tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。 在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

LayoutLMForTokenClassification 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在之后调用Module实例，而不是在此处调用，因为前者会负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, LayoutLMForTokenClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/layoutlm-base-uncased")
>>> model = LayoutLMForTokenClassification.from_pretrained("microsoft/layoutlm-base-uncased")

>>> words = ["Hello", "world"]
>>> normalized_word_boxes = [637, 773, 693, 782], [698, 773, 733, 782]

>>> token_boxes = []
>>> for word, box in zip(words, normalized_word_boxes):
...     word_tokens = tokenizer.tokenize(word)
...     token_boxes.extend([box] * len(word_tokens))
>>> # add bounding boxes of cls + sep tokens
>>> token_boxes = [[0, 0, 0, 0]] + token_boxes + [[1000, 1000, 1000, 1000]]

>>> encoding = tokenizer(" ".join(words), return_tensors="pt")
>>> input_ids = encoding["input_ids"]
>>> attention_mask = encoding["attention_mask"]
>>> token_type_ids = encoding["token_type_ids"]
>>> bbox = torch.tensor([token_boxes])
>>> token_labels = torch.tensor([1, 1, 0, 0]).unsqueeze(0)  # batch size of 1

>>> outputs = model(
...     input_ids=input_ids,
...     bbox=bbox,
...     attention_mask=attention_mask,
...     token_type_ids=token_type_ids,
...     labels=token_labels,
... )

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

LayoutLMForQuestionAnswering

class transformers.LayoutLMForQuestionAnswering

< source >

( config has_visual_segment_embedding = True )

参数

• config (LayoutLMConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，只会加载配置。查看 from_pretrained()方法来加载模型权重。

LayoutLM 模型在顶部有一个跨度分类头，用于提取问答任务，例如DocVQA（在最终隐藏状态输出的顶部有一个线性层，用于计算span start logits和span end logits）。

LayoutLM 模型由 Yiheng Xu、Minghao Li、Lei Cui、Shaohan Huang、Furu Wei 和 Ming Zhou 在LayoutLM: Pre-training of Text and Layout for Document Image Understanding中提出。

这个模型是 PyTorch 的torch.nn.Module子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有信息。

forward

< source >

( input_ids: Optional = None bbox: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None start_positions: Optional = None end_positions: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.QuestionAnsweringModelOutput or tuple(torch.FloatTensor)

返回

transformers.modeling_outputs.QuestionAnsweringModelOutput 或torch.FloatTensor元组

一个 transformers.modeling_outputs.QuestionAnsweringModelOutput 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或 config.return_dict=False）包含根据配置（LayoutLMConfig）和输入的不同元素。

• loss (torch.FloatTensor，形状为 (1,)，可选，当提供 labels 时返回） — 总跨度提取损失是起始位置和结束位置的交叉熵之和。
• start_logits (torch.FloatTensor，形状为 (batch_size, sequence_length)) — 跨度起始分数（SoftMax 之前）。
• end_logits (torch.FloatTensor，形状为 (batch_size, sequence_length)) — 跨度结束分数（SoftMax 之前）。
• hidden_states (tuple(torch.FloatTensor)，可选，当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回） — 形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor 元组（如果模型有嵌入层，则为嵌入的输出 + 每层的输出）。 模型在每一层输出的隐藏状态加上可选的初始嵌入输出。
• attentions (tuple(torch.FloatTensor)，可选，当传递 output_attentions=True 或 config.output_attentions=True 时返回） — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 torch.FloatTensor 元组（每层一个）。 注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

start_positions (torch.LongTensor，形状为 (batch_size,)，可选）：用于计算标记跨度的起始位置（索引）的标签。位置被夹紧到序列的长度（sequence_length）。超出序列范围的位置不会计入损失计算。end_positions (torch.LongTensor，形状为 (batch_size,)，可选）：用于计算标记跨度的结束位置（索引）的标签。位置被夹紧到序列的长度（sequence_length）。超出序列范围的位置不会计入损失计算。

示例：

在下面的示例中，我们为 LayoutLM 模型准备了一个问题 + 上下文对。它将给我们一个预测，告诉我们它认为答案是什么（从图像解析的文本中提取的答案跨度）。

>>> from transformers import AutoTokenizer, LayoutLMForQuestionAnswering
>>> from datasets import load_dataset
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("impira/layoutlm-document-qa", add_prefix_space=True)
>>> model = LayoutLMForQuestionAnswering.from_pretrained("impira/layoutlm-document-qa", revision="1e3ebac")

>>> dataset = load_dataset("nielsr/funsd", split="train")
>>> example = dataset[0]
>>> question = "what's his name?"
>>> words = example["words"]
>>> boxes = example["bboxes"]

>>> encoding = tokenizer(
...     question.split(), words, is_split_into_words=True, return_token_type_ids=True, return_tensors="pt"
... )
>>> bbox = []
>>> for i, s, w in zip(encoding.input_ids[0], encoding.sequence_ids(0), encoding.word_ids(0)):
...     if s == 1:
...         bbox.append(boxes[w])
...     elif i == tokenizer.sep_token_id:
...         bbox.append([1000] * 4)
...     else:
...         bbox.append([0] * 4)
>>> encoding["bbox"] = torch.tensor([bbox])

>>> word_ids = encoding.word_ids(0)
>>> outputs = model(**encoding)
>>> loss = outputs.loss
>>> start_scores = outputs.start_logits
>>> end_scores = outputs.end_logits
>>> start, end = word_ids[start_scores.argmax(-1)], word_ids[end_scores.argmax(-1)]
>>> print(" ".join(words[start : end + 1]))
M. Hamann P. Harper, P. Martinez

TensorFlow 隐藏 TensorFlow 内容

TFLayoutLMModel

class transformers.TFLayoutLMModel

< source >

( config: LayoutLMConfig *inputs **kwargs )

参数

• config（LayoutLMConfig） — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只加载配置。查看 from_pretrained() 方法以加载模型权重。

裸的 LayoutLM 模型变压器输出原始隐藏状态，没有特定的头部。

这个模型继承自 TFPreTrainedModel。查看超类文档，了解库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

这个模型也是一个 tf.keras.Model 的子类。将其用作常规的 TF 2.0 Keras 模型，并参考 TF 2.0 文档以获取有关一般用法和行为的所有相关信息。

transformers 中的 TensorFlow 模型和层接受两种格式的输入：

• 将所有输入作为关键字参数（类似于 PyTorch 模型），或
• 将所有输入作为列表、元组或字典放在第一个位置参数中。

支持第二种格式的原因是，Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于这种支持，当使用诸如 model.fit() 这样的方法时，应该会“正常工作” - 只需以 model.fit() 支持的任何格式传递输入和标签即可！但是，如果您想在 Keras 方法之外使用第二种格式，比如在使用 Keras Functional API 创建自己的层或模型时，有三种可能性可以用来收集所有输入张量作为第一个位置参数：

• 一个只包含 input_ids 的单个张量，没有其他内容：model(input_ids)
• 一个长度可变的列表，其中包含一个或多个输入张量，按照文档字符串中给定的顺序：model([input_ids, attention_mask]) 或 model([input_ids, attention_mask, token_type_ids])
• 一个字典，其中包含一个或多个与文档字符串中给定的输入名称相关联的输入张量：model({"input_ids": input_ids, "token_type_ids": token_type_ids})

请注意，当使用子类化创建模型和层时，您无需担心这些内容，因为您可以像对待其他 Python 函数一样传递输入！

call

<来源>

( input_ids: TFModelInputType | None = None bbox: np.ndarray | tf.Tensor | None = None attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None encoder_hidden_states: np.ndarray | tf.Tensor | None = None encoder_attention_mask: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: Optional[bool] = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingAndCrossAttentions or tuple(tf.Tensor)

参数

• input_ids（形状为(batch_size, sequence_length)的Numpy数组或tf.Tensor）— 输入序列标记在词汇表中的索引。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.call()和 PreTrainedTokenizer.encode()。 什么是输入 ID？
• bbox（形状为(batch_size, sequence_length, 4)的Numpy数组或tf.Tensor，可选）— 每个输入序列标记的边界框。在范围 [0, config.max_2d_position_embeddings- 1] 中选择。
• attention_mask（形状为(batch_size, sequence_length)的Numpy数组或tf.Tensor，可选）— 用于避免在填充标记索引上执行注意力的掩码。掩码值在 [0, 1] 中选择：
  • 1 表示未被 masked 的标记，
  • 0 表示被 masked 的标记。

  什么是注意力掩码？

• token_type_ids（形状为(batch_size, sequence_length)的Numpy数组或tf.Tensor，可选）— 段标记索引，用于指示输入的第一部分和第二部分。索引在 [0, 1] 中选择：
  • 0 对应于一个 句子 A 的标记，
  • 1 对应于一个 句子 B 的标记。

  什么是标记类型 ID？

• position_ids（形状为(batch_size, sequence_length)的Numpy数组或tf.Tensor，可选）— 每个输入序列标记在位置嵌入中的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。 什么是位置 ID？
• head_mask（形状为(num_heads,)或(num_layers, num_heads)的Numpy数组或tf.Tensor，可选）— 用于使自注意力模块的选定头部失效的掩码。掩码值在 [0, 1] 中选择：
  • 1 表示头部未被 masked，
  • 0 表示头部被 masked。
• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的tf.Tensor，可选）— 可选地，您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您想要更多控制权，以便将 input_ids 索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。
• output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的attentions。
• output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。
• return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。
• training (bool，可选，默认为False) — 是否在训练模式下使用模型（一些模块如 dropout 模块在训练和评估之间有不同的行为）。

返回

transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingAndCrossAttentions 或tuple(tf.Tensor)

transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingAndCrossAttentions 或一个tf.Tensor元组（如果传递return_dict=False或config.return_dict=False时），包括根据配置（LayoutLMConfig）和输入的不同元素。

• last_hidden_state (tf.Tensor of shape (batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列的输出。
• pooler_output (tf.Tensor of shape (batch_size, hidden_size)) — 第一个标记的最后一层隐藏状态（分类标记），经过线性层和 Tanh 激活函数进一步处理。线性层的权重是在预训练期间从下一个句子预测（分类）目标中训练的。 这个输出通常不是输入的语义内容的好摘要，通常最好对整个输入序列的隐藏状态进行平均或池化。
• past_key_values (List[tf.Tensor]，可选，当传递use_cache=True或config.use_cache=True时返回）— 长度为config.n_layers的tf.Tensor列表，每个张量的形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head)）。 包含预计算的隐藏状态（注意力块中的键和值），可用于加速顺序解码（请参见past_key_values输入）。
• hidden_states (tuple(tf.Tensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）— 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入输出，一个用于每一层的输出）。 模型每一层的隐藏状态加上初始嵌入输出。
• attentions (tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）— 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。 注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。
• cross_attentions (tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）— 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。 解码器的交叉注意力层的注意力权重，经过注意力 softmax 后，用于计算交叉注意力头中的加权平均值。

TFLayoutLMModel 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的步骤需要在此函数中定义，但应该在之后调用Module实例，而不是在此处调用，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, TFLayoutLMModel
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/layoutlm-base-uncased")
>>> model = TFLayoutLMModel.from_pretrained("microsoft/layoutlm-base-uncased")

>>> words = ["Hello", "world"]
>>> normalized_word_boxes = [637, 773, 693, 782], [698, 773, 733, 782]

>>> token_boxes = []
>>> for word, box in zip(words, normalized_word_boxes):
...     word_tokens = tokenizer.tokenize(word)
...     token_boxes.extend([box] * len(word_tokens))
>>> # add bounding boxes of cls + sep tokens
>>> token_boxes = [[0, 0, 0, 0]] + token_boxes + [[1000, 1000, 1000, 1000]]

>>> encoding = tokenizer(" ".join(words), return_tensors="tf")
>>> input_ids = encoding["input_ids"]
>>> attention_mask = encoding["attention_mask"]
>>> token_type_ids = encoding["token_type_ids"]
>>> bbox = tf.convert_to_tensor([token_boxes])

>>> outputs = model(
...     input_ids=input_ids, bbox=bbox, attention_mask=attention_mask, token_type_ids=token_type_ids
... )

>>> last_hidden_states = outputs.last_hidden_state

TFLayoutLMForMaskedLM

class transformers.TFLayoutLMForMaskedLM

<来源>

( config: LayoutLMConfig *inputs **kwargs )

参数

• config（LayoutLMConfig）- 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，只会加载配置。查看 from_pretrained()方法以加载模型权重。

在顶部带有语言建模头的 LayoutLM 模型。

此模型继承自 TFPreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

此模型还是一个tf.keras.Model子类。将其用作常规的 TF 2.0 Keras 模型，并参考 TF 2.0 文档以获取与一般用法和行为相关的所有内容。

transformers中的 TensorFlow 模型和层接受两种格式的输入：

• 将所有输入作为关键字参数（类似于 PyTorch 模型）传递，
• 将所有输入作为列表、元组或字典放在第一个位置参数中。

支持第二种格式的原因是，当将输入传递给模型和层时，Keras 方法更喜欢这种格式。由于有此支持，当使用model.fit()等方法时，应该可以正常工作-只需将输入和标签以model.fit()支持的任何格式传递即可！但是，如果您想在 Keras 方法之外使用第二种格式，例如在使用 KerasFunctionalAPI 创建自己的层或模型时，有三种可能性可用于将所有输入张量收集到第一个位置参数中：

• 只有一个包含input_ids的张量，没有其他内容：model(input_ids)
• 一个长度可变的列表，其中包含一个或多个按照文档字符串中给定顺序的输入张量：model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids])
• 一个包含一个或多个与文档字符串中给定输入名称相关联的输入张量的字典：model({"input_ids": input_ids, "token_type_ids": token_type_ids})

请注意，当使用子类化创建模型和层时，您无需担心这些问题，因为您可以像对待任何其他 Python 函数一样传递输入！

call

<来源>

( input_ids: TFModelInputType | None = None bbox: np.ndarray | tf.Tensor | None = None attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None labels: np.ndarray | tf.Tensor | None = None training: Optional[bool] = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFMaskedLMOutput or tuple(tf.Tensor)

参数

• input_ids（形状为(batch_size, sequence_length)的Numpy数组或tf.Tensor）- 词汇表中输入序列标记的索引。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.call()和 PreTrainedTokenizer.encode()。 什么是输入 ID？
• bbox（形状为(batch_size, sequence_length, 4)的Numpy数组或tf.Tensor，可选）- 每个输入序列标记的边界框。选择范围为[0, config.max_2d_position_embeddings- 1]。
• attention_mask (Numpy 数组或形状为(batch_size, sequence_length)的tf.Tensor，可选) — 避免在填充标记索引上执行注意力的掩码。选择的掩码值在[0, 1]中：
  • 对于未被遮蔽的标记，
  • 0 表示头部被遮蔽。

  什么是注意力掩码？

• token_type_ids (Numpy 数组或形状为(batch_size, sequence_length)的tf.Tensor，可选) — 段标记索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：
  • 0 对应于句子 A标记，
  • 1 对应于句子 B标记。

  什么是标记类型 ID？

• position_ids (Numpy 数组或形状为(batch_size, sequence_length)的tf.Tensor，可选) — 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。 什么是位置 ID？
• head_mask (Numpy 数组或形状为(num_heads,)或(num_layers, num_heads)的tf.Tensor，可选) — 用于使自注意力模块的选定头部失效的掩码。选择的掩码值在[0, 1]中：
  • 1 表示头部未被遮蔽，
  • 0 表示头部被遮蔽。
• inputs_embeds (形状为(batch_size, sequence_length, hidden_size)的tf.Tensor，*可选*) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制权来将input_ids`索引转换为相关向量，这将非常有用，而不是使用模型的内部嵌入查找矩阵。
• output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。
• output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。
• return_dict (bool, 可选) — 是否返回一个 ModelOutput 而不是一个普通元组。
• training (bool，可选，默认为False) — 是否在训练模式下使用模型（一些模块，如 dropout 模块，在训练和评估之间具有不同的行为）。
• labels (tf.Tensor或形状为(batch_size, sequence_length)的np.ndarray，可选) — 用于计算遮蔽语言建模损失的标签。索引应在[-100, 0, ..., config.vocab_size]内（参见input_ids文档字符串）。索引设置为-100的标记将被忽略（遮蔽），损失仅计算具有标签在[0, ..., config.vocab_size]内的标记。

返回

transformers.modeling_tf_outputs.TFMaskedLMOutput 或tuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFMaskedLMOutput 或一个tf.Tensor元组（如果传递了return_dict=False或当config.return_dict=False时）包含各种元素，具体取决于配置（LayoutLMConfig）和输入。

• loss (形状为(n,)的tf.Tensor，*可选*，当提供labels`时返回，其中 n 是非遮蔽标签的数量) — 遮蔽语言建模（MLM）损失。
• logits (形状为(batch_size, sequence_length, config.vocab_size)的tf.Tensor`) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
• hidden_states (tuple(tf.Tensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回） — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入的输出 + 一个用于每个层的输出）。 模型在每一层的输出以及初始嵌入输出的隐藏状态。
• attentions（tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回） - 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组。 在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

TFLayoutLMForMaskedLM 的前向方法覆盖了__call__特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在之后调用Module实例，而不是调用此函数，因为前者会负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, TFLayoutLMForMaskedLM
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/layoutlm-base-uncased")
>>> model = TFLayoutLMForMaskedLM.from_pretrained("microsoft/layoutlm-base-uncased")

>>> words = ["Hello", "[MASK]"]
>>> normalized_word_boxes = [637, 773, 693, 782], [698, 773, 733, 782]

>>> token_boxes = []
>>> for word, box in zip(words, normalized_word_boxes):
...     word_tokens = tokenizer.tokenize(word)
...     token_boxes.extend([box] * len(word_tokens))
>>> # add bounding boxes of cls + sep tokens
>>> token_boxes = [[0, 0, 0, 0]] + token_boxes + [[1000, 1000, 1000, 1000]]

>>> encoding = tokenizer(" ".join(words), return_tensors="tf")
>>> input_ids = encoding["input_ids"]
>>> attention_mask = encoding["attention_mask"]
>>> token_type_ids = encoding["token_type_ids"]
>>> bbox = tf.convert_to_tensor([token_boxes])

>>> labels = tokenizer("Hello world", return_tensors="tf")["input_ids"]

>>> outputs = model(
...     input_ids=input_ids,
...     bbox=bbox,
...     attention_mask=attention_mask,
...     token_type_ids=token_type_ids,
...     labels=labels,
... )

>>> loss = outputs.loss

TFLayoutLMForSequenceClassification

class transformers.TFLayoutLMForSequenceClassification

<来源>

( config: LayoutLMConfig *inputs **kwargs )

参数

• config（LayoutLMConfig） - 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只加载配置。查看 from_pretrained()方法以加载模型权重。

LayoutLM 模型变压器顶部带有序列分类/回归头（池化输出的线性层），例如用于 GLUE 任务。

这个模型继承自 TFPreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

这个模型也是一个tf.keras.Model子类。将其用作常规的 TF 2.0 Keras 模型，并参考 TF 2.0 文档以获取与一般用法和行为相关的所有信息。

transformers中的 TensorFlow 模型和层接受两种格式的输入：

• 将所有输入作为关键字参数（类似于 PyTorch 模型），或者
• 将所有输入作为列表、元组或字典放在第一个位置参数中。

支持第二种格式的原因是，当将输入传递给模型和层时，Keras 方法更喜欢这种格式。由于有了这种支持，当使用model.fit()等方法时，应该可以“正常工作” - 只需以model.fit()支持的任何格式传递输入和标签！但是，如果您想在 Keras 方法之外使用第二种格式，例如在使用 KerasFunctional API 创建自己的层或模型时，有三种可能性可以用来收集第一个位置参数中的所有输入张量：

• 一个只有input_ids的单个张量，没有其他内容：model(input_ids)
• 一个长度可变的列表，其中包含一个或多个按照文档字符串中给定顺序的输入张量：model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids])
• 一个字典，其中包含与文档字符串中给定输入名称相关联的一个或多个输入张量：model({"input_ids": input_ids, "token_type_ids": token_type_ids})

请注意，当使用子类化创建模型和层时，您无需担心这些问题，因为您可以像对待其他 Python 函数一样传递输入！

call

<来源>

( input_ids: TFModelInputType | None = None bbox: np.ndarray | tf.Tensor | None = None attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None labels: np.ndarray | tf.Tensor | None = None training: Optional[bool] = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFSequenceClassifierOutput or tuple(tf.Tensor)

参数

• input_ids (Numpy array 或 tf.Tensor，形状为 (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。 什么是输入 ID？
• bbox (Numpy array 或 tf.Tensor，形状为 (batch_size, sequence_length, 4)，可选) — 每个输入序列标记的边界框。选择范围为 [0, config.max_2d_position_embeddings- 1]。
• attention_mask (Numpy array 或 tf.Tensor，形状为 (batch_size, sequence_length)，可选) — 避免在填充标记索引上执行注意力的掩码。掩码值选择在 [0, 1]：
  • 1 表示未被 masked 的标记，
  • 0 表示被 masked 的标记。

  什么是注意力掩码？

• token_type_ids (Numpy array 或 tf.Tensor，形状为 (batch_size, sequence_length)，可选) — 段标记索引，指示输入的第一部分和第二部分。索引选择在 [0, 1]：
  • 0 对应于 句子 A 标记，
  • 1 对应于 句子 B 标记。

  什么是标记类型 ID？

• position_ids (Numpy array 或 tf.Tensor，形状为 (batch_size, sequence_length)，可选) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为 [0, config.max_position_embeddings - 1]。 什么是位置 ID？
• head_mask (Numpy array 或 tf.Tensor，形状为 (num_heads,) 或 (num_layers, num_heads)，可选) — 用于使自注意力模块中选定头部失效的掩码。掩码值选择在 [0, 1]：
  • 1 表示头部未被 masked，
  • 0 表示头部被 masked。
• inputs_embeds (tf.Tensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示而不是传递 input_ids。如果您想要更多控制如何将 input_ids 索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。
• output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的 attentions。
• output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的 hidden_states。
• return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。
• training (bool，可选，默认为 False) — 是否在训练模式下使用模型（一些模块如 dropout 模块在训练和评估之间有不同的行为）。
• labels (tf.Tensor 或 np.ndarray，形状为 (batch_size,)，可选) — 用于计算序列分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1]。如果 config.num_labels == 1，则计算回归损失（均方损失），如果 config.num_labels > 1，则计算分类损失（交叉熵）。

返回

transformers.modeling_tf_outputs.TFSequenceClassifierOutput 或 tuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFSequenceClassifierOutput 或一个tf.Tensor元组（如果传递了return_dict=False或config.return_dict=False时）包含各种元素，取决于配置（LayoutLMConfig）和输入。

• loss（形状为(batch_size, )的tf.Tensor，可选，当提供labels时返回）-分类（如果 config.num_labels==1 则为回归）损失。
• logits（形状为(batch_size, config.num_labels)的tf.Tensor）-分类（如果 config.num_labels==1 则为回归）分数（SoftMax 之前）。
• hidden_states（tuple(tf.Tensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）-形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入的输出+一个用于每一层的输出）。 模型在每一层输出处的隐藏状态以及初始嵌入输出。
• attentions（tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）-形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。 注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

TFLayoutLMForSequenceClassification 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用Module实例，而不是这个，因为前者会负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, TFLayoutLMForSequenceClassification
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/layoutlm-base-uncased")
>>> model = TFLayoutLMForSequenceClassification.from_pretrained("microsoft/layoutlm-base-uncased")

>>> words = ["Hello", "world"]
>>> normalized_word_boxes = [637, 773, 693, 782], [698, 773, 733, 782]

>>> token_boxes = []
>>> for word, box in zip(words, normalized_word_boxes):
...     word_tokens = tokenizer.tokenize(word)
...     token_boxes.extend([box] * len(word_tokens))
>>> # add bounding boxes of cls + sep tokens
>>> token_boxes = [[0, 0, 0, 0]] + token_boxes + [[1000, 1000, 1000, 1000]]

>>> encoding = tokenizer(" ".join(words), return_tensors="tf")
>>> input_ids = encoding["input_ids"]
>>> attention_mask = encoding["attention_mask"]
>>> token_type_ids = encoding["token_type_ids"]
>>> bbox = tf.convert_to_tensor([token_boxes])
>>> sequence_label = tf.convert_to_tensor([1])

>>> outputs = model(
...     input_ids=input_ids,
...     bbox=bbox,
...     attention_mask=attention_mask,
...     token_type_ids=token_type_ids,
...     labels=sequence_label,
... )

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

TFLayoutLMForTokenClassification

class transformers.TFLayoutLMForTokenClassification

<来源>

( config: LayoutLMConfig *inputs **kwargs )

参数

• config（LayoutLMConfig）-模型配置类，具有模型的所有参数。使用配置文件初始化不会加载与模型关联的权重，只加载配置。查看 from_pretrained()方法以加载模型权重。

LayoutLM 模型在顶部带有一个标记分类头（隐藏状态输出的顶部线性层），例如用于命名实体识别（NER）任务。

该模型继承自 TFPreTrainedModel。查看超类文档以获取库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入、修剪头等）。

这个模型也是一个tf.keras.Model子类。将其用作常规的 TF 2.0 Keras 模型，并参考 TF 2.0 文档以获取与一般用法和行为相关的所有内容。

transformers中的 TensorFlow 模型和层接受两种格式的输入：

• 将所有输入作为关键字参数（类似于 PyTorch 模型），或
• 将所有输入作为列表、元组或字典的第一个位置参数。

支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于有了这种支持，当使用model.fit()等方法时，您应该可以“轻松处理” - 只需以model.fit()支持的任何格式传递输入和标签即可！但是，如果您想在 Keras 方法之外使用第二种格式，比如在使用 Keras Functional API 创建自己的层或模型时，有三种可能性可以用来收集第一个位置参数中的所有输入张量：

• 一个仅包含input_ids的单个张量，没有其他内容：model(input_ids)
• 一个长度不同的列表，其中包含按照文档字符串中给定的顺序的一个或多个输入张量：model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids])
• 一个包含与文档字符串中给定的输入名称相关联的一个或多个输入张量的字典：model({"input_ids": input_ids, "token_type_ids": token_type_ids})

请注意，当使用子类化创建模型和层时，您无需担心这些问题，因为您可以像对待任何其他 Python 函数一样传递输入！

call

<来源>

( input_ids: TFModelInputType | None = None bbox: np.ndarray | tf.Tensor | None = None attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None labels: np.ndarray | tf.Tensor | None = None training: Optional[bool] = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFTokenClassifierOutput or tuple(tf.Tensor)

参数

• input_ids（形状为(batch_size, sequence_length)的Numpy数组或tf.Tensor）- 词汇表中输入序列令牌的索引。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.call()和 PreTrainedTokenizer.encode()。 什么是输入 ID？
• bbox（形状为(batch_size, sequence_length, 4)的Numpy数组或tf.Tensor，可选）- 每个输入序列令牌的边界框。在范围[0, config.max_2d_position_embeddings- 1]中选择。
• attention_mask（形状为(batch_size, sequence_length)的Numpy数组或tf.Tensor，可选）- 用于避免在填充令牌索引上执行注意力的掩码。掩码值在[0, 1]中选择：
  • 1 表示未被masked的令牌，
  • 0 表示被masked的令牌。

  什么是注意力掩码？

• token_type_ids（形状为(batch_size, sequence_length)的Numpy数组或tf.Tensor，可选）- 分段令牌索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：
  • 0 对应于句子 A令牌，
  • 1 对应于句子 B令牌。

  什么是令牌类型 ID？

• position_ids（形状为(batch_size, sequence_length)的Numpy数组或tf.Tensor，可选）- 每个输入序列令牌在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。 什么是位置 ID？
• head_mask（形状为(num_heads,)或(num_layers, num_heads)的Numpy数组或tf.Tensor，可选）- 用于使自注意力模块中选择的头部失效的掩码。掩码值在[0, 1]中选择：
  • 1 表示头部未被masked，
  • 0 表示头部被masked。
• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的tf.Tensor，可选）- 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制权，以便将input_ids索引转换为相关向量，而不是模型的内部嵌入查找矩阵。
• output_attentions (bool，optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。
• training (bool，optional，默认为False) — 是否在训练模式下使用模型（一些模块，如 dropout 模块，在训练和评估之间有不同的行为）。
• labels (tf.Tensor或形状为(batch_size, sequence_length)的np.ndarray，optional) — 用于计算标记分类损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。

返回

transformers.modeling_tf_outputs.TFTokenClassifierOutput 或tuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFTokenClassifierOutput 或一个tf.Tensor元组（如果传递return_dict=False或config.return_dict=False）包含根据配置（LayoutLMConfig）和输入的不同元素。

• loss (tf.Tensor，形状为(n,)，optional，当提供labels时返回，其中 n 是未屏蔽标签的数量) — 分类损失。
• logits (tf.Tensor，形状为(batch_size, sequence_length, config.num_labels)) — 分类分数（SoftMax 之前）。
• hidden_states (tuple(tf.Tensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入的输出 + 一个用于每个层的输出）。 每个层的模型的隐藏状态加上初始嵌入输出。
• attentions (tuple(tf.Tensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每个层一个）。 注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

TFLayoutLMForTokenClassification 的前向方法，覆盖__call__特殊方法。

虽然前向传递的配方需要在此函数内定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例：

>>> import tensorflow as tf
>>> from transformers import AutoTokenizer, TFLayoutLMForTokenClassification

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/layoutlm-base-uncased")
>>> model = TFLayoutLMForTokenClassification.from_pretrained("microsoft/layoutlm-base-uncased")

>>> words = ["Hello", "world"]
>>> normalized_word_boxes = [637, 773, 693, 782], [698, 773, 733, 782]

>>> token_boxes = []
>>> for word, box in zip(words, normalized_word_boxes):
...     word_tokens = tokenizer.tokenize(word)
...     token_boxes.extend([box] * len(word_tokens))
>>> # add bounding boxes of cls + sep tokens
>>> token_boxes = [[0, 0, 0, 0]] + token_boxes + [[1000, 1000, 1000, 1000]]

>>> encoding = tokenizer(" ".join(words), return_tensors="tf")
>>> input_ids = encoding["input_ids"]
>>> attention_mask = encoding["attention_mask"]
>>> token_type_ids = encoding["token_type_ids"]
>>> bbox = tf.convert_to_tensor([token_boxes])
>>> token_labels = tf.convert_to_tensor([1, 1, 0, 0])

>>> outputs = model(
...     input_ids=input_ids,
...     bbox=bbox,
...     attention_mask=attention_mask,
...     token_type_ids=token_type_ids,
...     labels=token_labels,
... )

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

TFLayoutLMForQuestionAnswering

class transformers.TFLayoutLMForQuestionAnswering

<来源>

( config: LayoutLMConfig *inputs **kwargs )

参数

• config（LayoutLMConfig） — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只会加载配置。查看 from_pretrained()方法以加载模型权重。

LayoutLM 模型，顶部带有用于提取式问答任务（如DocVQA）的跨度分类头（在最终隐藏状态输出的顶部的线性层，用于计算span start logits和span end logits）。

此模型继承自 TFPreTrainedModel。查看超类文档，了解库为其所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

此模型还是一个tf.keras.Model子类。将其用作常规的 TF 2.0 Keras 模型，并参考 TF 2.0 文档以获取有关一般用法和行为的所有相关信息。

transformers中的 TensorFlow 模型和层接受两种格式的输入：

• 将所有输入作为关键字参数（类似于 PyTorch 模型），或
• 将所有输入作为列表、元组或字典放在第一个位置参数中。

支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于这种支持，当使用model.fit()等方法时，应该“只需工作” - 只需以model.fit()支持的任何格式传递输入和标签！但是，如果您想在 Keras 方法之外使用第二种格式，比如在使用 Keras Functional API 创建自己的层或模型时，有三种可能性可以用来收集第一个位置参数中的所有输入张量：

• 只有input_ids的单个张量，没有其他内容：model(input_ids)
• 一个长度可变的列表，其中包含一个或多个按照文档字符串中给定的顺序的输入张量：model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids])
• 一个包含一个或多个与文档字符串中给定的输入名称相关联的输入张量的字典：model({"input_ids": input_ids, "token_type_ids": token_type_ids})

请注意，当使用子类化创建模型和层时，您无需担心这些问题，因为您可以像对待任何其他 Python 函数一样传递输入！

call

<来源>

( input_ids: TFModelInputType | None = None bbox: np.ndarray | tf.Tensor | None = None attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None start_positions: np.ndarray | tf.Tensor | None = None end_positions: np.ndarray | tf.Tensor | None = None training: Optional[bool] = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFQuestionAnsweringModelOutput or tuple(tf.Tensor)

参数

• input_ids（形状为(batch_size, sequence_length)的Numpy数组或tf.Tensor） - 词汇表中输入序列标记的索引。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.call()和 PreTrainedTokenizer.encode()。 什么是输入 ID？
• bbox（形状为(batch_size, sequence_length, 4)的Numpy数组或tf.Tensor，可选） - 每个输入序列标记的边界框。在范围[0, config.max_2d_position_embeddings- 1]中选择。
• attention_mask（形状为(batch_size, sequence_length)的Numpy数组或tf.Tensor，可选） - 遮罩，用于避免在填充标记索引上执行注意力。遮罩值在[0, 1]中选择：
  • 1 表示未被掩码的标记，
  • 0 表示被掩码的标记。

  什么是注意力掩码？

• token_type_ids（形状为(batch_size, sequence_length)的Numpy数组或tf.Tensor，可选） - 段标记索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：
  • 0 对应于句子 A的标记，
  • 1 对应于句子 B的标记。

  什么是标记类型 ID？

• position_ids（形状为(batch_size, sequence_length)的Numpy数组或tf.Tensor，可选） - 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。 什么是位置 ID？
• head_mask (Numpy array or tf.Tensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于使自注意力模块的选定头部失效的掩码。在[0, 1]中选择的掩码值：
  • 1 表示头部未被屏蔽，
  • 0 表示头部被屏蔽。
• inputs_embeds (tf.Tensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，可以直接传递嵌入表示而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，这将非常有用，而不是使用模型的内部嵌入查找矩阵。
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。
• return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通的元组。
• training (bool, optional, 默认为False) — 是否在训练模式下使用模型（一些模块，如 dropout 模块，在训练和评估之间有不同的行为）。
• start_positions (tf.Tensor or np.ndarray of shape (batch_size,), optional) — 用于计算标记跨度开始位置的标签（索引）的位置。位置被夹紧到序列的长度(sequence_length)。序列外的位置不会被考虑在内计算损失。
• end_positions (tf.Tensor or np.ndarray of shape (batch_size,), optional) — 用于计算标记跨度结束位置的标签（索引）的位置。位置被夹紧到序列的长度(sequence_length)。序列外的位置不会被考虑在内计算损失。

返回

transformers.modeling_tf_outputs.TFQuestionAnsweringModelOutput 或tuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFQuestionAnsweringModelOutput 或一个tf.Tensor元组（如果传递return_dict=False或当config.return_dict=False时）包含根据配置（LayoutLMConfig）和输入的各种元素。

• loss (tf.Tensor of shape (batch_size, ), optional, 当提供start_positions和end_positions时返回) — 总跨度提取损失是开始和结束位置的交叉熵之和。
• start_logits (tf.Tensor of shape (batch_size, sequence_length)) — 跨度开始分数（在 SoftMax 之前）。
• end_logits (tf.Tensor of shape (batch_size, sequence_length)) — Span-end scores (before SoftMax).
• hidden_states (tuple(tf.Tensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — 元组的tf.Tensor（一个用于嵌入的输出 + 一个用于每一层的输出）的形状为(batch_size, sequence_length, hidden_size)。 每层模型的隐藏状态加上初始嵌入输出。
• attentions (tuple(tf.Tensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — Tuple of tf.Tensor (one for each layer) of shape (batch_size, num_heads, sequence_length, sequence_length). 用于计算自注意力头中的加权平均值的注意力 softmax 后的注意力权重。

TFLayoutLMForQuestionAnswering 的前向方法重写了__call__特殊方法。

虽然前向传递的配方需要在此函数内定义，但应该在此之后调用Module实例，而不是这个，因为前者负责运行前处理和后处理步骤，而后者则会默默地忽略它们。

示例：

>>> import tensorflow as tf
>>> from transformers import AutoTokenizer, TFLayoutLMForQuestionAnswering
>>> from datasets import load_dataset

>>> tokenizer = AutoTokenizer.from_pretrained("impira/layoutlm-document-qa", add_prefix_space=True)
>>> model = TFLayoutLMForQuestionAnswering.from_pretrained("impira/layoutlm-document-qa", revision="1e3ebac")

>>> dataset = load_dataset("nielsr/funsd", split="train")
>>> example = dataset[0]
>>> question = "what's his name?"
>>> words = example["words"]
>>> boxes = example["bboxes"]

>>> encoding = tokenizer(
...     question.split(), words, is_split_into_words=True, return_token_type_ids=True, return_tensors="tf"
... )
>>> bbox = []
>>> for i, s, w in zip(encoding.input_ids[0], encoding.sequence_ids(0), encoding.word_ids(0)):
...     if s == 1:
...         bbox.append(boxes[w])
...     elif i == tokenizer.sep_token_id:
...         bbox.append([1000] * 4)
...     else:
...         bbox.append([0] * 4)
>>> encoding["bbox"] = tf.convert_to_tensor([bbox])

>>> word_ids = encoding.word_ids(0)
>>> outputs = model(**encoding)
>>> loss = outputs.loss
>>> start_scores = outputs.start_logits
>>> end_scores = outputs.end_logits
>>> start, end = word_ids[tf.math.argmax(start_scores, -1)[0]], word_ids[tf.math.argmax(end_scores, -1)[0]]
>>> print(" ".join(words[start : end + 1]))
M. Hamann P. Harper, P. Martinez

LayoutLMV2

原文链接：huggingface.co/docs/transformers/v4.37.2/en/model_doc/layoutlmv2

概述

LayoutLMV2 模型是由 Yang Xu、Yiheng Xu、Tengchao Lv、Lei Cui、Furu Wei、Guoxin Wang、Yijuan Lu、Dinei Florencio、Cha Zhang、Wanxiang Che、Min Zhang、Lidong Zhou 提出的LayoutLMv2: Multi-modal Pre-training for Visually-Rich Document Understanding。LayoutLMV2 改进了 LayoutLM 以获得跨多个文档图像理解基准的最新结果：

• 从扫描文档中提取信息：FUNSD数据集（包含超过 30,000 个单词的 199 个带注释表格）、CORD数据集（包含 800 张用于训练的收据、100 张用于验证和 100 张用于测试）、SROIE数据集（包含 626 张用于训练和 347 张用于测试的收据）以及Kleister-NDA数据集（包含来自 EDGAR 数据库的非披露协议，包括 254 份用于训练、83 份用于验证和 203 份用于测试的文件）。
• 文档图像分类：RVL-CDIP数据集（包含 40 万张属于 16 个类别的图像）。
• 文档视觉问答：DocVQA数据集（包含在 12,000 多个文档图像上定义的 5 万个问题）。

该论文的摘要如下：

文本和布局的预训练在各种视觉丰富的文档理解任务中已被证明是有效的，这是由于其有效的模型架构和大规模未标记的扫描/数字化文档的优势。在本文中，我们提出了 LayoutLMv2，通过在多模态框架中预训练文本、布局和图像，利用了新的模型架构和预训练任务。具体来说，LayoutLMv2 不仅使用现有的遮蔽视觉语言建模任务，还使用新的文本-图像对齐和文本-图像匹配任务在预训练阶段，从而更好地学习跨模态交互。同时，它还将空间感知自注意机制集成到 Transformer 架构中，使模型能够充分理解不同文本块之间的相对位置关系。实验结果表明，LayoutLMv2 优于强基线，并在各种下游视觉丰富的文档理解任务中取得了新的最先进结果，包括 FUNSD（0.7895 -> 0.8420）、CORD（0.9493 -> 0.9601）、SROIE（0.9524 -> 0.9781）、Kleister-NDA（0.834 -> 0.852）、RVL-CDIP（0.9443 -> 0.9564）和 DocVQA（0.7295 -> 0.8672）。预训练的 LayoutLMv2 模型可以在此 https URL 上公开获取。

LayoutLMv2 依赖于detectron2、torchvision和tesseract。运行以下命令进行安装：

python -m pip install 'git+https://github.com/facebookresearch/detectron2.git'
python -m pip install torchvision tesseract

（如果您正在开发 LayoutLMv2，请注意通过 doctests 还需要安装这些包。）

使用提示

• LayoutLMv1 和 LayoutLMv2 之间的主要区别在于后者在预训练期间包含了视觉嵌入（而 LayoutLMv1 仅在微调期间添加了视觉嵌入）。
• LayoutLMv2 在自注意力层中添加了相对 1D 注意力偏置和空间 2D 注意力偏置到注意力分数中。详细信息可在论文的第 5 页找到。
• 可以在此处找到如何在 RVL-CDIP、FUNSD、DocVQA、CORD 上使用 LayoutLMv2 模型的演示笔记本。
• LayoutLMv2 使用 Facebook AI 的Detectron2包作为其视觉骨干。查看此链接获取安装说明。
• 除了input_ids，forward()还需要 2 个额外的输入，即image和bbox。image输入对应于文本标记出现的原始文档图像。模型期望每个文档图像的大小为 224x224。这意味着如果您有一批文档图像，image应该是形状为(batch_size, 3, 224, 224)的张量。这可以是torch.Tensor或Detectron2.structures.ImageList。您不需要对通道进行归一化，因为模型会自行处理。需要注意的是，视觉主干期望 BGR 通道而不是 RGB，因为 Detectron2 中的所有模型都是使用 BGR 格式进行预训练的。bbox输入是输入文本标记的边界框（即 2D 位置）。这与 LayoutLMModel 相同。可以使用外部 OCR 引擎（例如 Google 的Tesseract）（有一个Python 包装器可用）来获取这些信息。每个边界框应采用(x0, y0, x1, y1)格式，其中(x0, y0)对应于边界框左上角的位置，(x1, y1)表示右下角的位置。请注意，首先需要将边界框归一化为 0-1000 的比例。要进行归一化，可以使用以下函数：

def normalize_bbox(bbox, width, height):
    return [
        int(1000 * (bbox[0] / width)),
        int(1000 * (bbox[1] / height)),
        int(1000 * (bbox[2] / width)),
        int(1000 * (bbox[3] / height)),
    ]

这里，width和height对应于标记出现的原始文档的宽度和高度（在调整图像大小之前）。可以使用 Python Image Library（PIL）库来获取这些信息，例如：

from PIL import Image

image = Image.open(
    "name_of_your_document - can be a png, jpg, etc. of your documents (PDFs must be converted to images)."
)

width, height = image.size

然而，该模型包含一个全新的 LayoutLMv2Processor，可用于直接为模型准备数据（包括在底层应用 OCR）。更多信息可以在下面的“使用”部分找到。

• 在内部，LayoutLMv2Model 将通过其视觉主干发送image输入，以获得一个分辨率较低的特征图，其形状等于 LayoutLMv2Config 的image_feature_pool_shape属性。然后将该特征图展平以获得一系列图像标记。由于特征图的大小默认为 7x7，因此获得 49 个图像标记。然后将这些标记与文本标记连接，并通过 Transformer 编码器发送。这意味着模型的最后隐藏状态将具有长度为 512 + 49 = 561，如果您将文本标记填充到最大长度。更一般地，最后的隐藏状态将具有形状seq_length + image_feature_pool_shape[0] * config.image_feature_pool_shape[1]。
• 在调用 from_pretrained()时，将打印一个警告，其中包含一长串未初始化的参数名称。这不是问题，因为这些参数是批量归一化统计数据，在自定义数据集上微调时将具有值。
• 如果要在分布式环境中训练模型，请确保在模型上调用synchronize_batch_norm，以便正确同步视觉主干的批量归一化层。

此外，还有 LayoutXLM，这是 LayoutLMv2 的多语言版本。更多信息可以在 LayoutXLM 的文档页面找到。

资源

官方 Hugging Face 和社区（由🌎表示）资源列表，可帮助您开始使用 LayoutLMv2。如果您有兴趣提交资源以包含在此处，请随时提出拉取请求，我们将对其进行审查！资源应该展示一些新内容，而不是重复现有资源。

文本分类

• 关于如何在 RVL-CDIP 数据集上对 LayoutLMv2 进行微调以进行文本分类的笔记。
• 另请参阅：文本分类任务指南

问答

• 关于如何在 DocVQA 数据集上对 LayoutLMv2 进行问答微调的笔记。
• 另请参阅：问答任务指南
• 另请参阅：文档问答任务指南

标记分类

• 关于如何在 CORD 数据集上对 LayoutLMv2 进行微调以进行标记分类的笔记。
• 关于如何在 FUNSD 数据集上对 LayoutLMv2 进行微调以进行标记分类的笔记。
• 另请参阅：标记分类任务指南

用法：LayoutLMv2Processor

为模型准备数据的最简单方法是使用 LayoutLMv2Processor，它在内部结合了图像处理器（LayoutLMv2ImageProcessor）和标记器（LayoutLMv2Tokenizer 或 LayoutLMv2TokenizerFast）。图像处理器处理图像模态，而标记器处理文本模态。处理器结合了两者，这对于像 LayoutLMv2 这样的多模态模型是理想的。请注意，如果您只想处理一个模态，仍然可以分别使用两者。

from transformers import LayoutLMv2ImageProcessor, LayoutLMv2TokenizerFast, LayoutLMv2Processor

image_processor = LayoutLMv2ImageProcessor()  # apply_ocr is set to True by default
tokenizer = LayoutLMv2TokenizerFast.from_pretrained("microsoft/layoutlmv2-base-uncased")
processor = LayoutLMv2Processor(image_processor, tokenizer)

简而言之，可以将文档图像（以及可能的其他数据）提供给 LayoutLMv2Processor，它将创建模型期望的输入。在内部，处理器首先使用 LayoutLMv2ImageProcessor 在图像上应用 OCR，以获取单词列表和标准化边界框，并将图像调整大小以获得image输入。然后，单词和标准化边界框提供给 LayoutLMv2Tokenizer 或 LayoutLMv2TokenizerFast，将它们转换为标记级别的input_ids、attention_mask、token_type_ids、bbox。可选地，可以向处理器提供单词标签，这些标签将转换为标记级别的labels。

LayoutLMv2Processor 使用PyTesseract，这是 Google 的 Tesseract OCR 引擎的 Python 封装。请注意，您仍然可以使用自己选择的 OCR 引擎，并自己提供单词和标准化框。这需要使用apply_ocr设置为False来初始化 LayoutLMv2ImageProcessor。

总共有 5 个处理器支持的使用案例。下面我们列出它们。请注意，这些使用案例对批处理和非批处理输入都适用（我们为非批处理输入进行说明）。

使用案例 1：文档图像分类（训练、推理）+标记分类（推理），apply_ocr=True

这是最简单的情况，处理器（实际上是图像处理器）将对图像执行 OCR，以获取单词和标准化边界框。

from transformers import LayoutLMv2Processor
from PIL import Image

processor = LayoutLMv2Processor.from_pretrained("microsoft/layoutlmv2-base-uncased")

image = Image.open(
    "name_of_your_document - can be a png, jpg, etc. of your documents (PDFs must be converted to images)."
).convert("RGB")
encoding = processor(
    image, return_tensors="pt"
)  # you can also add all tokenizer parameters here such as padding, truncation
print(encoding.keys())
# dict_keys(['input_ids', 'token_type_ids', 'attention_mask', 'bbox', 'image'])

使用案例 2：文档图像分类（训练、推理）+标记分类（推理），apply_ocr=False

如果想要自己执行 OCR，可以将图像处理器初始化为apply_ocr设置为False。在这种情况下，应该自己向处理器提供单词和相应的（标准化的）边界框。

from transformers import LayoutLMv2Processor
from PIL import Image

processor = LayoutLMv2Processor.from_pretrained("microsoft/layoutlmv2-base-uncased", revision="no_ocr")

image = Image.open(
    "name_of_your_document - can be a png, jpg, etc. of your documents (PDFs must be converted to images)."
).convert("RGB")
words = ["hello", "world"]
boxes = [[1, 2, 3, 4], [5, 6, 7, 8]]  # make sure to normalize your bounding boxes
encoding = processor(image, words, boxes=boxes, return_tensors="pt")
print(encoding.keys())
# dict_keys(['input_ids', 'token_type_ids', 'attention_mask', 'bbox', 'image'])

使用案例 3：标记分类（训练），apply_ocr=False

对于标记分类任务（如 FUNSD、CORD、SROIE、Kleister-NDA），还可以提供相应的单词标签以训练模型。处理器将把这些转换为标记级别的labels。默认情况下，它只会标记单词的第一个词片，并用-100 标记剩余的词片，这是 PyTorch 的 CrossEntropyLoss 的ignore_index。如果希望标记单词的所有词片，可以将分词器初始化为only_label_first_subword设置为False。

from transformers import LayoutLMv2Processor
from PIL import Image

processor = LayoutLMv2Processor.from_pretrained("microsoft/layoutlmv2-base-uncased", revision="no_ocr")

image = Image.open(
    "name_of_your_document - can be a png, jpg, etc. of your documents (PDFs must be converted to images)."
).convert("RGB")
words = ["hello", "world"]
boxes = [[1, 2, 3, 4], [5, 6, 7, 8]]  # make sure to normalize your bounding boxes
word_labels = [1, 2]
encoding = processor(image, words, boxes=boxes, word_labels=word_labels, return_tensors="pt")
print(encoding.keys())
# dict_keys(['input_ids', 'token_type_ids', 'attention_mask', 'bbox', 'labels', 'image'])

使用案例 4：视觉问答（推理），apply_ocr=True

对于视觉问答任务（如 DocVQA），您可以向处理器提供问题。默认情况下，处理器将在图像上应用 OCR，并创建[CLS]问题标记[SEP]单词标记[SEP]。

from transformers import LayoutLMv2Processor
from PIL import Image

processor = LayoutLMv2Processor.from_pretrained("microsoft/layoutlmv2-base-uncased")

image = Image.open(
    "name_of_your_document - can be a png, jpg, etc. of your documents (PDFs must be converted to images)."
).convert("RGB")
question = "What's his name?"
encoding = processor(image, question, return_tensors="pt")
print(encoding.keys())
# dict_keys(['input_ids', 'token_type_ids', 'attention_mask', 'bbox', 'image'])

使用案例 5：视觉问答（推理），apply_ocr=False

对于视觉问答任务（如 DocVQA），您可以向处理器提供问题。如果您想自己执行 OCR，可以向处理器提供自己的单词和（标准化的）边界框。

from transformers import LayoutLMv2Processor
from PIL import Image

processor = LayoutLMv2Processor.from_pretrained("microsoft/layoutlmv2-base-uncased", revision="no_ocr")

image = Image.open(
    "name_of_your_document - can be a png, jpg, etc. of your documents (PDFs must be converted to images)."
).convert("RGB")
question = "What's his name?"
words = ["hello", "world"]
boxes = [[1, 2, 3, 4], [5, 6, 7, 8]]  # make sure to normalize your bounding boxes
encoding = processor(image, question, words, boxes=boxes, return_tensors="pt")
print(encoding.keys())
# dict_keys(['input_ids', 'token_type_ids', 'attention_mask', 'bbox', 'image'])

LayoutLMv2Config

class transformers.LayoutLMv2Config

<来源>

( 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 max_2d_position_embeddings = 1024 max_rel_pos = 128 rel_pos_bins = 32 fast_qkv = True max_rel_2d_pos = 256 rel_2d_pos_bins = 64 convert_sync_batchnorm = True image_feature_pool_shape = [7, 7, 256] coordinate_size = 128 shape_size = 128 has_relative_attention_bias = True has_spatial_attention_bias = True has_visual_segment_embedding = False detectron2_config_args = None **kwargs )

参数

• vocab_size（int，可选，默认为 30522）—LayoutLMv2 模型的词汇量。定义了在调用 LayoutLMv2Model 或TFLayoutLMv2Model时可以表示的不同标记数量。
• hidden_size（int，可选，默认为 768）—编码器层和池化器层的维度。
• num_hidden_layers（int，可选，默认为 12）—变换器编码器中的隐藏层数量。
• num_attention_heads（int，可选，默认为 12）—变换器编码器中每个注意力层的注意力头数量。
• intermediate_size（int，可选，默认为 3072）—变换器编码器中“中间”（即前馈）层的维度。
• hidden_act（str或function，可选，默认为"gelu"）—编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"、"relu"、"selu"和"gelu_new"。
• hidden_dropout_prob（float，可选，默认为 0.1）—嵌入层、编码器和池化器中所有全连接层的 dropout 概率。
• attention_probs_dropout_prob (float, optional, 默认为 0.1) — 注意力概率的丢弃比率。
• max_position_embeddings (int, optional, 默认为 512) — 此模型可能使用的最大序列长度。通常设置为一个较大的值以防万一（例如 512、1024 或 2048）。
• type_vocab_size (int, optional, 默认为 2) — 在调用 LayoutLMv2Model 或TFLayoutLMv2Model时传递的token_type_ids的词汇表大小。
• initializer_range (float, optional, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
• layer_norm_eps (float, optional, 默认为 1e-12) — 层归一化层使用的 epsilon。
• max_2d_position_embeddings (int, optional, 默认为 1024) — 2D 位置嵌入可能使用的最大值。通常设置为一个较大的值以防万一（例如 1024）。
• max_rel_pos (int, optional, 默认为 128) — 自注意力机制中要使用的相对位置的最大数量。
• rel_pos_bins (int, optional, 默认为 32) — 自注意力机制中要使用的相对位置桶的数量。
• fast_qkv (bool, optional, 默认为True) — 是否在自注意力层中使用单个矩阵作为查询、键、值。
• max_rel_2d_pos (int, optional, 默认为 256) — 自注意力机制中使用的相对 2D 位置的最大数量。
• rel_2d_pos_bins (int, optional, 默认为 64) — 自注意力机制中的 2D 相对位置桶的数量。
• image_feature_pool_shape (List[int], optional, 默认为[7, 7, 256]) — 平均池化特征图的形状。
• coordinate_size (int, optional, 默认为 128) — 坐标嵌入的维度。
• shape_size (int, optional, 默认为 128) — 宽度和高度嵌入的维度。
• has_relative_attention_bias (bool, optional, 默认为True) — 是否在自注意力机制中使用相对注意力偏置。
• has_spatial_attention_bias (bool, optional, 默认为True) — 是否在自注意力机制中使用空间注意力偏置。
• has_visual_segment_embedding (bool, optional, 默认为False) — 是否添加视觉段嵌入。
• detectron2_config_args (dict, optional) — 包含 Detectron2 视觉骨干配置参数的字典。有关默认值的详细信息，请参阅此文件。

这是用于存储 LayoutLMv2Model 配置的配置类。它用于根据指定的参数实例化一个 LayoutLMv2 模型，定义模型架构。使用默认值实例化配置将产生类似于 LayoutLMv2 microsoft/layoutlmv2-base-uncased架构的配置。

配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。

示例:

>>> from transformers import LayoutLMv2Config, LayoutLMv2Model

>>> # Initializing a LayoutLMv2 microsoft/layoutlmv2-base-uncased style configuration
>>> configuration = LayoutLMv2Config()

>>> # Initializing a model (with random weights) from the microsoft/layoutlmv2-base-uncased style configuration
>>> model = LayoutLMv2Model(configuration)

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

LayoutLMv2FeatureExtractor

class transformers.LayoutLMv2FeatureExtractor

<来源>

( *args **kwargs )

__call__

<来源>

( images **kwargs )

预处理图像或一批图像。

LayoutLMv2ImageProcessor

class transformers.LayoutLMv2ImageProcessor

<来源>

( do_resize: bool = True size: Dict = None resample: Resampling = <Resampling.BILINEAR: 2> apply_ocr: bool = True ocr_lang: Optional = None tesseract_config: Optional = '' **kwargs )

参数

• do_resize (bool, 可选, 默认为 True) — 是否将图像的 (height, width) 尺寸调整为 (size["height"], size["width"])。可以被 preprocess 中的 do_resize 覆盖。
• size (Dict[str, int] 可选, 默认为 {"height" -- 224, "width": 224}): 调整大小后的图像尺寸。可以被 preprocess 中的 size 覆盖。
• resample (PILImageResampling, 可选, 默认为 Resampling.BILINEAR) — 用于调整图像大小时使用的重采样滤波器。可以被 preprocess 方法中的 resample 参数覆盖。
• apply_ocr (bool, 可选, 默认为 True) — 是否应用 Tesseract OCR 引擎以获取单词 + 规范化边界框。可以被 preprocess 中的 apply_ocr 覆盖。
• ocr_lang (str, 可选) — 由其 ISO 代码指定的语言，用于 Tesseract OCR 引擎。默认情况下使用英语。可以被 preprocess 中的 ocr_lang 覆盖。
• tesseract_config (str, 可选, 默认为 "") — 转发到调用 Tesseract 时 config 参数的任何额外自定义配置标志。例如: ‘—psm 6’。可以被 preprocess 中的 tesseract_config 覆盖。

构建一个 LayoutLMv2 图像处理器。

preprocess

<来源>

( images: Union do_resize: bool = None size: Dict = None resample: Resampling = None apply_ocr: bool = None ocr_lang: Optional = None tesseract_config: Optional = None return_tensors: Union = None data_format: ChannelDimension = <ChannelDimension.FIRST: 'channels_first'> input_data_format: Union = None **kwargs )

参数

• images (ImageInput) — 要预处理的图像。
• do_resize (bool, 可选, 默认为 self.do_resize) — 是否调整图像大小。
• size (Dict[str, int], 可选, 默认为 self.size) — 调整大小后输出图像的期望尺寸。
• resample (PILImageResampling, 可选, 默认为 self.resample) — 用于调整图像大小时使用的重采样滤波器。可以是枚举 PIL.Image 重采样滤波器之一。仅在 do_resize 设置为 True 时有效。
• apply_ocr (bool, 可选, 默认为 self.apply_ocr) — 是否应用 Tesseract OCR 引擎以获取单词 + 规范化边界框。
• ocr_lang (str, 可选, 默认为 self.ocr_lang) — 由其 ISO 代码指定的语言，用于 Tesseract OCR 引擎。默认情况下使用英语。
• tesseract_config (str, 可选, 默认为 self.tesseract_config) — 转发到调用 Tesseract 时 config 参数的任何额外自定义配置标志。
• return_tensors (str 或 TensorType, 可选) — 要返回的张量类型。可以是以下之一：
  • 未设置: 返回一个 np.ndarray 列表。
  • TensorType.TENSORFLOW 或 'tf': 返回类型为 tf.Tensor 的批处理。
  • TensorType.PYTORCH 或 'pt': 返回类型为 torch.Tensor 的批处理。
  • TensorType.NUMPY 或 'np': 返回类型为 np.ndarray 的批处理。
  • TensorType.JAX 或 'jax': 返回类型为 jax.numpy.ndarray 的批处理。
• data_format (ChannelDimension 或 str, 可选, 默认为 ChannelDimension.FIRST) — 输出图像的通道维度格式。可以是以下之一：
  • ChannelDimension.FIRST: 图像格式为 (num_channels, height, width)。
  • ChannelDimension.LAST: 图像格式为 (height, width, num_channels)。

预处理图像或一批图像。

LayoutLMv2Tokenizer

class transformers.LayoutLMv2Tokenizer

<来源>

( vocab_file do_lower_case = True do_basic_tokenize = True never_split = None unk_token = '[UNK]' sep_token = '[SEP]' pad_token = '[PAD]' cls_token = '[CLS]' mask_token = '[MASK]' cls_token_box = [0, 0, 0, 0] sep_token_box = [1000, 1000, 1000, 1000] pad_token_box = [0, 0, 0, 0] pad_token_label = -100 only_label_first_subword = True tokenize_chinese_chars = True strip_accents = None model_max_length: int = 512 additional_special_tokens: Optional = None **kwargs )

构建一个 LayoutLMv2 分词器。基于 WordPiece。LayoutLMv2Tokenizer 可用于将单词、单词级边界框和可选单词标签转换为标记级的 input_ids、attention_mask、token_type_ids、bbox 和可选的 labels（用于标记分类）。

这个分词器继承自 PreTrainedTokenizer，其中包含大部分主要方法。用户应参考这个超类以获取有关这些方法的更多信息。

LayoutLMv2Tokenizer 运行端到端的分词：标点符号拆分和 wordpiece。它还将单词级边界框转换为标记级边界框。

__call__

< source >

( text: Union text_pair: Union = None boxes: Union = None word_labels: Union = None add_special_tokens: bool = True padding: Union = False truncation: Union = None max_length: Optional = None stride: int = 0 pad_to_multiple_of: Optional = None return_tensors: Union = None return_token_type_ids: Optional = None return_attention_mask: Optional = 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 ) → export const metadata = 'undefined';BatchEncoding

参数

• text（str、List[str]、List[List[str]]）— 要编码的序列或批次序列。每个序列可以是一个字符串，一个字符串列表（单个示例的单词或一批示例的问题）或一个字符串列表的列表（单词批次）。
• text_pair（List[str]、List[List[str]]）— 要编码的序列或批次序列。每个序列应该是一个字符串列表（预分词的字符串）。
• boxes（List[List[int]]、List[List[List[int]]]）— 单词级边界框。每个边界框应该被归一化为 0-1000 的比例。
• word_labels（List[int]、List[List[int]]，可选）— 单词级整数标签（用于标记分类任务，如 FUNSD、CORD）。
• 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 硬件上启用张量核心特别有用。
• return_tensors（str或 TensorType，可选）— 如果设置，将返回张量而不是 Python 整数列表。可接受的值为：
  • 'tf'：返回 TensorFlow tf.constant对象。
  • 'pt'：返回 PyTorch torch.Tensor对象。
  • 'np'：返回 Numpy np.ndarray对象。
• return_token_type_ids（bool，可选）— 是否返回令牌类型 ID。如果保持默认设置，将根据特定分词器的默认值返回令牌类型 ID，由return_outputs属性定义。 令牌类型 ID 是什么？
• return_attention_mask（bool，可选）— 是否返回注意力蒙版。如果保持默认设置，将根据特定分词器的默认值返回注意力蒙版，由return_outputs属性定义。 注意力蒙版是什么？
• return_overflowing_tokens（bool，可选，默认为False）— 是否返回溢出的令牌序列。如果提供了一对输入 ID 序列（或一批对）并且truncation_strategy = longest_first或True，则会引发错误，而不是返回溢出的令牌。
• return_special_tokens_mask（bool，可选，默认为False）— 是否返回特殊令牌蒙版信息。
• return_offsets_mapping（bool，可选，默认为False）— 是否返回每个令牌的(char_start, char_end)。 这仅适用于继承自 PreTrainedTokenizerFast 的快速分词器，如果使用 Python 的分词器，此方法将引发NotImplementedError。
• return_length（bool，可选，默认为False）— 是否返回编码输入的长度。
• verbose（bool，可选，默认为True）— 是否打印更多信息和警告。**kwargs — 传递给self.tokenize()方法

返回

BatchEncoding

具有以下字段的 BatchEncoding：

• input_ids — 要馈送到模型的令牌 ID 列表。 输入 ID 是什么？
• bbox — 要馈送到模型的边界框列表。
• token_type_ids — 要馈送到模型的令牌类型 ID 列表（当return_token_type_ids=True或*token_type_ids*在self.model_input_names中时）。 令牌类型 ID 是什么？
• attention_mask — 指定哪些令牌应该被模型关注的索引列表（当return_attention_mask=True或*attention_mask*在self.model_input_names中时）。 注意力蒙版是什么？
• labels — 要馈送到模型的标签列表（当指定word_labels时）。
• overflowing_tokens — 溢出令牌序列的列表（当指定max_length并且return_overflowing_tokens=True时）。
• num_truncated_tokens — 截断的标记数（当指定max_length并且return_overflowing_tokens=True时）。
• special_tokens_mask — 由 0 和 1 组成的列表，其中 1 指定添加的特殊标记，0 指定常规序列标记（当add_special_tokens=True和return_special_tokens_mask=True时）。
• length — 输入的长度（当return_length=True时）。

对一个或多个序列或一个或多个序列对进行标记化和为模型准备，具有单词级别标准化边界框和可选标签。

save_vocabulary

<来源>

( save_directory: str filename_prefix: Optional = None )

LayoutLMv2TokenizerFast

class transformers.LayoutLMv2TokenizerFast

<来源>

( vocab_file = None tokenizer_file = None do_lower_case = True unk_token = '[UNK]' sep_token = '[SEP]' pad_token = '[PAD]' cls_token = '[CLS]' mask_token = '[MASK]' cls_token_box = [0, 0, 0, 0] sep_token_box = [1000, 1000, 1000, 1000] pad_token_box = [0, 0, 0, 0] pad_token_label = -100 only_label_first_subword = True tokenize_chinese_chars = True strip_accents = None **kwargs )

参数

• vocab_file (str) — 包含词汇表的文件。
• do_lower_case (bool, optional, defaults to True) — 在标记化时是否将输入转换为小写。
• unk_token (str, optional, defaults to "[UNK]") — 未知标记。词汇表中不存在的标记无法转换为 ID，而是设置为此标记。
• sep_token (str, optional, defaults to "[SEP]") — 分隔符标记，在从多个序列构建序列时使用，例如用于序列分类的两个序列或用于文本和问题的问题回答。它也用作使用特殊标记构建的序列的最后一个标记。
• pad_token (str, optional, defaults to "[PAD]") — 用于填充的标记，例如在批处理不同长度的序列时使用。
• cls_token (str, optional, defaults to "[CLS]") — 在进行序列分类（对整个序列而不是每个标记进行分类）时使用的分类器标记。当使用特殊标记构建序列时，它是序列的第一个标记。
• mask_token (str, optional, defaults to "[MASK]") — 用于屏蔽值的标记。在使用掩码语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。
• cls_token_box (List[int], optional, defaults to [0, 0, 0, 0]) — 用于特殊[CLS]标记的边界框。
• sep_token_box (List[int], optional, defaults to [1000, 1000, 1000, 1000]) — 用于特殊[SEP]标记的边界框。
• pad_token_box (List[int], optional, defaults to [0, 0, 0, 0]) — 用于特殊[PAD]标记的边界框。
• pad_token_label (int, optional, defaults to -100) — 用于填充标记的标签。默认为-100，这是 PyTorch 的 CrossEntropyLoss 的ignore_index。
• only_label_first_subword (bool, optional, defaults to True) — 是否仅标记第一个子词，如果提供了单词标签。
• tokenize_chinese_chars (bool, optional, defaults to True) — 是否标记化中文字符。这可能应该在日语中停用（参见此问题）。
• strip_accents (bool, optional) — 是否去除所有重音符号。如果未指定此选项，则将由lowercase的值确定（与原始 LayoutLMv2 中的情况相同）。

构建一个“快速”LayoutLMv2 分词器（由 HuggingFace 的tokenizers库支持）。基于 WordPiece。

此分词器继承自 PreTrainedTokenizerFast，其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。

__call__

<来源>

( text: Union text_pair: Union = None boxes: Union = None word_labels: Union = None add_special_tokens: bool = True padding: Union = False truncation: Union = None max_length: Optional = None stride: int = 0 pad_to_multiple_of: Optional = None return_tensors: Union = None return_token_type_ids: Optional = None return_attention_mask: Optional = 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 ) → export const metadata = 'undefined';BatchEncoding

参数

• text (str, List[str], List[List[str]]) — 要编码的序列或序列批次。每个序列可以是一个字符串，一个字符串列表（单个示例的单词或一批示例的问题）或一个字符串列表的列表（单词批次）。
• text_pair (List[str], List[List[str]]) — 要编码的序列或序列批次。每个序列应该是一个字符串列表（预标记化字符串）。
• boxes (List[List[int]], List[List[List[int]]]) — 单词级别的边界框。每个边界框应标准化为 0-1000 的比例。
• word_labels (List[int], List[List[int]], optional) — 单词级别的整数标签（用于诸如 FUNSD、CORD 等标记分类任务）。
• add_special_tokens (bool, optional, 默认为True) — 是否使用相对于其模型的特殊标记对序列进行编码。
• padding (bool, str 或 PaddingStrategy, optional, 默认为False) — 激活和控制填充。接受以下值：
  • True 或 'longest': 填充到批次中最长的序列（如果只提供单个序列，则不填充）。
  • 'max_length': 填充到由参数max_length指定的最大长度，或者如果未提供该参数，则填充到模型的最大可接受输入长度。
  • False 或 'do_not_pad'（默认）: 不填充（即，可以输出具有不同长度的序列的批次）。
• truncation (bool, str 或 TruncationStrategy, optional, 默认为False) — 激活和控制截断。接受以下值：
  • True 或 'longest_first': 截断到由参数max_length指定的最大长度，或者如果未提供该参数，则截断到模型的最大可接受输入长度。这将逐标记截断，如果提供了一对序列（或一批序列），则从较长序列中删除一个标记。
  • 'only_first': 截断到由参数max_length指定的最大长度，或者如果未提供该参数，则截断到模型的最大可接受输入长度。如果提供了一对序列（或一批序列），则仅截断第一个序列。
  • 'only_second': 截断到由参数max_length指定的最大长度，或者如果未提供该参数，则截断到模型的最大可接受输入长度。如果提供了一对序列（或一批序列），则仅截断第二个序列。
  • False 或 'do_not_truncate'（默认）: 不截断（即，可以输出长度大于模型最大可接受输入大小的批次）。
• max_length (int, optional) — 控制截断/填充参数使用的最大长度。 如果未设置或设置为None，则如果截断/填充参数中的一个需要最大长度，则将使用预定义的模型最大长度。如果模型没有特定的最大输入长度（如 XLNet），则将禁用截断/填充到最大长度。
• stride (int, optional, 默认为 0) — 如果设置为一个数字，并且与max_length一起使用，当return_overflowing_tokens=True时返回的溢出标记将包含截断序列末尾的一些标记，以提供截断和溢出序列之间的一些重叠。此参数的值定义了重叠标记的数量。
• pad_to_multiple_of (int, optional) — 如果设置，将填充序列到提供的值的倍数。这对于在具有计算能力>= 7.5（Volta）的 NVIDIA 硬件上启用 Tensor Cores 特别有用。
• return_tensors（str或 TensorType，可选）— 如果设置，将返回张量而不是 Python 整数列表。可接受的值为：
  • 'tf'：返回 TensorFlow tf.constant 对象。
  • 'pt'：返回 PyTorch torch.Tensor 对象。
  • 'np'：返回 Numpy np.ndarray 对象。
• return_token_type_ids（bool，可选）— 是否返回令牌类型 ID。如果保持默认设置，将根据特定分词器的默认设置返回令牌类型 ID，由return_outputs属性定义。 什么是令牌类型 ID？
• return_attention_mask（bool，可选）— 是否返回注意力掩码。如果保持默认设置，将根据特定分词器的默认设置返回注意力掩码，由return_outputs属性定义。 什么是注意力掩码？
• return_overflowing_tokens（bool，可选，默认为False）— 是否返回溢出的令牌序列。如果提供一对输入 id 序列（或一批对）并且truncation_strategy = longest_first或True，则会引发错误，而不是返回溢出的令牌。
• return_special_tokens_mask（bool，可选，默认为False）— 是否返回特殊令牌掩码信息。
• return_offsets_mapping（bool，可选，默认为False）— 是否返回每个令牌的(char_start, char_end)。 这仅适用于继承自 PreTrainedTokenizerFast 的快速分词器，如果使用 Python 的分词器，此方法将引发NotImplementedError。
• return_length（bool，可选，默认为False）— 是否返回编码输入的长度。
• verbose（bool，可选，默认为True）— 是否打印更多信息和警告。**kwargs — 传递给self.tokenize()方法

返回

BatchEncoding

一个带有以下字段的 BatchEncoding：

• input_ids — 要提供给模型的令牌 id 列表。 什么是输入 ID？
• bbox — 要提供给模型的边界框列表。
• token_type_ids — 要提供给模型的令牌类型 id 列表（当return_token_type_ids=True或者self.model_input_names中包含*token_type_ids*时）。 什么是令牌类型 ID？
• attention_mask — 指定哪些令牌应该被模型关注的索引列表（当return_attention_mask=True或者self.model_input_names中包含*attention_mask*时）。 什么是注意力掩码？
• labels — 要提供给模型的标签列表（当指定word_labels时）。
• overflowing_tokens — 溢出的令牌序列列表（当指定max_length并且return_overflowing_tokens=True时）。
• num_truncated_tokens — 截断的令牌数量（当指定max_length并且return_overflowing_tokens=True时）。
• special_tokens_mask — 由 0 和 1 组成的列表，其中 1 指定添加的特殊令牌，0 指定常规序列令牌（当add_special_tokens=True并且return_special_tokens_mask=True时）。
• length — 输入的长度（当return_length=True时）。

对一个或多个序列或一个或多个序列对进行分词和准备模型，其中包含单词级别的归一化边界框和可选标签。

LayoutLMv2Processor

class transformers.LayoutLMv2Processor

<来源>

( image_processor = None tokenizer = None **kwargs )

参数

• image_processor（LayoutLMv2ImageProcessor，可选）— LayoutLMv2ImageProcessor 的实例。图像处理器是必需的输入。
• tokenizer（LayoutLMv2Tokenizer或LayoutLMv2TokenizerFast，可选）— LayoutLMv2Tokenizer 或 LayoutLMv2TokenizerFast 的实例。标记器是必需的输入。

构建一个 LayoutLMv2 处理器，将 LayoutLMv2 图像处理器和 LayoutLMv2 标记器合并为一个单一处理器。

LayoutLMv2Processor 提供了准备模型数据所需的所有功能。

它首先使用 LayoutLMv2ImageProcessor 将文档图像调整为固定大小，并可选择应用 OCR 以获取单词和归一化边界框。然后将它们提供给 LayoutLMv2Tokenizer 或 LayoutLMv2TokenizerFast，将单词和边界框转换为标记级别的input_ids、attention_mask、token_type_ids、bbox。可选地，可以提供整数word_labels，这些标签将转换为用于标记分类任务（如 FUNSD、CORD）的标记级别labels。

__call__

<来源>

( images text: Union = None text_pair: Union = None boxes: Union = None word_labels: Union = None add_special_tokens: bool = True padding: Union = False truncation: Union = False max_length: Optional = None stride: int = 0 pad_to_multiple_of: Optional = None return_token_type_ids: Optional = None return_attention_mask: Optional = 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: Union = None **kwargs )

此方法首先将images参数转发到call()。如果 LayoutLMv2ImageProcessor 初始化时apply_ocr设置为True，它将获取的单词和边界框连同其他参数传递给call()并返回输出，以及调整大小后的images。如果 LayoutLMv2ImageProcessor 初始化时apply_ocr设置为False，它将用户指定的单词（text/text_pair）和boxes连同其他参数传递给 call()并返回输出，以及调整大小后的images。

请参考上述两个方法的文档字符串以获取更多信息。

LayoutLMv2Model

class transformers.LayoutLMv2Model

<来源>

( config )

参数

• config（LayoutLMv2Config）— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只加载配置。查看 from_pretrained()方法以加载模型权重。

裸的 LayoutLMv2 模型变换器，输出没有特定头部的原始隐藏状态。此模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有事项。

forward

< source >

( input_ids: Optional = None bbox: Optional = None image: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutput or tuple(torch.FloatTensor)

参数

• input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是输入 ID？
• bbox (torch.LongTensor of shape ((batch_size, sequence_length), 4), optional) — 每个输入序列标记的边界框。选择范围在[0, config.max_2d_position_embeddings-1]内。每个边界框应该是(x0, y0, x1, y1)格式的归一化版本，其中(x0, y0)对应于边界框左上角的位置，(x1, y1)表示右下角的位置。
• image (torch.FloatTensor of shape (batch_size, num_channels, height, width) 或 detectron.structures.ImageList，其tensors的形状为(batch_size, num_channels, height, width)) — 文档图像的批处理。
• attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 用于避免在填充标记索引上执行注意力的掩码。选择在[0, 1]范围内的掩码值：
  • 1 对于未被masked的标记，
  • 对于被masked的标记为 0。

  什么是注意力掩码？

• token_type_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 指示输入的第一部分和第二部分的段标记索引。索引在[0, 1]中选择：
  • 0 对应于句子 A标记，
  • 1 对应于句子 B标记。

  什么是标记类型 ID？

• position_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 每个输入序列标记在位置嵌入中的位置索引。选择范围在[0, config.max_position_embeddings - 1]内。 什么是位置 ID？
• head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于使自注意力模块中的特定头部失效的掩码。选择在[0, 1]范围内的掩码值：
  • 1 表示头部未被masked，
  • 0 表示头部被masked。
• inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，您可以直接传递嵌入表示而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，则这很有用，而不是使用模型的内部嵌入查找矩阵。
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量中的attentions。
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量中的hidden_states。
• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

返回

transformers.modeling_outputs.BaseModelOutput 或 tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.BaseModelOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含各种元素，取决于配置（LayoutLMv2Config）和输入。

• last_hidden_state (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列。
• hidden_states (tuple(torch.FloatTensor), 可选的, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入的输出+每层的输出）。 模型在每一层输出的隐藏状态以及可选的初始嵌入输出。
• attentions (tuple(torch.FloatTensor), 可选的, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。 注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

LayoutLMv2Model 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的方法需要在这个函数内定义，但应该在之后调用Module实例，而不是这个，因为前者会处理运行前后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoProcessor, LayoutLMv2Model, set_seed
>>> from PIL import Image
>>> import torch
>>> from datasets import load_dataset

>>> set_seed(88)

>>> processor = AutoProcessor.from_pretrained("microsoft/layoutlmv2-base-uncased")
>>> model = LayoutLMv2Model.from_pretrained("microsoft/layoutlmv2-base-uncased")

>>> dataset = load_dataset("hf-internal-testing/fixtures_docvqa")
>>> image_path = dataset["test"][0]["file"]
>>> image = Image.open(image_path).convert("RGB")

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

>>> outputs = model(**encoding)
>>> last_hidden_states = outputs.last_hidden_state

>>> last_hidden_states.shape
torch.Size([1, 342, 768])

LayoutLMv2ForSequenceClassification

class transformers.LayoutLMv2ForSequenceClassification

<来源>

( config )

参数

• config (LayoutLMv2Config) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，只加载配置。查看 from_pretrained()方法以加载模型权重。

LayoutLMv2 模型，顶部带有一个序列分类头（在[CLS]标记的最终隐藏状态、平均池化的初始视觉嵌入和平均池化的最终视觉嵌入的串联之上的线性层，例如用于文档图像分类任务，如RVL-CDIP数据集。

这个模型是一个 PyTorch torch.nn.Module子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有内容。

forward

<来源>

( input_ids: Optional = None bbox: Optional = None image: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.SequenceClassifierOutput or tuple(torch.FloatTensor)

参数

• input_ids (torch.LongTensor，形状为batch_size, sequence_length) — 词汇表中输入序列标记的索引。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是输入 ID？
• bbox (torch.LongTensor of shape (batch_size, sequence_length, 4), optional) — 每个输入序列标记的边界框。选择范围为 [0, config.max_2d_position_embeddings-1]。每个边界框应该是 (x0, y0, x1, y1) 格式的归一化版本，其中 (x0, y0) 对应于边界框左上角的位置，而 (x1, y1) 表示右下角的位置。
• image (torch.FloatTensor of shape (batch_size, num_channels, height, width) 或 detectron.structures.ImageList，其 tensors 的形状为 (batch_size, num_channels, height, width)) — 文档图像的批处理。
• attention_mask (torch.FloatTensor of shape batch_size, sequence_length, optional) — 避免在填充标记索引上执行注意力的掩码。掩码值选择在 [0, 1] 范围内：
  • 1 表示未被遮蔽的标记，
  • 0 表示被遮蔽的标记。

  什么是注意力掩码？

• token_type_ids (torch.LongTensor of shape batch_size, sequence_length, optional) — 段标记索引，指示输入的第一部分和第二部分。索引选择在 [0, 1] 范围内：
  • 0 对应于 句子 A 标记，
  • 1 对应于 句子 B 标记。

  什么是标记类型 ID？

• position_ids (torch.LongTensor of shape batch_size, sequence_length, optional) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为 [0, config.max_position_embeddings - 1]。 什么是位置 ID？
• head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于使自注意力模块中的特定头部失效的掩码。掩码值选择在 [0, 1] 范围内：
  • 1 表示头部未被遮蔽，
  • 0 表示头部被遮蔽。
• inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您想要更多控制如何将 input_ids 索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的 attentions。
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的 hidden_states。
• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。
• labels (torch.LongTensor of shape (batch_size,), optional) — 用于计算序列分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1] 范围内。如果 config.num_labels == 1，则计算回归损失（均方损失），如果 config.num_labels > 1，则计算分类损失（交叉熵）。

返回

transformers.modeling_outputs.SequenceClassifierOutput 或 tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.SequenceClassifierOutput 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时）包含根据配置（LayoutLMv2Config）和输入而异的各种元素。

• loss (torch.FloatTensor of shape (1,), optional, 当提供 labels 时返回) — 分类（或如果 config.num_labels==1 则为回归）损失。
• logits (torch.FloatTensor of shape (batch_size, config.num_labels)) — 分类（如果config.num_labels==1则为回归）得分（SoftMax 之前）。
• hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入的输出+每层的输出）。 模型每一层输出的隐藏状态以及可选的初始嵌入输出。
• attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。 在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

LayoutLMv2ForSequenceClassification 的前向方法，覆盖__call__特殊方法。

虽然前向传递的方法需要在此函数内定义，但应该在之后调用Module实例，而不是在此处调用，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoProcessor, LayoutLMv2ForSequenceClassification, set_seed
>>> from PIL import Image
>>> import torch
>>> from datasets import load_dataset

>>> set_seed(88)

>>> dataset = load_dataset("rvl_cdip", split="train", streaming=True)
>>> data = next(iter(dataset))
>>> image = data["image"].convert("RGB")

>>> processor = AutoProcessor.from_pretrained("microsoft/layoutlmv2-base-uncased")
>>> model = LayoutLMv2ForSequenceClassification.from_pretrained(
...     "microsoft/layoutlmv2-base-uncased", num_labels=dataset.info.features["label"].num_classes
... )

>>> encoding = processor(image, return_tensors="pt")
>>> sequence_label = torch.tensor([data["label"]])

>>> outputs = model(**encoding, labels=sequence_label)

>>> loss, logits = outputs.loss, outputs.logits
>>> predicted_idx = logits.argmax(dim=-1).item()
>>> predicted_answer = dataset.info.features["label"].names[4]
>>> predicted_idx, predicted_answer
(4, 'advertisement')

LayoutLMv2ForTokenClassification

class transformers.LayoutLMv2ForTokenClassification

<来源>

( config )

参数

• config（LayoutLMv2Config） — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，只加载配置。查看 from_pretrained()方法以加载模型权重。

在 LayoutLMv2 模型的顶部具有标记分类头部（隐藏状态的文本部分上的线性层）的模型，例如用于序列标记（信息提取）任务的FUNSD、SROIE、CORD和Kleister-NDA。

该模型是 PyTorch 的torch.nn.Module子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

<来源>

( input_ids: Optional = None bbox: Optional = None image: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.TokenClassifierOutput or tuple(torch.FloatTensor)

参数

• input_ids (torch.LongTensor of shape batch_size, sequence_length) — 词汇表中输入序列标记的索引。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是输入 ID？
• bbox (torch.LongTensor of shape (batch_size, sequence_length, 4), optional) — 每个输入序列标记的边界框。选择范围为[0, config.max_2d_position_embeddings-1]。每个边界框应该是一个规范化版本，格式为(x0, y0, x1, y1)，其中(x0, y0)对应于边界框左上角的位置，(x1, y1)表示右下角的位置。
• image（torch.FloatTensor，形状为(batch_size, num_channels, height, width)或detectron.structures.ImageList，其tensors形状为(batch_size, num_channels, height, width)）— 批量文档图像。
• attention_mask（torch.FloatTensor，形状为batch_size, sequence_length，可选）— 用于避免在填充标记索引上执行注意力的掩码。掩码值选在[0, 1]之间：
  • 对于未被masked的标记为 1，
  • 对于被masked的标记为 0。

  什么是注意力掩码？

• token_type_ids（torch.LongTensor，形状为batch_size, sequence_length，可选）— 段标记索引，用于指示输入的第一部分和第二部分。索引选在[0, 1]之间：
  • 0 对应于句子 A的标记。
  • 1 对应于句子 B的标记。

  什么是标记类型 ID？

• position_ids（torch.LongTensor，形状为batch_size, sequence_length，可选）— 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。 什么是位置 ID？
• head_mask（torch.FloatTensor，形状为(num_heads,)或(num_layers, num_heads)，可选）— 用于使自注意力模块的选定头部失效的掩码。掩码值选在[0, 1]之间：
  • 1 表示头部未被masked。
  • 0 表示头部被masked。
• 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 而不是普通元组。
• labels（torch.LongTensor，形状为(batch_size, sequence_length)，可选）— 用于计算标记分类损失的标签。索引应在[0, ..., config.num_labels - 1]之间。

返回

transformers.modeling_outputs.TokenClassifierOutput 或tuple(torch.FloatTensor)。

一个 transformers.modeling_outputs.TokenClassifierOutput 或一个torch.FloatTensor元组（如果传递了return_dict=False或当config.return_dict=False时），包括根据配置（LayoutLMv2Config）和输入的不同元素。

• loss（torch.FloatTensor，形状为(1,)，可选，当提供labels时返回）— 分类损失。
• logits（torch.FloatTensor，形状为(batch_size, sequence_length, config.num_labels)）— 分类分数（SoftMax 之前）。
• hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回）— 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入的输出之一，+ 每层的输出）。 模型在每一层输出的隐藏状态以及可选的初始嵌入输出。
• attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。 在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

LayoutLMv2ForTokenClassification 的前向方法，覆盖了__call__特殊方法。

尽管前向传递的步骤需要在此函数内定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoProcessor, LayoutLMv2ForTokenClassification, set_seed
>>> from PIL import Image
>>> from datasets import load_dataset

>>> set_seed(88)

>>> datasets = load_dataset("nielsr/funsd", split="test")
>>> labels = datasets.features["ner_tags"].feature.names
>>> id2label = {v: k for v, k in enumerate(labels)}

>>> processor = AutoProcessor.from_pretrained("microsoft/layoutlmv2-base-uncased", revision="no_ocr")
>>> model = LayoutLMv2ForTokenClassification.from_pretrained(
...     "microsoft/layoutlmv2-base-uncased", num_labels=len(labels)
... )

>>> data = datasets[0]
>>> image = Image.open(data["image_path"]).convert("RGB")
>>> words = data["words"]
>>> boxes = data["bboxes"]  # make sure to normalize your bounding boxes
>>> word_labels = data["ner_tags"]
>>> encoding = processor(
...     image,
...     words,
...     boxes=boxes,
...     word_labels=word_labels,
...     padding="max_length",
...     truncation=True,
...     return_tensors="pt",
... )

>>> outputs = model(**encoding)
>>> logits, loss = outputs.logits, outputs.loss

>>> predicted_token_class_ids = logits.argmax(-1)
>>> predicted_tokens_classes = [id2label[t.item()] for t in predicted_token_class_ids[0]]
>>> predicted_tokens_classes[:5]
['B-ANSWER', 'B-HEADER', 'B-HEADER', 'B-HEADER', 'B-HEADER']

LayoutLMv2ForQuestionAnswering

class transformers.LayoutLMv2ForQuestionAnswering

<来源>

( config has_visual_segment_embedding = True )

参数

• config（LayoutLMv2Config） — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，只会加载配置。查看 from_pretrained()方法以加载模型权重。

LayoutLMv2 模型，在其顶部具有用于提取问答任务的跨度分类头，例如DocVQA（在隐藏状态输出的文本部分顶部的线性层，用于计算跨度起始对数和跨度结束对数）。

这个模型是 PyTorch 的torch.nn.Module子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有内容。

forward

<来源>

( input_ids: Optional = None bbox: Optional = None image: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None start_positions: Optional = None end_positions: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.QuestionAnsweringModelOutput or tuple(torch.FloatTensor)

参数

• input_ids（形状为batch_size, sequence_length的torch.LongTensor） — 词汇表中输入序列标记的索引。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是输入 ID？
• bbox（形状为(batch_size, sequence_length, 4)的torch.LongTensor，可选） — 每个输入序列标记的边界框。在范围[0, config.max_2d_position_embeddings-1]中选择。每个边界框应该是(x0, y0, x1, y1)格式的归一化版本，其中(x0, y0)对应于边界框左上角的位置，而(x1, y1)表示边界框右下角的位置。
• image（形状为(batch_size, num_channels, height, width)的torch.FloatTensor或detectron.structures.ImageList，其tensors的形状为(batch_size, num_channels, height, width)） — 文档图像的批处理。
• attention_mask（形状为batch_size, sequence_length的torch.FloatTensor，可选） — 避免在填充标记索引上执行注意力的蒙版。蒙版值选择在[0, 1]中：
  • 对于未被掩码的标记为 1，
  • 对于被掩码的标记为 0。

  什么是注意力蒙版？

• token_type_ids（形状为batch_size, sequence_length的torch.LongTensor，可选） — 指示输入的第一部分和第二部分的段标记索引。索引选择在[0, 1]中：
  • 0 对应于句子 A的标记，
  • 1 对应于 句子 B 标记。

  什么是标记类型 ID？

• position_ids (torch.LongTensor，形状为 batch_size, sequence_length，可选) — 每个输入序列标记在位置嵌入中的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。 什么是位置 ID？
• head_mask (torch.FloatTensor，形状为 (num_heads,) 或 (num_layers, num_heads)，可选) — 用于使自注意力模块的选定头部无效的掩码。掩码值在 [0, 1] 中选择：
  • 1 表示头部未被masked，
  • 0 表示头部被masked。
• 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 而不是一个普通元组。
• start_positions (torch.LongTensor，形状为 (batch_size,)，可选) — 用于计算标记跨度起始位置的位置（索引）的标签，以计算标记分类损失。位置被夹紧到序列的长度 (sequence_length)。超出序列范围的位置不会被考虑在内以计算损失。
• end_positions (torch.LongTensor，形状为 (batch_size,)，可选) — 用于计算标记跨度结束位置的位置（索引）的标签，以计算标记分类损失。位置被夹紧到序列的长度 (sequence_length)。超出序列范围的位置不会被考虑在内以计算损失。

返回

transformers.modeling_outputs.QuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.QuestionAnsweringModelOutput 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时）包含根据配置（LayoutLMv2Config）和输入的各种元素。

• 损失 (torch.FloatTensor，形状为 (1,)，可选，当提供labels时返回) — 总跨度抽取损失是起始位置和结束位置的交叉熵之和。
• start_logits (torch.FloatTensor，形状为 (batch_size, sequence_length)) — 跨度起始分数（SoftMax 之前）。
• end_logits (torch.FloatTensor，形状为 (batch_size, sequence_length)) — 跨度结束分数（SoftMax 之前）。
• hidden_states (tuple(torch.FloatTensor)，可选，当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回） — 形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor 元组（如果模型具有嵌入层，则为嵌入的输出 + 每层的输出）。 模型在每一层输出的隐藏状态以及可选的初始嵌入输出。
• attentions (tuple(torch.FloatTensor), 可选，当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 torch.FloatTensor 元组（每层一个）。 注意力权重在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

LayoutLMv2ForQuestionAnswering 的前向方法，覆盖了 __call__ 特殊方法。

虽然前向传递的步骤需要在这个函数内定义，但应该在之后调用 Module 实例而不是这个函数，因为前者会处理运行前后的处理步骤，而后者会默默地忽略它们。

示例：

在下面的示例中，我们给 LayoutLMv2 模型一个图像（包含文本）并向其提问。它会给出一个预测，即它认为答案在从图像中解析的文本中的位置。

>>> from transformers import AutoProcessor, LayoutLMv2ForQuestionAnswering, set_seed
>>> import torch
>>> from PIL import Image
>>> from datasets import load_dataset

>>> set_seed(88)
>>> processor = AutoProcessor.from_pretrained("microsoft/layoutlmv2-base-uncased")
>>> model = LayoutLMv2ForQuestionAnswering.from_pretrained("microsoft/layoutlmv2-base-uncased")

>>> dataset = load_dataset("hf-internal-testing/fixtures_docvqa")
>>> image_path = dataset["test"][0]["file"]
>>> image = Image.open(image_path).convert("RGB")
>>> question = "When is coffee break?"
>>> encoding = processor(image, question, return_tensors="pt")

>>> outputs = model(**encoding)
>>> predicted_start_idx = outputs.start_logits.argmax(-1).item()
>>> predicted_end_idx = outputs.end_logits.argmax(-1).item()
>>> predicted_start_idx, predicted_end_idx
(154, 287)

>>> predicted_answer_tokens = encoding.input_ids.squeeze()[predicted_start_idx : predicted_end_idx + 1]
>>> predicted_answer = processor.tokenizer.decode(predicted_answer_tokens)
>>> predicted_answer  # results are not very good without further fine-tuning
'council mem - bers conducted by trrf treasurer philip g. kuehn to get answers which the public ...

>>> target_start_index = torch.tensor([7])
>>> target_end_index = torch.tensor([14])
>>> outputs = model(**encoding, start_positions=target_start_index, end_positions=target_end_index)
>>> predicted_answer_span_start = outputs.start_logits.argmax(-1).item()
>>> predicted_answer_span_end = outputs.end_logits.argmax(-1).item()
>>> predicted_answer_span_start, predicted_answer_span_end
(154, 287)