Transformers 文档
LayoutLMV2
并获得增强的文档体验
开始使用
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 数据集（包含 199 份标注表格，超过 30,000 个单词），CORD 数据集（包含 800 份收据用于训练，100 份用于验证，100 份用于测试），SROIE 数据集（包含 626 份收据用于训练，347 份用于测试）以及 Kleister-NDA 数据集（包含来自 EDGAR 数据库的保密协议，其中 254 份文档用于训练，83 份文档用于验证，203 份文档用于测试）。
- 文档图像分类：RVL-CDIP 数据集（包含 400,000 张图像，属于 16 个类别之一）。
- 文档视觉问答：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 进行开发，请注意，通过文档测试也需要安装这些包。)
使用技巧
- 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 进行标记分类的笔记本：https://colab.research.google.com/github/NielsRogge/Transformers-Tutorials/blob/master/LayoutLMv2/CORD/Fine_tuning_LayoutLMv2ForTokenClassification_on_CORD.ipynb。
- 关于如何使用 HuggingFace Trainer 在 FUNSD 数据集上微调 LayoutLMv2 进行标记分类的笔记本。
- 另请参见：Token 分类任务指南
用法：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
< 来源 >( 词汇表大小 = 30522 隐藏层大小 = 768 隐藏层数量 = 12 注意力头数量 = 12 中间层大小 = 3072 隐藏激活函数 = 'gelu' 隐藏层 dropout 概率 = 0.1 注意力概率 dropout 概率 = 0.1 最大位置嵌入 = 512 类型词汇表大小 = 2 初始化器范围 = 0.02 层归一化 epsilon = 1e-12 填充 token id = 0 最大 2D 位置嵌入 = 1024 最大相对位置 = 128 相对位置 bin 数量 = 32 快速 QKV = True 最大相对 2D 位置 = 256 相对 2D 位置 bin 数量 = 64 转换同步批归一化 = True 图像特征池形状 = [7, 7, 256] 坐标大小 = 128 形状大小 = 128 具有相对注意力偏差 = True 具有空间注意力偏差 = True 具有视觉分段嵌入 = False Detectron2 配置参数 = 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) — 2D 位置嵌入可能使用的最大值。通常为了以防万一（例如 1024），将其设置为一个较大的值。 - max_rel_pos (
int, 可选, 默认为 128) — 自注意力机制中使用的最大相对位置数。 - rel_pos_bins (
int, 可选, 默认为 32) — 自注意力机制中使用的相对位置 bin 数量。 - fast_qkv (
bool, 可选, 默认为True) — 是否在自注意力层中使用单个矩阵表示查询、键和值。 - max_rel_2d_pos (
int, optional, defaults to 256) — 自注意力机制中相对2D位置的最大数量。 - rel_2d_pos_bins (
int, optional, defaults to 64) — 自注意力机制中2D相对位置的bin数量。 - image_feature_pool_shape (
list[int], optional, defaults to [7, 7, 256]) — 平均池化特征图的形状。 - coordinate_size (
int, optional, defaults to 128) — 坐标嵌入的维度。 - shape_size (
int, optional, defaults to 128) — 宽度和高度嵌入的维度。 - has_relative_attention_bias (
bool, optional, defaults toTrue) — 是否在自注意力机制中使用相对注意力偏差。 - has_spatial_attention_bias (
bool, optional, defaults toTrue) — 是否在自注意力机制中使用空间注意力偏差。 - has_visual_segment_embedding (
bool, optional, defaults toFalse) — 是否添加视觉段嵌入。 - 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.configLayoutLMv2FeatureExtractor
预处理单张或批量图像。
LayoutLMv2ImageProcessor
class transformers.LayoutLMv2ImageProcessor
< 来源 >( do_resize: bool = True size: typing.Optional[dict[str, int]] = None resample: Resampling = <Resampling.BILINEAR: 2> apply_ocr: bool = True ocr_lang: typing.Optional[str] = None tesseract_config: typing.Optional[str] = '' **kwargs )
参数
- do_resize (
bool, optional, defaults toTrue) — 是否将图像的（高度，宽度）尺寸调整为(size["height"], size["width"])。可在preprocess方法中的do_resize参数覆盖。 - size (
dict[str, int]optional, defaults to{"height" -- 224, "width": 224})：调整大小后图像的尺寸。可在preprocess方法中的size参数覆盖。 - resample (
PILImageResampling, optional, defaults toResampling.BILINEAR) — 调整图像大小时使用的重采样滤波器。可在preprocess方法中的resample参数覆盖。 - apply_ocr (
bool, optional, defaults toTrue) — 是否应用Tesseract OCR引擎以获取单词+标准化边界框。可在preprocess方法中的apply_ocr参数覆盖。 - ocr_lang (
str, optional) — Tesseract OCR引擎使用的语言，由其ISO代码指定。默认使用英语。可在preprocess方法中的ocr_lang参数覆盖。 - tesseract_config (
str, optional, defaults to"") — 调用Tesseract时传递给config参数的任何附加自定义配置标志。例如：“—psm 6”。可在preprocess方法中的tesseract_config参数覆盖。
构建LayoutLMv2图像处理器。
preprocess
< 来源 >( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']] do_resize: typing.Optional[bool] = None size: typing.Optional[dict[str, int]] = None resample: Resampling = None apply_ocr: typing.Optional[bool] = None ocr_lang: typing.Optional[str] = None tesseract_config: typing.Optional[str] = None return_tensors: typing.Union[str, transformers.utils.generic.TensorType, NoneType] = None data_format: ChannelDimension = <ChannelDimension.FIRST: 'channels_first'> input_data_format: typing.Union[str, transformers.image_utils.ChannelDimension, NoneType] = None )
参数
- images (
ImageInput) — 要预处理的图像。 - do_resize (
bool, optional, defaults toself.do_resize) — 是否调整图像大小。 - size (
dict[str, int], optional, defaults toself.size) — 调整大小后输出图像的所需尺寸。 - resample (
PILImageResampling, optional, defaults toResampling.BILINEAR) — 调整图像大小时使用的重采样滤波器。可以是枚举PIL.Image重采样滤波器之一。仅在do_resize设置为True时有效。 - apply_ocr (
bool, optional, defaults toself.apply_ocr) — 是否应用Tesseract OCR引擎以获取单词+标准化边界框。 - ocr_lang (
str, optional, defaults toself.ocr_lang) — Tesseract OCR引擎使用的语言，由其ISO代码指定。默认使用英语。 - tesseract_config (
str, optional, defaults toself.tesseract_config) — 调用Tesseract时传递给config参数的任何附加自定义配置标志。 - return_tensors (
strorTensorType, optional) — 要返回的张量类型。可以是以下之一：- 未设置：返回
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 (
ChannelDimensionorstr, optional, defaults toChannelDimension.FIRST) — 输出图像的通道维度格式。可以是以下之一：ChannelDimension.FIRST：图像格式为（通道数，高度，宽度）。ChannelDimension.LAST：图像格式为（高度，宽度，通道数）。
预处理一张或一批图像。
LayoutLMv2ImageProcessorFast
class transformers.LayoutLMv2ImageProcessorFast
< 来源 >( **kwargs: typing_extensions.Unpack[transformers.models.layoutlmv2.image_processing_layoutlmv2_fast.LayoutLMv2FastImageProcessorKwargs] )
构建一个快速Layoutlmv2图像处理器。
preprocess
< 来源 >( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']] **kwargs: typing_extensions.Unpack[transformers.models.layoutlmv2.image_processing_layoutlmv2_fast.LayoutLMv2FastImageProcessorKwargs] ) → <class 'transformers.image_processing_base.BatchFeature'>
参数
- images (
Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]) — 要预处理的图像。期望像素值范围为0到255的单个图像或批处理图像。如果传入像素值在0到1之间的图像，请设置do_rescale=False。 - do_resize (
bool, optional) — 是否调整图像大小。 - size (
dict[str, int], optional) — 描述模型的最大输入维度。 - default_to_square (
bool, optional) — 如果尺寸是整数，则调整大小时是否默认为正方形图像。 - resample (
Union[PILImageResampling, F.InterpolationMode, NoneType]) — 调整图像大小以使用的重采样滤波器。可以是枚举PILImageResampling之一。仅在do_resize设置为True时有效。 - do_center_crop (
bool, optional) — 是否对图像进行中心裁剪。 - crop_size (
dict[str, int], optional) — 应用center_crop后输出图像的尺寸。 - do_rescale (
bool, optional) — 是否缩放图像。 - rescale_factor (
Union[int, float, NoneType]) — 如果do_rescale设置为True，则按此缩放因子缩放图像。 - do_normalize (
bool, optional) — 是否对图像进行归一化。 - image_mean (
Union[float, list[float], NoneType]) — 用于归一化的图像平均值。仅在do_normalize设置为True时有效。 - image_std (
Union[float, list[float], NoneType]) — 用于归一化的图像标准差。仅在do_normalize设置为True时有效。 - do_convert_rgb (
bool, optional) — 是否将图像转换为RGB。 - return_tensors (
Union[str, ~utils.generic.TensorType, NoneType]) — 如果设置为`pt`，则返回堆叠张量，否则返回张量列表。 - data_format (
~image_utils.ChannelDimension, optional) — 仅支持ChannelDimension.FIRST。为与慢速处理器兼容而添加。 - input_data_format (
Union[str, ~image_utils.ChannelDimension, NoneType]) — 输入图像的通道维度格式。如果未设置，通道维度格式将从输入图像中推断。可以是以下之一："channels_first"或ChannelDimension.FIRST：图像格式为（通道数，高度，宽度）。"channels_last"或ChannelDimension.LAST：图像格式为（高度，宽度，通道数）。"none"或ChannelDimension.NONE：图像格式为（高度，宽度）。
- device (
torch.device, optional) — 处理图像的设备。如果未设置，设备将从输入图像中推断。 - disable_grouping (
bool, optional) — 是否禁用按大小对图像进行分组，以便单独处理而非批处理。如果为None，则在图像位于CPU上时设置为True，否则设置为False。此选择基于经验观察，详情请参阅此处：https://github.com/huggingface/transformers/pull/38157 - apply_ocr (
bool, optional, defaults toTrue) — 是否应用Tesseract OCR引擎以获取单词+标准化边界框。可在preprocess方法中的apply_ocr参数覆盖。 - ocr_lang (
str, optional) — Tesseract OCR引擎使用的语言，由其ISO代码指定。默认使用英语。可在preprocess方法中的ocr_lang参数覆盖。 - tesseract_config (
str, 可选) — 转发给 Tesseract `config` 参数的任何额外自定义配置标志。例如：`--psm 6`。可以通过 `preprocess` 方法中的 `tesseract_config` 参数覆盖。
返回
<class 'transformers.image_processing_base.BatchFeature'>
- data (
dict) — 由 call 方法返回的列表/数组/张量字典（“pixel_values”等）。 - tensor_type (
Union[None, str, TensorType], 可选) — 您可以在此处提供一个`tensor_type`，以便在初始化时将整数列表转换为PyTorch/TensorFlow/Numpy张量。
LayoutLMv2Tokenizer
class transformers.LayoutLMv2Tokenizer
< source >( 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: typing.Optional[list[str]] = None **kwargs )
构建一个 LayoutLMv2 分词器。基于 WordPiece。LayoutLMv2Tokenizer 可用于将单词、单词级边界框和可选的单词标签转换为标记级 input_ids、attention_mask、token_type_ids、bbox 和可选的 labels（用于标记分类）。
此分词器继承自 PreTrainedTokenizer，其中包含大多数主要方法。用户应参阅此超类以获取有关这些方法的更多信息。
LayoutLMv2Tokenizer 执行端到端分词：标点符号分割和 WordPiece。它还将单词级边界框转换为标记级边界框。
__call__
< source >( text: typing.Union[str, list[str], list[list[str]]] text_pair: typing.Union[list[str], list[list[str]], NoneType] = None boxes: typing.Union[list[list[int]], list[list[list[int]]], NoneType] = None word_labels: typing.Union[list[int], list[list[int]], NoneType] = None add_special_tokens: bool = True padding: typing.Union[bool, str, transformers.utils.generic.PaddingStrategy] = False truncation: typing.Union[bool, str, transformers.tokenization_utils_base.TruncationStrategy] = None max_length: typing.Optional[int] = None stride: int = 0 pad_to_multiple_of: typing.Optional[int] = None padding_side: typing.Optional[str] = None return_tensors: typing.Union[str, transformers.utils.generic.TensorType, NoneType] = None return_token_type_ids: typing.Optional[bool] = None return_attention_mask: typing.Optional[bool] = None return_overflowing_tokens: bool = False return_special_tokens_mask: bool = False return_offsets_mapping: bool = False return_length: bool = False verbose: bool = True **kwargs ) → 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。如果保留默认值，将根据特定分词器的默认设置返回标记类型 ID，由return_outputs属性定义。 - 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，包含以下字段：
-
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
class 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: typing.Union[str, list[str], list[list[str]]] text_pair: typing.Union[list[str], list[list[str]], NoneType] = None boxes: typing.Union[list[list[int]], list[list[list[int]]], NoneType] = None word_labels: typing.Union[list[int], list[list[int]], NoneType] = None add_special_tokens: bool = True padding: typing.Union[bool, str, transformers.utils.generic.PaddingStrategy] = False truncation: typing.Union[bool, str, transformers.tokenization_utils_base.TruncationStrategy] = None max_length: typing.Optional[int] = None stride: int = 0 pad_to_multiple_of: typing.Optional[int] = None padding_side: typing.Optional[str] = None return_tensors: typing.Union[str, transformers.utils.generic.TensorType, NoneType] = None return_token_type_ids: typing.Optional[bool] = None return_attention_mask: typing.Optional[bool] = None return_overflowing_tokens: bool = False return_special_tokens_mask: bool = False return_offsets_mapping: bool = False return_length: bool = False verbose: bool = True **kwargs ) → 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等token分类任务）。 - add_special_tokens (
bool, 可选, 默认为True) — 是否使用与模型相关的特殊标记来编码序列。 - padding (
bool,str或 PaddingStrategy, 可选, 默认为False) — 激活并控制填充。接受以下值：True或'longest'：填充到批处理中最长的序列（如果只提供单个序列则不填充）。'max_length'：填充到由参数max_length指定的最大长度，如果未提供该参数，则填充到模型可接受的最大输入长度。False或'do_not_pad'(默认)：不填充（即，可以输出具有不同长度序列的批处理）。
- truncation (
bool,str或 TruncationStrategy, 可选, 默认为False) — 激活并控制截断。接受以下值：True或'longest_first'：截断到由参数max_length指定的最大长度，如果未提供该参数，则截断到模型可接受的最大输入长度。如果提供了一对序列（或一批对），则此操作将逐个 token 截断，从对中最长的序列中移除一个 token。'only_first'：截断到由参数max_length指定的最大长度，如果未提供该参数，则截断到模型可接受的最大输入长度。如果提供了一对序列（或一批对），则此操作将仅截断第一序列。'only_second'：截断到由参数max_length指定的最大长度，如果未提供该参数，则截断到模型可接受的最大输入长度。如果提供了一对序列（或一批对），则此操作将仅截断第二序列。False或'do_not_truncate'(默认)：不截断（即，可以输出序列长度大于模型最大可接受输入大小的批处理）。
- max_length (
int, 可选) — 控制截断/填充参数使用的最大长度。如果未设置或设置为
None，如果其中一个截断/填充参数需要最大长度，则此操作将使用预定义的模型最大长度。如果模型没有特定的最大输入长度（如XLNet），则到最大长度的截断/填充将被停用。 - stride (
int, 可选, 默认为 0) — 如果设置为一个数字并与max_length一起使用，当return_overflowing_tokens=True时，返回的溢出 token 将包含截断序列末尾的一些 token，以提供截断序列和溢出序列之间的一些重叠。此参数的值定义重叠 token 的数量。 - 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, 可选) — 是否返回 token 类型 ID。如果保留默认值，将根据特定分词器的默认设置（由return_outputs属性定义）返回 token 类型 ID。 - return_attention_mask (
bool, 可选) — 是否返回注意力掩码。如果保留默认值，将根据特定分词器的默认设置（由return_outputs属性定义）返回注意力掩码。 - return_overflowing_tokens (
bool, 可选, 默认为False) — 是否返回溢出 token 序列。如果提供了一对输入 ID 序列（或一批对），并且truncation_strategy = longest_first或True，则会引发错误，而不是返回溢出 token。 - return_special_tokens_mask (
bool, 可选, 默认为False) — 是否返回特殊 token 掩码信息。 - return_offsets_mapping (
bool, 可选, 默认为False) — 是否返回每个 token 的(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
< 源 >( image_processor = None tokenizer = None **kwargs )
参数
- image_processor (
LayoutLMv2ImageProcessor, 可选) — LayoutLMv2ImageProcessor 的实例。图像处理器是必需输入。 - tokenizer (
LayoutLMv2Tokenizer或LayoutLMv2TokenizerFast, 可选) — LayoutLMv2Tokenizer 或 LayoutLMv2TokenizerFast 的实例。分词器是必需输入。
构建一个 LayoutLMv2 处理器，它将 LayoutLMv2 图像处理器和 LayoutLMv2 分词器组合成一个单一的处理器。
LayoutLMv2Processor 提供了准备模型所需的所有功能。
它首先使用 LayoutLMv2ImageProcessor 将文档图像调整为固定大小，并可选地应用 OCR 来获取单词和归一化的边界框。然后将这些信息提供给 LayoutLMv2Tokenizer 或 LayoutLMv2TokenizerFast，后者将单词和边界框转换为 token 级别的 input_ids、attention_mask、token_type_ids、bbox。可选地，可以提供整数 word_labels，它们被转换为 token 级别的 labels，用于 token 分类任务（如 FUNSD、CORD）。
__call__
< 源 >( images text: typing.Union[str, list[str], list[list[str]]] = None text_pair: typing.Union[list[str], list[list[str]], NoneType] = None boxes: typing.Union[list[list[int]], list[list[list[int]]], NoneType] = None word_labels: typing.Union[list[int], list[list[int]], NoneType] = None add_special_tokens: bool = True padding: typing.Union[bool, str, transformers.utils.generic.PaddingStrategy] = False truncation: typing.Union[bool, str, transformers.tokenization_utils_base.TruncationStrategy] = False max_length: typing.Optional[int] = None stride: int = 0 pad_to_multiple_of: typing.Optional[int] = None return_token_type_ids: typing.Optional[bool] = None return_attention_mask: typing.Optional[bool] = None return_overflowing_tokens: bool = False return_special_tokens_mask: bool = False return_offsets_mapping: bool = False return_length: bool = False verbose: bool = True return_tensors: typing.Union[str, transformers.utils.generic.TensorType, NoneType] = None **kwargs )
此方法首先将 images 参数转发给 call()。如果 LayoutLMv2ImageProcessor 使用 apply_ocr 设置为 True 进行初始化，它将把获得的单词和边界框以及附加参数传递给 call() 并返回输出以及调整大小的 images。如果 LayoutLMv2ImageProcessor 使用 apply_ocr 设置为 False 进行初始化，它将把用户指定的单词（text/text_pair）和 boxes 以及附加参数传递给 [__call__()](/docs/transformers/v4.53.3/en/model_doc/layoutlmv2#transformers.LayoutLMv2Tokenizer.__call__) 并返回输出以及调整大小的 images。
有关更多信息，请参阅上述两种方法的文档字符串。
LayoutLMv2Model
class transformers.LayoutLMv2Model
< 源 >( config )
参数
- config (LayoutLMv2Model) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，只加载配置。请查看 from_pretrained() 方法来加载模型权重。
裸的 Layoutlmv2 模型，输出原始隐藏状态，顶部没有任何特定头部。
此模型继承自 PreTrainedModel。请查看超类文档，了解库为其所有模型实现的一般方法（例如下载或保存、调整输入嵌入大小、修剪头部等）。
此模型也是 PyTorch torch.nn.Module 子类。将其作为常规 PyTorch 模块使用，并参考 PyTorch 文档中所有与一般用法和行为相关的内容。
前向
< 源 >( input_ids: typing.Optional[torch.LongTensor] = None bbox: typing.Optional[torch.LongTensor] = None image: typing.Optional[torch.FloatTensor] = None attention_mask: typing.Optional[torch.FloatTensor] = None token_type_ids: typing.Optional[torch.LongTensor] = None position_ids: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.BaseModelOutputWithPooling 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor形状为(batch_size, sequence_length), 可选) — 词汇表中输入序列 token 的索引。填充将默认被忽略。索引可以使用 AutoTokenizer 获得。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- bbox (
torch.LongTensor形状为((batch_size, sequence_length), 4), 可选) — 每个输入序列 token 的边界框。选择范围为[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), 可选) — 避免在填充 token 索引上执行注意力的掩码。掩码值选择范围为[0, 1]：- 1 表示 token 未被掩码，
- 0 表示 token 被掩码。
- token_type_ids (
torch.LongTensor形状为(batch_size, sequence_length), 可选) — 分段 token 索引，用于指示输入的第一个和第二个部分。索引选择范围为[0, 1]：- 0 对应于 句子 A token，
- 1 对应于 句子 B token。
- position_ids (
torch.LongTensor形状为(batch_size, sequence_length), 可选) — 每个输入序列 token 在位置嵌入中的位置索引。选择范围为[0, config.n_positions - 1]。 - head_mask (
torch.FloatTensor形状为(num_heads,)或(num_layers, num_heads), 可选) — 用于使自注意力模块的选定头部无效的掩码。掩码值选择范围为[0, 1]：- 1 表示头部未被掩码，
- 0 表示头部被掩码。
- inputs_embeds (
torch.FloatTensor形状为(batch_size, sequence_length, hidden_size), 可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您希望对如何将input_ids索引转换为相关向量有比模型内部嵌入查找矩阵更多的控制，这将非常有用。 - output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是纯元组。
返回
transformers.modeling_outputs.BaseModelOutputWithPooling 或 tuple(torch.FloatTensor)
transformers.modeling_outputs.BaseModelOutputWithPooling 或 torch.FloatTensor 元组（如果传递 return_dict=False 或 config.return_dict=False），包含根据配置（LayoutLMv2Config）和输入而变化的各种元素。
-
last_hidden_state (
torch.FloatTensor, 形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。 -
pooler_output (
torch.FloatTensor形状为(batch_size, hidden_size)) — 序列第一个 token（分类 token）的最后一层隐藏状态，经过用于辅助预训练任务的层进一步处理。例如，对于 BERT 家族的模型，这会在通过线性层和 tanh 激活函数处理后返回分类 token。线性层权重在预训练期间通过下一句预测（分类）目标进行训练。 -
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")
>>> image = dataset["test"][0]["image"]
>>> 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 (LayoutLMv2ForSequenceClassification) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，只加载配置。请查看 from_pretrained() 方法来加载模型权重。
带有序列分类头部的 LayoutLMv2 模型（在 [CLS] token 的最终隐藏状态、平均池化初始视觉嵌入和平均池化最终视觉嵌入的串联之上添加一个线性层），例如用于文档图像分类任务，如 RVL-CDIP 数据集。
此模型继承自 PreTrainedModel。请查看超类文档，了解库为其所有模型实现的一般方法（例如下载或保存、调整输入嵌入大小、修剪头部等）。
此模型也是 PyTorch torch.nn.Module 子类。将其作为常规 PyTorch 模块使用，并参考 PyTorch 文档中所有与一般用法和行为相关的内容。
前向
< 源 >( input_ids: typing.Optional[torch.LongTensor] = None bbox: typing.Optional[torch.LongTensor] = None image: typing.Optional[torch.FloatTensor] = None attention_mask: typing.Optional[torch.FloatTensor] = None token_type_ids: typing.Optional[torch.LongTensor] = None position_ids: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.SequenceClassifierOutput or tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensorof shapebatch_size, sequence_length) — 词汇表中输入序列标记的索引。可以使用AutoTokenizer获取索引。有关详细信息，请参阅PreTrainedTokenizer.encode()和PreTrainedTokenizer.call()。
- 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或其tensors形状为(batch_size, num_channels, height, width)的detectron.structures.ImageList) — 文档图像批次。 - 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标记。
- position_ids (形状为
batch_size, sequence_length的torch.LongTensor，可选) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。 - 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索引转换为相关向量具有比模型内部嵌入查找矩阵更多的控制权，这将很有用。 - labels (形状为
(batch_size,)的torch.LongTensor，可选) — 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]之间。如果config.num_labels == 1，则计算回归损失（均方损失），如果config.num_labels > 1，则计算分类损失（交叉熵）。 - output_attentions (
bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。 - return_dict (
bool，可选) — 是否返回ModelOutput而不是普通元组。
返回
transformers.modeling_outputs.SequenceClassifierOutput 或 tuple(torch.FloatTensor)
一个transformers.modeling_outputs.SequenceClassifierOutput或torch.FloatTensor的元组（如果传入return_dict=False或config.return_dict=False），包含根据配置（LayoutLMv2Config）和输入的不同元素。
-
loss (形状为
(1,)的torch.FloatTensor，可选，当提供labels时返回) — 分类损失（如果 config.num_labels==1，则为回归损失）。 -
logits (形状为
(batch_size, config.num_labels)的torch.FloatTensor) — 分类（如果 config.num_labels==1，则为回归）分数（SoftMax 之前）。 -
hidden_states (
tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor元组（如果模型有嵌入层，则为嵌入输出一个，每层输出一个），形状为(batch_size, sequence_length, hidden_size)。模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。
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)
>>> 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
class transformers.LayoutLMv2ForTokenClassification
< 源 >( config )
参数
- config (LayoutLMv2ForTokenClassification) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型相关的权重，只加载配置。请查看from_pretrained()方法加载模型权重。
LayoutLMv2模型，顶部带有一个标记分类头（隐藏状态文本部分顶部的线性层），例如用于序列标注（信息提取）任务，如FUNSD、SROIE、CORD和Kleister-NDA。
此模型继承自 PreTrainedModel。请查看超类文档，了解库为其所有模型实现的一般方法（例如下载或保存、调整输入嵌入大小、修剪头部等）。
此模型也是 PyTorch torch.nn.Module 子类。将其作为常规 PyTorch 模块使用，并参考 PyTorch 文档中所有与一般用法和行为相关的内容。
前向
< 源 >( input_ids: typing.Optional[torch.LongTensor] = None bbox: typing.Optional[torch.LongTensor] = None image: typing.Optional[torch.FloatTensor] = None attention_mask: typing.Optional[torch.FloatTensor] = None token_type_ids: typing.Optional[torch.LongTensor] = None position_ids: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.TokenClassifierOutput or tuple(torch.FloatTensor)
参数
- input_ids (形状为
batch_size, sequence_length的torch.LongTensor) — 词汇表中输入序列标记的索引。可以使用AutoTokenizer获取索引。有关详细信息，请参阅PreTrainedTokenizer.encode()和PreTrainedTokenizer.call()。
- 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或其tensors形状为(batch_size, num_channels, height, width)的detectron.structures.ImageList) — 文档图像批次。 - 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标记。
- position_ids (形状为
batch_size, sequence_length的torch.LongTensor，可选) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。 - 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索引转换为相关向量具有比模型内部嵌入查找矩阵更多的控制权，这将很有用。 - labels (形状为
(batch_size, sequence_length)的torch.LongTensor，可选) — 用于计算标记分类损失的标签。索引应在[0, ..., config.num_labels - 1]之间。 - output_attentions (
bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。 - return_dict (
bool，可选) — 是否返回ModelOutput而不是普通元组。
返回
transformers.modeling_outputs.TokenClassifierOutput 或 tuple(torch.FloatTensor)
一个transformers.modeling_outputs.TokenClassifierOutput或torch.FloatTensor的元组（如果传入return_dict=False或config.return_dict=False），包含根据配置（LayoutLMv2Config）和输入的不同元素。
-
loss (形状为
(1,)的torch.FloatTensor，可选，当提供labels时返回) — 分类损失。 -
logits (形状为
(batch_size, sequence_length, config.num_labels)的torch.FloatTensor) — 分类分数（SoftMax 之前）。 -
hidden_states (
tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor元组（如果模型有嵌入层，则为嵌入输出一个，每层输出一个），形状为(batch_size, sequence_length, hidden_size)。模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。
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")
>>> 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
< 源 >( config has_visual_segment_embedding = True )
参数
- config (LayoutLMv2ForQuestionAnswering) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型相关的权重，只加载配置。请查看from_pretrained()方法加载模型权重。
- has_visual_segment_embedding (
bool，可选，默认为True) — 是否添加视觉段嵌入。
Layoutlmv2 Transformer，顶部带有一个跨度分类头，用于像SQuAD这样的抽取式问答任务（隐藏状态输出顶部的一个线性层，用于计算span start logits和span end logits）。
此模型继承自 PreTrainedModel。请查看超类文档，了解库为其所有模型实现的一般方法（例如下载或保存、调整输入嵌入大小、修剪头部等）。
此模型也是 PyTorch torch.nn.Module 子类。将其作为常规 PyTorch 模块使用，并参考 PyTorch 文档中所有与一般用法和行为相关的内容。
前向
< 源 >( input_ids: typing.Optional[torch.LongTensor] = None bbox: typing.Optional[torch.LongTensor] = None image: typing.Optional[torch.FloatTensor] = None attention_mask: typing.Optional[torch.FloatTensor] = None token_type_ids: typing.Optional[torch.LongTensor] = None position_ids: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None start_positions: typing.Optional[torch.LongTensor] = None end_positions: typing.Optional[torch.LongTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.QuestionAnsweringModelOutput or tuple(torch.FloatTensor)
参数
- input_ids (形状为
batch_size, sequence_length的torch.LongTensor) — 词汇表中输入序列标记的索引。可以使用AutoTokenizer获取索引。有关详细信息，请参阅PreTrainedTokenizer.encode()和PreTrainedTokenizer.call()。
- 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或其tensors形状为(batch_size, num_channels, height, width)的detectron.structures.ImageList) — 文档图像批次。 - 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标记。
- position_ids (形状为
batch_size, sequence_length的torch.LongTensor，可选) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。 - head_mask (形状为
(num_heads,)或(num_layers, num_heads)的torch.FloatTensor，可选) — 用于使自注意力模块的选定头部无效的掩码。掩码值选择范围为[0, 1]：- 1表示头部未被掩盖，
- 0表示头部被掩盖。
- inputs_embeds (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 可选参数，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您希望对如何将input_ids索引转换为相关向量有更多控制，而不是依赖模型的内部嵌入查找矩阵，此参数会很有用。 - start_positions (
torch.LongTensor，形状为(batch_size,)，可选) — 用于计算标记分类损失的标记范围起始位置（索引）的标签。位置将被限制在序列长度（sequence_length）内。序列外的位置不计入损失计算。 - end_positions (
torch.LongTensor，形状为(batch_size,)，可选) — 用于计算标记分类损失的标记范围结束位置（索引）的标签。位置将被限制在序列长度（sequence_length）内。序列外的位置不计入损失计算。 - output_attentions (
bool，可选) — 是否返回所有注意力层的注意力张量。更多详情请参阅返回张量中的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。更多详情请参阅返回张量中的hidden_states。 - return_dict (
bool，可选) — 是否返回 ModelOutput 对象而不是普通元组。
返回
transformers.modeling_outputs.QuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)
transformers.modeling_outputs.QuestionAnsweringModelOutput 或 torch.FloatTensor 元组（如果传递了 return_dict=False 或 config.return_dict=False），包含根据配置（LayoutLMv2Config）和输入的不同元素。
-
loss (
torch.FloatTensorof shape(1,), 可选, 当提供labels时返回) — 总范围提取损失是起始位置和结束位置的交叉熵之和。 -
start_logits (
torch.FloatTensorof shape(batch_size, sequence_length)) — 范围起始分数（SoftMax 之前）。 -
end_logits (
torch.FloatTensorof shape(batch_size, sequence_length)) — 范围结束分数（SoftMax 之前）。 -
hidden_states (
tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor元组（如果模型有嵌入层，则为嵌入输出一个，每层输出一个），形状为(batch_size, sequence_length, hidden_size)。模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。
LayoutLMv2ForQuestionAnswering 的 forward 方法，它覆盖了 __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")
>>> image = dataset["test"][0]["image"]
>>> 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)