LayoutLMV2
概述
LayoutLMV2 模型由杨旭、徐毅恒、吕腾超、崔磊、魏福如、郭新旺、陆一娟、迪内·弗洛伦西奥、张超、车万祥、张敏、周丽东在 LayoutLMv2: 用于富视觉文档理解的多模态预训练 一文中提出。LayoutLMV2 改进了 LayoutLM，在多个文档图像理解基准测试中获得了最先进的结果
- 从扫描文档中提取信息：FUNSD 数据集（包含 199 个带注释的表单的集合，包含 30,000 多个单词）、CORD 数据集（包含 800 张用于训练的收据、100 张用于验证的收据和 100 张用于测试的收据）、SROIE 数据集（包含 626 张用于训练的收据和 347 张用于测试的收据）和 Kleister-NDA 数据集（来自 EDGAR 数据库的保密协议集合，包括 254 份用于训练的文档、83 份用于验证的文档和 203 份用于测试的文档）。
- 文档图像分类：RVL-CDIP 数据集（包含属于 16 个类别之一的 400,000 张图像的集合）。
- 文档视觉问答：DocVQA 数据集（在 12,000 多张文档图像上定义的 50,000 个问题的集合）。
论文的摘要是这样的
事实证明，文本和布局的预训练在各种富视觉文档理解任务中都很有效，这得益于其有效的模型架构和大规模未标记扫描/数字出生文档的优势。在本文中，我们通过在多模态框架中对文本、布局和图像进行预训练来介绍 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 进行开发，请注意，传递 doctest 还需要安装这些软件包。）
使用技巧
- LayoutLMv1 和 LayoutLMv2 之间的主要区别是，后者在预训练期间包含视觉嵌入（而 LayoutLMv1 仅在微调期间添加视觉嵌入）。
- LayoutLMv2 在自注意力层中向注意力分数添加了相对一维注意力偏差以及空间二维注意力偏差。详细信息可在 论文 的第 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输入是输入文本标记的边界框（即二维位置）。这与 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 图像库 (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 数据集上使用 HuggingFace 训练器微调 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 引擎，并自己提供单词和标准化边界框。这需要初始化 LayoutLMv2ImageProcessor 并将 apply_ocr 设置为 False。
处理器总共支持 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
类 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时传递的inputs_ids可以表示的不同标记的数量。 - hidden_size (
int, 可选, 默认为 768) — 编码器层和池化器层的维度。 - num_hidden_layers (
int, 可选, 默认为 12) — Transformer 编码器中的隐藏层数。 - num_attention_heads (
int，可选，默认为 12) — Transformer 编码器中每个注意力层的注意力头数。 - intermediate_size (
int，可选，默认为 3072) — Transformer 编码器中“中间”（即，前馈）层的维度。 - hidden_act (
str或function，可选，默认为"gelu") — 编码器和池化器中使用的非线性激活函数（函数或字符串）。如果是字符串，则支持"gelu"、"relu"、"selu"和"gelu_new"。 - hidden_dropout_prob (
float，可选，默认为 0.1) — 嵌入、编码器和池化器中所有全连接层的 dropout 概率。 - attention_probs_dropout_prob (
float，可选，默认为 0.1) — 注意力概率的 dropout 比率。 - max_position_embeddings (
int，可选，默认为 512) — 此模型可能使用的最大序列长度。通常将其设置为较大的数字以防万一（例如，512 或 1024 或 2048）。 - type_vocab_size (
int，可选，默认为 2) — 调用 LayoutLMv2Model 或TFLayoutLMv2Model时传递的token_type_ids的词汇量大小。 - initializer_range (
float，可选，默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准偏差。 - layer_norm_eps (
float，可选，默认为 1e-12) — 层归一化层使用的 epsilon。 - max_2d_position_embeddings (
int，可选，默认为 1024) — 二维位置嵌入可能使用的最大值。通常将其设置为较大的值以防万一（例如，1024）。 - max_rel_pos (
int，可选，默认为 128) — 自注意力机制中使用的最大相对位置数。 - rel_pos_bins (
int，可选，默认为 32) — 自注意力机制中使用的相对位置箱数。 - fast_qkv (
bool，可选，默认为True) — 是否在自注意力层中对查询、键和值使用单个矩阵。 - max_rel_2d_pos (
int，可选，默认为 256) — 自注意力机制中使用的最大二维相对位置数。 - rel_2d_pos_bins (
int，可选，默认为 64) — 自注意力机制中使用的二维相对位置箱数。 - image_feature_pool_shape (
List[int]，可选，默认为 [7, 7, 256]) — 平均池化特征图的形状。 - coordinate_size (
int，*可选*，默认为 128) — 坐标嵌入的维度。 - shape_size (
int，*可选*，默认为 128) — 宽度和高度嵌入的维度。 - has_relative_attention_bias (
bool，*可选*，默认为True) — 是否在自注意力机制中使用相对注意力偏差。 - has_spatial_attention_bias (
bool，*可选*，默认为True) — 是否在自注意力机制中使用空间注意力偏差。 - has_visual_segment_embedding (
bool，*可选*，默认为False) — 是否添加视觉分段嵌入。 - detectron2_config_args (
dict，*可选*) — 包含 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.configLayoutLMv2FeatureExtractor
对图像或图像批次进行预处理。
LayoutLMv2ImageProcessor
class transformers.LayoutLMv2ImageProcessor
< source >( 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) — 是否将图像的（高度、宽度）维度调整为(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, 可选) — 由 Tesseract OCR 引擎使用的语言，由其 ISO 代码指定。默认情况下，使用英语。可以通过preprocess中的ocr_lang覆盖。 - tesseract_config (
str, 可选, 默认为"") — 调用 Tesseract 时转发到config参数的任何其他自定义配置标志。例如：'--psm 6'。可以通过preprocess中的tesseract_config覆盖。
构造一个 LayoutLMv2 图像处理器。
预处理
< 源代码 >( 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 )
参数
- 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) — Tesseract OCR 引擎使用的语言（由其 ISO 代码指定）。默认情况下使用英语。 - 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
类 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 运行端到端分词：标点符号拆分和词块。它还将词级边界框转换为词符级边界框。
__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 padding_side: 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 ) → 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 硬件上使用 Tensor Core 特别有用。 - return_tensors (
str或 TensorType, *可选*) — 如果设置，将返回张量而不是 Python 整数列表。 可接受的值为：'tf'：返回 TensorFlowtf.constant对象。'pt'：返回 PyTorchtorch.Tensor对象。'np'：返回 Numpynp.ndarray对象。
- return_token_type_ids (
bool, *可选*) — 是否返回标记类型 ID。 如果保留默认值，则将根据特定分词器的默认值（由return_outputs属性定义）返回标记类型 ID。 - return_attention_mask (
bool, *可选*) — 是否返回注意力掩码。 如果保留默认值，则将根据特定分词器的默认值（由return_outputs属性定义）返回注意力掩码。 - return_overflowing_tokens (
bool, *可选*, 默认值为False) — 是否返回溢出的标记序列。 如果使用truncation_strategy = longest_first或True提供了一对输入 ID 序列（或一批对），则会引发错误，而不是返回溢出的标记。 - 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，具有以下字段
-
input_ids — 要馈送到模型的标记 ID 列表。
-
bbox — 要馈送到模型的边界框列表。
-
token_type_ids — 要馈送到模型的标记类型 ID 列表（当
return_token_type_ids=True或 “token_type_ids” 在self.model_input_names中时）。 -
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时）。
对一个或多个序列或一个或多对序列进行标记化并准备模型的主要方法，这些序列具有词级标准化边界框和可选标签。
LayoutLMv2TokenizerFast
类 transformers.LayoutLMv2TokenizerFast
< source >( 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, 可选, 默认值True) — 在进行标记化时是否将输入转换为小写。 - unk_token (
str, 可选, 默认值"[UNK]") — 未知标记。不在词汇表中的标记无法转换为 ID，而是设置为该标记。 - sep_token (
str, 可选, 默认值"[SEP]") — 分隔标记，用于从多个序列构建序列时使用，例如，用于序列分类的两个序列，或用于问答的文本和问题。它也用作使用特殊标记构建的序列的最后一个标记。 - pad_token (
str，可选，默认为"[PAD]") — 用于填充的标记，例如在对不同长度的序列进行批处理时。 - cls_token (
str，可选，默认为"[CLS]") — 在进行序列分类（对整个序列进行分类，而不是对每个标记进行分类）时使用的分类标记。构建带有特殊标记的序列时，它是序列的第一个标记。 - mask_token (
str，可选，默认为"[MASK]") — 用于屏蔽值的标记。这是在使用掩码语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。 - cls_token_box (
List[int]，可选，默认为[0, 0, 0, 0]) — 用于特殊 [CLS] 标记的边界框。 - sep_token_box (
List[int]，可选，默认为[1000, 1000, 1000, 1000]) — 用于特殊 [SEP] 标记的边界框。 - pad_token_box (
List[int]，可选，默认为[0, 0, 0, 0]) — 用于特殊 [PAD] 标记的边界框。 - pad_token_label (
int，可选，默认为 -100) — 用于填充标记的标签。默认为 -100，它是 PyTorch 的 CrossEntropyLoss 的ignore_index。 - only_label_first_subword (
bool，可选，默认为True) — 如果提供了单词标签，是否仅标记第一个子词。 - tokenize_chinese_chars (
bool，可选，默认为True) — 是否对汉字进行分词。 对于日语，这可能应该停用（请参阅此问题）。 - strip_accents (
bool，可选) — 是否删除所有变音符号。 如果未指定此选项，则将由lowercase的值确定（如在原始 LayoutLMv2 中）。
构建一个“快速”LayoutLMv2 分词器（由 HuggingFace 的 *tokenizers* 库支持）。 基于 WordPiece。
此分词器继承自 PreTrainedTokenizerFast，其中包含大多数主要方法。 用户应参考此超类以获取有关这些方法的更多信息。
__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 padding_side: 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 ) → 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 硬件上使用 Tensor Cores 尤其有用。 - return_tensors (
str或 TensorType, 可选) — 如果设置，则返回张量而不是 Python 整数列表。可接受的值为：'tf'：返回 TensorFlowtf.constant对象。'pt'：返回 PyTorchtorch.Tensor对象。'np'：返回 Numpynp.ndarray对象。
- return_token_type_ids (
bool, 可选) — 是否返回标记类型 ID。如果保留默认值，则将根据特定标记器的默认值（由return_outputs属性定义）返回标记类型 ID。 - return_attention_mask (
bool, 可选) — 是否返回注意力掩码。如果保留默认值，则将根据特定标记器的默认值（由return_outputs属性定义）返回注意力掩码。 - return_overflowing_tokens (
bool, 可选, 默认值False) — 是否返回溢出标记序列。如果使用truncation_strategy = longest_first或True提供了一对输入 ID 序列（或一批对），则会引发错误而不是返回溢出标记。 - 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，具有以下字段
-
input_ids — 要馈送到模型的标记 ID 列表。
-
bbox — 要馈送到模型的边界框列表。
-
token_type_ids — 要馈送到模型的标记类型 ID 列表（当
return_token_type_ids=True或 “token_type_ids” 在self.model_input_names中时）。 -
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时）。
对一个或多个序列或一个或多对序列进行标记化并准备模型的主要方法，这些序列具有词级标准化边界框和可选标签。
LayoutLMv2Processor
class transformers.LayoutLMv2Processor
< source >( 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__
< source >( 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__()](/docs/transformers/v4.45.2/en/model_doc/layoutlmv2#transformers.LayoutLMv2Tokenizer.__call__) 并返回输出以及调整大小后的 `images`。
有关详细信息，请参阅上述两种方法的文档字符串。
LayoutLMv2Model
class transformers.LayoutLMv2Model
< source >( config )
参数
- config (LayoutLMv2Config) — 包含模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型关联的权重，只会加载配置。 查看 from_pretrained() 方法来加载模型权重。
裸 LayoutLMv2 模型转换器输出原始隐藏状态，顶部没有任何特定头部。此模型是 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 output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → transformers.modeling_outputs.BaseModelOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor类型，形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- bbox (
torch.LongTensor类型，形状为((batch_size, sequence_length), 4)，可选) — 每个输入序列标记的边界框。在[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]中选择的掩码值：- 1 表示**未掩码**的标记，
- 0 表示**已掩码**的标记。
- token_type_ids (
torch.LongTensor， 形状为(batch_size, sequence_length)， 可选) — 分段标记索引，用于指示输入的第一部分和第二部分。索引在[0, 1]中选择：- 0 对应于*句子 A* 标记，
- 1 对应于*句子 B* 标记。
- position_ids (
torch.LongTensor， 形状为(batch_size, sequence_length)， 可选) — 位置嵌入中每个输入序列标记的位置索引。在[0, config.max_position_embeddings - 1]范围内选择。 - head_mask (
torch.FloatTensor， 形状为(num_heads,)或(num_layers, num_heads)， 可选) — 用于将自注意力模块的选定头部置零的掩码。掩码值在[0, 1]中选择：- 1 表示头部*未被掩码*，
- 0 表示头部*已被掩码*。
- inputs_embeds (
torch.FloatTensor， 形状为(batch_size, sequence_length, hidden_size)， 可选) — 或者，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您希望更多地控制如何将 input_ids 索引转换为关联向量，而不是模型的内部嵌入查找矩阵，则此选项非常有用。 - output_attentions (
bool， 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。 - output_hidden_states (
bool， 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。 - return_dict (
bool， 可选) — 是否返回 ModelOutput 而不是普通元组。
返回
transformers.modeling_outputs.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时返回) —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 后的注意力权重，用于计算自注意力头中的加权平均值。
LayoutLMv2Model 的前向方法，重写了 __call__ 特殊方法。
尽管前向传递的配方需要在此函数中定义，但之后应该调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者则默默地忽略它们。
例子
>>> from transformers import AutoProcessor, LayoutLMv2Model, set_seed
>>> from PIL import Image
>>> import torch
>>> from datasets import load_dataset
>>> set_seed(0)
>>> processor = AutoProcessor.from_pretrained("microsoft/layoutlmv2-base-uncased")
>>> model = LayoutLMv2Model.from_pretrained("microsoft/layoutlmv2-base-uncased")
>>> dataset = load_dataset("hf-internal-testing/fixtures_docvqa", trust_remote_code=True)
>>> 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
类 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 ) → transformers.modeling_outputs.SequenceClassifierOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor，形状为batch_size, sequence_length) — 词汇表中输入序列标记的索引。索引可以使用 AutoTokenizer 获取。详情请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- bbox (
torch.LongTensor，形状为(batch_size, sequence_length, 4)，可选) — 每个输入序列标记的边界框。在[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]中选择：- 1 表示 未掩码 的标记，
- 0 表示 已掩码 的标记。
- token_type_ids (
torch.LongTensor，形状为batch_size, sequence_length，可选) — 片段标记索引，用于指示输入的第一部分和第二部分。索引在[0, 1]中选择：- 0 对应于 句子 A 标记，
- 1 对应于 句子 B 标记。
- position_ids (
torch.LongTensor， 形状为batch_size, sequence_length， 可选) — 位置嵌入中每个输入序列标记的位置索引。在[0, config.max_position_embeddings - 1]范围内选择。 - head_mask (
torch.FloatTensor， 形状为(num_heads,)或(num_layers, num_heads)， 可选) — 用于将自注意力模块的选定头部置零的掩码。掩码值在[0, 1]中选择：- 1 表示头部**未被掩码**，
- 0 表示头部**已被掩码**。
- inputs_embeds (
torch.FloatTensor， 形状为(batch_size, sequence_length, hidden_size)， 可选) — 或者，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想更好地控制如何将 *input_ids* 索引转换为关联向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。 - output_attentions (
bool， 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。 - output_hidden_states (
bool， 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。 - return_dict (
bool， 可选) — 是否返回 ModelOutput 而不是普通的元组。 - 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），包含根据配置（LayoutLMv2Config）和输入的不同元素。
-
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 后的注意力权重，用于计算自注意力头中的加权平均值。
LayoutLMv2ForSequenceClassification 的 forward 方法，重载了 __call__ 特殊方法。
尽管前向传递的配方需要在此函数中定义，但之后应该调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者则默默地忽略它们。
示例
>>> from transformers import AutoProcessor, LayoutLMv2ForSequenceClassification, set_seed
>>> from PIL import Image
>>> import torch
>>> from datasets import load_dataset
>>> set_seed(0)
>>> dataset = load_dataset("aharley/rvl_cdip", split="train", streaming=True, trust_remote_code=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 # results are not good without further fine-tuning
(7, 'advertisement')LayoutLMv2ForTokenClassification
类 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 ) → transformers.modeling_outputs.TokenClassifierOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor类型，形状为batch_size, sequence_length) — 词汇表中输入序列标记的索引。索引可以使用 AutoTokenizer 获取。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- bbox (
torch.LongTensor类型，形状为(batch_size, sequence_length, 4)，可选) — 每个输入序列标记的边界框。在[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]中选择：- 未掩码标记为 1，
- 已掩码标记为 0。
- token_type_ids (
torch.LongTensor类型，形状为batch_size, sequence_length，可选) — 区段标记索引，用于指示输入的第一部分和第二部分。索引在[0, 1]中选择：- 0 对应于 *句子 A* 标记，
- 1 对应于 *句子 B* 标记。
- position_ids (
torch.LongTensor类型，形状为batch_size, sequence_length，可选) — 位置嵌入中每个输入序列标记的位置索引。在[0, config.max_position_embeddings - 1]范围内选择。 - **head_mask** (``torch.FloatTensor`` ， 形状为 ``(num_heads,)`` 或 ``(num_layers, num_heads)``， *可选*) — 用于将自注意力模块的选定头部置零的掩码。掩码值在 ``[0, 1]`` 中选择：
- 1 表示头部**未被掩盖**，
- 0 表示头部**已被掩盖**。
- **inputs_embeds** (``torch.FloatTensor`` ， 形状为 ``(batch_size, sequence_length, hidden_size)``， *可选*) — 可选择直接传递嵌入表示，而不是传递 ``input_ids``。 如果您想更好地控制如何将 *input_ids* 索引转换为关联向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。
- **output_attentions** (``bool`` ， *可选*) — 是否返回所有注意力层的注意力张量。 有关更多详细信息，请参阅返回张量下的 ``attentions``。
- **output_hidden_states** (``bool`` ， *可选*) — 是否返回所有层的隐藏状态。 有关更多详细信息，请参阅返回张量下的 ``hidden_states``。
- **return_dict** (``bool`` ， *可选*) — 是否返回 ModelOutput 而不是普通元组。
- **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时返回) —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 后的注意力权重，用于计算自注意力头中的加权平均值。
LayoutLMv2ForTokenClassification forward 方法，覆盖了 ``__call__`` 特殊方法。
尽管前向传递的配方需要在此函数中定义，但之后应该调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者则默默地忽略它们。
示例
>>> from transformers import AutoProcessor, LayoutLMv2ForTokenClassification, set_seed
>>> from PIL import Image
>>> from datasets import load_dataset
>>> set_seed(0)
>>> datasets = load_dataset("nielsr/funsd", split="test", trust_remote_code=True)
>>> 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] # results are not good without further fine-tuning
['I-HEADER', 'I-HEADER', 'I-QUESTION', 'I-HEADER', 'I-QUESTION']LayoutLMv2ForQuestionAnswering
class transformers.LayoutLMv2ForQuestionAnswering
< source >( config has_visual_segment_embedding = True )
参数
- config (LayoutLMv2Config) — 模型配置类，包含模型的所有参数。 使用配置文件初始化不会加载与模型关联的权重，只会加载配置。 查看 from_pretrained() 方法来加载模型权重。
LayoutLMv2 模型顶部有一个用于提取式问答任务的跨度分类头，例如 DocVQA（在隐藏状态输出的文本部分之上的线性层，用于计算“跨度开始 logits”和“跨度结束 logits”）。
此模型是 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 start_positions: Optional = None end_positions: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → transformers.modeling_outputs.QuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor， 形状为batch_size, sequence_length) — 词汇表中输入序列标记的索引。索引可以使用 AutoTokenizer 获取。 更多详情，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- bbox (
torch.LongTensor， 形状为(batch_size, sequence_length, 4)， 可选) — 每个输入序列标记的边界框。 在[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]中选择的掩码值：- 1 表示**未被掩码**的标记，
- 0 表示**已被掩码**的标记。
- token_type_ids (
torch.LongTensor， 形状为batch_size, sequence_length， 可选) — 段标记索引，用于指示输入的第一部分和第二部分。 索引在[0, 1]中选择：- 0 对应于 *句子 A* 标记，
- 1 对应于 *句子 B* 标记。
- position_ids (
torch.LongTensor， 形状为batch_size, sequence_length， 可选) — 位置嵌入中每个输入序列标记的位置索引。 在[0, config.max_position_embeddings - 1]范围内选择。 - head_mask (
torch.FloatTensor形状为(num_heads,)或(num_layers, num_heads)的张量, 可选) — 用于将自注意力模块的选定头部置零的掩码。掩码值在[0, 1]中选择:- 1 表示头部**未被掩盖**，
- 0 表示头部**已被掩盖**。
- inputs_embeds (
torch.FloatTensor形状为(batch_size, sequence_length, hidden_size)的张量, 可选) — 可选参数，您可以选择直接传递嵌入表示，而不是传递input_ids。 如果您想比模型的内部嵌入查找矩阵更能控制如何将 *input_ids* 索引转换为关联向量，这将非常有用。 - output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。 有关详细信息，请参阅返回张量下的attentions。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。 有关详细信息，请参阅返回张量下的hidden_states。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。 - 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) 和输入。
-
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时返回) —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 后的注意力权重，用于计算自注意力头中的加权平均值。
LayoutLMv2ForQuestionAnswering 前向方法重写了 __call__ 特殊方法。
尽管前向传递的配方需要在此函数中定义，但之后应该调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者则默默地忽略它们。
示例
在下面的示例中，我们为 LayoutLMv2 模型提供了一张图像（包含文本）并向其提出问题。它将给出其认为答案是什么的预测（答案在从图像解析的文本中的跨度）。
>>> from transformers import AutoProcessor, LayoutLMv2ForQuestionAnswering, set_seed
>>> import torch
>>> from PIL import Image
>>> from datasets import load_dataset
>>> set_seed(0)
>>> processor = AutoProcessor.from_pretrained("microsoft/layoutlmv2-base-uncased")
>>> model = LayoutLMv2ForQuestionAnswering.from_pretrained("microsoft/layoutlmv2-base-uncased")
>>> dataset = load_dataset("hf-internal-testing/fixtures_docvqa", trust_remote_code=True)
>>> 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
(30, 191)
>>> 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 good without further fine-tuning
'44 a. m. to 12 : 25 p. m. 12 : 25 to 12 : 58 p. m. 12 : 58 to 4 : 00 p. m. 2 : 00 to 5 : 00 p. m. coffee break coffee will be served for men and women in the lobby adjacent to exhibit area. please move into exhibit area. ( exhibits open ) trrf general session ( part | ) presiding : lee a. waller trrf vice president “ introductory remarks ” lee a. waller, trrf vice presi - dent individual interviews with trrf public board members and sci - entific advisory council mem - bers conducted by trrf treasurer philip g. kuehn to get answers which the public refrigerated warehousing industry is looking for. plus questions from'>>> 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
(30, 191)