LayoutLMv3
概述
LayoutLMv3 模型在 LayoutLMv3: Pre-training for Document AI with Unified Text and Image Masking 中被提出，作者是 Yupan Huang, Tengchao Lv, Lei Cui, Yutong Lu, Furu Wei。LayoutLMv3 通过使用 patch embeddings (如同 ViT) 而不是利用 CNN backbone 简化了 LayoutLMv2，并在 3 个目标上预训练模型：masked language modeling (MLM)、masked image modeling (MIM) 和 word-patch alignment (WPA)。
论文的摘要如下
在文档人工智能领域，自监督预训练技术取得了显著进展。大多数多模态预训练模型使用掩码语言建模目标来学习文本模态上的双向表示，但它们在图像模态的预训练目标上有所不同。这种差异增加了多模态表示学习的难度。在本文中，我们提出了 LayoutLMv3，通过统一的文本和图像掩码来预训练文档人工智能的多模态 Transformer 模型。此外，LayoutLMv3 还使用单词-图像块对齐目标进行预训练，通过预测文本单词的对应图像块是否被掩码来学习跨模态对齐。简单的统一架构和训练目标使 LayoutLMv3 成为适用于以文本为中心和以图像为中心的文档人工智能任务的通用预训练模型。实验结果表明，LayoutLMv3 不仅在以文本为中心的任务（包括表单理解、收据理解和文档视觉问答）中，而且在以图像为中心的任务（如文档图像分类和文档布局分析）中，都取得了最先进的性能。
LayoutLMv3 架构。 摘自原始论文。此模型由 nielsr 贡献。此模型的 TensorFlow 版本由 chriskoo、tokec 和 lre 添加。原始代码可以在这里找到。
使用技巧
- 在数据处理方面，LayoutLMv3 与其前身 LayoutLMv2 完全相同，除了
- 图像需要调整大小并以常规 RGB 格式进行通道归一化。另一方面，LayoutLMv2 在内部对图像进行归一化，并期望通道采用 BGR 格式。
- 文本使用字节对编码 (BPE) 进行分词，而不是 WordPiece。由于数据预处理方面的这些差异，可以使用 LayoutLMv3Processor，它在内部结合了 LayoutLMv3ImageProcessor（用于图像模态）和 LayoutLMv3Tokenizer/LayoutLMv3TokenizerFast（用于文本模态）来为模型准备所有数据。
- 关于 LayoutLMv3Processor 的使用，我们参考其前身的使用指南。
资源
以下是官方 Hugging Face 和社区（用 🌎 表示）资源的列表，可帮助您开始使用 LayoutLMv3。如果您有兴趣提交资源以包含在此处，请随时打开 Pull Request，我们将对其进行审核！理想情况下，资源应展示一些新的内容，而不是重复现有资源。
LayoutLMv3 与 LayoutLMv2 几乎相同，因此我们也包含您可以为 LayoutLMv3 任务改编的 LayoutLMv2 资源。对于这些 notebook，在为模型准备数据时，请注意使用 LayoutLMv2Processor！
- LayoutLMv3ForTokenClassification 由此示例脚本和notebook支持。
- 关于如何使用 LayoutLMv2ForTokenClassification 执行推理的notebook，以及关于在没有标签的情况下如何使用 LayoutLMv2ForTokenClassification 执行推理的notebook。
- 关于如何使用 🤗 Trainer 微调 LayoutLMv2ForTokenClassification 的notebook。
- Token 分类任务指南
文档问答
LayoutLMv3Config
class transformers.LayoutLMv3Config
< source >( vocab_size = 50265 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-05 pad_token_id = 1 bos_token_id = 0 eos_token_id = 2 max_2d_position_embeddings = 1024 coordinate_size = 128 shape_size = 128 has_relative_attention_bias = True rel_pos_bins = 32 max_rel_pos = 128 rel_2d_pos_bins = 64 max_rel_2d_pos = 256 has_spatial_attention_bias = True text_embed = True visual_embed = True input_size = 224 num_channels = 3 patch_size = 16 classifier_dropout = None **kwargs )
参数
- vocab_size (
int, 可选, 默认为 50265) — LayoutLMv3 模型的词汇表大小。定义了在调用 LayoutLMv3Model 时传递的inputs_ids可以表示的不同 token 的数量。 - 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) — 在调用 LayoutLMv3Model 时传递的token_type_ids的词汇表大小。 - initializer_range (
float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。 - layer_norm_eps (
float, 可选, 默认为 1e-5) — 层归一化层使用的 epsilon 值。 - max_2d_position_embeddings (
int, 可选, 默认为 1024) — 2D 位置嵌入可能使用的最大值。通常将其设置为较大的值以防万一（例如，1024）。 - coordinate_size (
int, 可选, 默认为128) — 坐标嵌入的维度。 - shape_size (
int, 可选, 默认为128) — 宽度和高度嵌入的维度。 - has_relative_attention_bias (
bool, 可选, 默认为True) — 是否在自注意力机制中使用相对注意力偏差。 - rel_pos_bins (
int, 可选, 默认为 32) — 自注意力机制中要使用的相对位置 bin 的数量。 - max_rel_pos (
int, 可选, 默认为 128) — 自注意力机制中要使用的最大相对位置数。 - max_rel_2d_pos (
int, 可选, 默认为 256) — 自注意力机制中最大相对 2D 位置数。 - rel_2d_pos_bins (
int, optional, defaults to 64) — 自注意力机制中 2D 相对位置桶的数量。 - has_spatial_attention_bias (
bool, optional, defaults toTrue) — 是否在自注意力机制中使用空间注意力偏置。 - visual_embed (
bool, optional, defaults toTrue) — 是否添加图像块嵌入 (patch embeddings)。 - input_size (
int, optional, defaults to224) — 图像的大小（分辨率）。 - num_channels (
int, optional, defaults to3) — 图像的通道数。 - patch_size (
int, optional, defaults to16) — 图像块的大小（分辨率）。 - classifier_dropout (
float, optional) — 分类头的 dropout 比率。
这是用于存储 LayoutLMv3Model 配置的配置类。 它用于根据指定的参数实例化 LayoutLMv3 模型，定义模型架构。 使用默认值实例化配置将产生与 LayoutLMv3 microsoft/layoutlmv3-base 架构类似的配置。
配置对象继承自 PretrainedConfig，可用于控制模型输出。 有关更多信息，请阅读 PretrainedConfig 的文档。
示例
>>> from transformers import LayoutLMv3Config, LayoutLMv3Model
>>> # Initializing a LayoutLMv3 microsoft/layoutlmv3-base style configuration
>>> configuration = LayoutLMv3Config()
>>> # Initializing a model (with random weights) from the microsoft/layoutlmv3-base style configuration
>>> model = LayoutLMv3Model(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configLayoutLMv3FeatureExtractor
预处理单张图像或一批图像。
LayoutLMv3ImageProcessor
class transformers.LayoutLMv3ImageProcessor
< source >( do_resize: bool = True size: Dict = None resample: Resampling = <Resampling.BILINEAR: 2> do_rescale: bool = True rescale_value: float = 0.00392156862745098 do_normalize: bool = True image_mean: Union = None image_std: Union = None apply_ocr: bool = True ocr_lang: Optional = None tesseract_config: Optional = '' **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 toPILImageResampling.BILINEAR) — 如果调整图像大小，则使用的重采样滤波器。 可以被preprocess中的resample参数覆盖。 - do_rescale (
bool, optional, defaults toTrue) — 是否按指定的rescale_value重新缩放图像的像素值。 可以被preprocess中的do_rescale参数覆盖。 - rescale_factor (
float, optional, defaults to 1 / 255) — 图像像素值重新缩放的因子。 可以被preprocess中的rescale_factor参数覆盖。 - do_normalize (
bool, optional, defaults toTrue) — 是否对图像进行归一化。 可以被preprocess方法中的do_normalize参数覆盖。 - image_mean (
Iterable[float]orfloat, optional, defaults toIMAGENET_STANDARD_MEAN) — 如果对图像进行归一化，则使用的均值。 这是一个浮点数或浮点数列表，其长度等于图像中的通道数。 可以被preprocess方法中的image_mean参数覆盖。 - image_std (
Iterable[float]orfloat, optional, defaults toIMAGENET_STANDARD_STD) — 如果对图像进行归一化，则使用的标准差。 这是一个浮点数或浮点数列表，其长度等于图像中的通道数。 可以被preprocess方法中的image_std参数覆盖。 - 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) — 传递给 Tesseract 的任何其他自定义配置标志，当调用 Tesseract 时会转发到config参数。 例如：‘—psm 6’。 可以被preprocess方法中的tesseract_config参数覆盖。
构建 LayoutLMv3 图像处理器。
preprocess
< source >( images: Union do_resize: bool = None size: Dict = None resample = None do_rescale: bool = None rescale_factor: float = None do_normalize: bool = None image_mean: Union = None image_std: Union = 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) — 要预处理的图像。 期望单张或一批像素值范围为 0 到 255 的图像。 如果传入像素值在 0 到 1 之间的图像，请设置do_rescale=False。 - do_resize (
bool, optional, defaults toself.do_resize) — Whether to resize the image. - size (
Dict[str, int], optional, defaults toself.size) — Desired size of the output image after applyingresize. - resample (
int, optional, defaults toself.resample) — Resampling filter to use if resizing the image. This can be one of thePILImageResamplingfilters. Only has an effect ifdo_resizeis set toTrue. - do_rescale (
bool, optional, defaults toself.do_rescale) — Whether to rescale the image pixel values between [0, 1]. - rescale_factor (
float, optional, defaults toself.rescale_factor) — Rescale factor to apply to the image pixel values. Only has an effect ifdo_rescaleis set toTrue. - do_normalize (
bool, optional, defaults toself.do_normalize) — Whether to normalize the image. - image_mean (
floatorIterable[float], optional, defaults toself.image_mean) — Mean values to be used for normalization. Only has an effect ifdo_normalizeis set toTrue. - image_std (
floatorIterable[float], optional, defaults toself.image_std) — Standard deviation values to be used for normalization. Only has an effect ifdo_normalizeis set toTrue. - apply_ocr (
bool, optional, defaults toself.apply_ocr) — Whether to apply the Tesseract OCR engine to get words + normalized bounding boxes. - ocr_lang (
str, optional, defaults toself.ocr_lang) — The language, specified by its ISO code, to be used by the Tesseract OCR engine. By default, English is used. - tesseract_config (
str, optional, defaults toself.tesseract_config) — Any additional custom configuration flags that are forwarded to theconfigparameter when calling Tesseract. - return_tensors (
strorTensorType, optional) — The type of tensors to return. Can be one of:- Unset: Return a list of
np.ndarray. TensorType.TENSORFLOWor'tf': Return a batch of typetf.Tensor.TensorType.PYTORCHor'pt': Return a batch of typetorch.Tensor.TensorType.NUMPYor'np': Return a batch of typenp.ndarray.TensorType.JAXor'jax': Return a batch of typejax.numpy.ndarray.
- Unset: Return a list of
- data_format (
ChannelDimensionorstr, optional, defaults toChannelDimension.FIRST) — The channel dimension format for the output image. Can be one of:ChannelDimension.FIRST: image in (num_channels, height, width) format.ChannelDimension.LAST: image in (height, width, num_channels) format.
- input_data_format (
ChannelDimensionorstr, optional) — The channel dimension format for the input image. If unset, the channel dimension format is inferred from the input image. Can be one of:"channels_first"orChannelDimension.FIRST: image in (num_channels, height, width) format."channels_last"orChannelDimension.LAST: image in (height, width, num_channels) format."none"orChannelDimension.NONE: image in (height, width) format.
Preprocess an image or batch of images.
LayoutLMv3Tokenizer
class transformers.LayoutLMv3Tokenizer
< source >( vocab_file merges_file errors = 'replace' bos_token = '<s>' eos_token = '</s>' sep_token = '</s>' cls_token = '<s>' unk_token = '<unk>' pad_token = '<pad>' mask_token = '<mask>' add_prefix_space = True cls_token_box = [0, 0, 0, 0] sep_token_box = [0, 0, 0, 0] pad_token_box = [0, 0, 0, 0] pad_token_label = -100 only_label_first_subword = True **kwargs )
参数
- vocab_file (
str) — Path to the vocabulary file. - merges_file (
str) — Path to the merges file. - errors (
str, optional, defaults to"replace") — Paradigm to follow when decoding bytes to UTF-8. See bytes.decode for more information. - bos_token (
str, optional, defaults to"<s>") — The beginning of sequence token that was used during pretraining. Can be used a sequence classifier token.When building a sequence using special tokens, this is not the token that is used for the beginning of sequence. The token used is the
cls_token. - eos_token (
str, optional, defaults to"</s>") — The end of sequence token.When building a sequence using special tokens, this is not the token that is used for the end of sequence. The token used is the
sep_token. - sep_token (
str, optional, defaults to"</s>") — The separator token, which is used when building a sequence from multiple sequences, e.g. two sequences for sequence classification or for a text and a question for question answering. It is also used as the last token of a sequence built with special tokens. - cls_token (
str, optional, defaults to"<s>") — The classifier token which is used when doing sequence classification (classification of the whole sequence instead of per-token classification). It is the first token of the sequence when built with special tokens. - unk_token (
str, optional, defaults to"<unk>") — The unknown token. A token that is not in the vocabulary cannot be converted to an ID and is set to be this token instead. - pad_token (
str, optional, defaults to"<pad>") — The token used for padding, for example when batching sequences of different lengths. - mask_token (
str, optional, defaults to"<mask>") — The token used for masking values. This is the token used when training this model with masked language modeling. This is the token which the model will try to predict. - add_prefix_space (
bool, optional, defaults toTrue) — 是否在输入文本前添加一个空格。这允许像处理其他单词一样处理句首单词。(RoBERTa tokenizer 通过前导空格检测单词的开头)。 - cls_token_box (
List[int], optional, defaults to[0, 0, 0, 0]) — 用于特殊 [CLS] token 的边界框。 - sep_token_box (
List[int], optional, defaults to[0, 0, 0, 0]) — 用于特殊 [SEP] token 的边界框。 - pad_token_box (
List[int], optional, defaults to[0, 0, 0, 0]) — 用于特殊 [PAD] token 的边界框。 - pad_token_label (
int, optional, defaults to -100) — 用于 padding tokens 的标签。默认为 -100，这是 PyTorch 的 CrossEntropyLoss 的ignore_index。 - only_label_first_subword (
bool, optional, defaults toTrue) — 是否仅标记第一个 subword，以防提供单词标签。
构建 LayoutLMv3 tokenizer。 基于 RoBERTatokenizer (Byte Pair Encoding 或 BPE)。 LayoutLMv3Tokenizer 可以用于将单词、单词级边界框和可选的单词标签转换为 token 级别的 input_ids、attention_mask、token_type_ids、bbox 以及可选的 labels (用于 token 分类)。
此 tokenizer 继承自 PreTrainedTokenizer，其中包含大多数主要方法。 用户应参考此超类以获取有关这些方法的更多信息。
LayoutLMv3Tokenizer 运行端到端 tokenization：标点符号分割和 wordpiece。 它还将单词级边界框转换为 token 级边界框。
__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 )
参数
- text (
str,List[str],List[List[str]]) — 要编码的序列或序列批次。每个序列可以是字符串、字符串列表（单个示例的单词或示例批次的问题）或字符串列表的列表（单词批次）。 - text_pair (
List[str],List[List[str]]) — 要编码的序列或序列批次。每个序列都应该是字符串列表（预 token 化的字符串）。 - boxes (
List[List[int]],List[List[List[int]]]) — 单词级边界框。每个边界框应标准化为 0-1000 比例。 - word_labels (
List[int],List[List[int]], optional) — 单词级整数标签（用于 token 分类任务，如 FUNSD、CORD）。 - add_special_tokens (
bool, optional, defaults toTrue) — 是否使用与其模型相关的特殊 token 对序列进行编码。 - padding (
bool,stror PaddingStrategy, optional, defaults toFalse) — 激活并控制 padding。接受以下值：True或'longest'：填充到批次中最长的序列（如果仅提供单个序列，则不进行填充）。'max_length'：填充到由参数max_length指定的最大长度，如果未提供该参数，则填充到模型可接受的最大输入长度。False或'do_not_pad'(默认)：不进行填充（即，可以输出具有不同长度序列的批次）。
- truncation (
bool,stror TruncationStrategy, optional, defaults toFalse) — 激活并控制 truncation。接受以下值：True或'longest_first'：截断为由参数max_length指定的最大长度，如果未提供该参数，则截断为模型可接受的最大输入长度。如果提供了一对序列（或一批对），这将逐 token 截断，从对中最长的序列中删除 token。'only_first'：截断为由参数max_length指定的最大长度，如果未提供该参数，则截断为模型可接受的最大输入长度。如果提供了一对序列（或一批对），这将仅截断对中的第一个序列。'only_second'：截断为由参数max_length指定的最大长度，如果未提供该参数，则截断为模型可接受的最大输入长度。如果提供了一对序列（或一批对），这将仅截断对中的第二个序列。False或'do_not_truncate'(默认)：不进行截断（即，可以输出序列长度大于模型最大允许输入大小的批次）。
- max_length (
int, optional) — 控制由 truncation/padding 参数之一使用的最大长度。如果未设置或设置为
None，如果 truncation/padding 参数之一需要最大长度，则将使用预定义的模型最大长度。 如果模型没有特定的最大输入长度（如 XLNet），则将停用截断/填充到最大长度。 - stride (
int, optional, defaults to 0) — 如果与max_length一起设置，当return_overflowing_tokens=True时返回的溢出 token 将包含来自截断序列末尾的一些 token，以在截断序列和溢出序列之间提供一些重叠。 此参数的值定义了重叠 token 的数量。 - pad_to_multiple_of (
int, optional) — 如果设置，则将序列填充为提供值的倍数。 这对于在计算能力>= 7.5(Volta) 的 NVIDIA 硬件上启用 Tensor Cores 的使用特别有用。 - return_tensors (
stror TensorType, optional) — 如果设置，将返回 tensors 而不是 python 整数列表。 可接受的值为：'tf'：返回 TensorFlowtf.constant对象。'pt'：返回 PyTorchtorch.Tensor对象。'np'：返回 Numpynp.ndarray对象。
- add_special_tokens (
bool, optional, defaults toTrue) — 是否使用与其模型相关的特殊 token 对序列进行编码。 - padding (
bool,stror PaddingStrategy, optional, defaults toFalse) — 激活并控制 padding。接受以下值：True或'longest'：填充到批次中最长的序列（如果仅提供单个序列，则不进行填充）。'max_length'：填充到由参数max_length指定的最大长度，如果未提供该参数，则填充到模型可接受的最大输入长度。False或'do_not_pad'(默认)：不进行填充（即，可以输出具有不同长度序列的批次）。
- truncation (
bool,stror TruncationStrategy, optional, defaults toFalse) — 激活并控制 truncation。接受以下值：True或'longest_first'：截断为由参数max_length指定的最大长度，如果未提供该参数，则截断为模型可接受的最大输入长度。如果提供了一对序列（或一批对），这将逐 token 截断，从对中最长的序列中删除 token。'only_first'：截断为由参数max_length指定的最大长度，如果未提供该参数，则截断为模型可接受的最大输入长度。如果提供了一对序列（或一批对），这将仅截断对中的第一个序列。'only_second'：截断为由参数max_length指定的最大长度，如果未提供该参数，则截断为模型可接受的最大输入长度。如果提供了一对序列（或一批对），这将仅截断对中的第二个序列。False或'do_not_truncate'(默认)：不进行截断（即，可以输出序列长度大于模型最大允许输入大小的批次）。
- max_length (
int, optional) — 控制由 truncation/padding 参数之一使用的最大长度。 如果未设置或设置为None，如果 truncation/padding 参数之一需要最大长度，则将使用预定义的模型最大长度。 如果模型没有特定的最大输入长度（如 XLNet），则将停用截断/填充到最大长度。 - stride (
int, optional, defaults to 0) — 如果与max_length一起设置，当return_overflowing_tokens=True时返回的溢出 token 将包含来自截断序列末尾的一些 token，以在截断序列和溢出序列之间提供一些重叠。 此参数的值定义了重叠 token 的数量。 - pad_to_multiple_of (
int, optional) — 如果设置，则将序列填充为提供值的倍数。 这对于在计算能力>= 7.5(Volta) 的 NVIDIA 硬件上启用 Tensor Cores 的使用特别有用。 - return_tensors (
stror TensorType, optional) — 如果设置，将返回 tensors 而不是 python 整数列表。 可接受的值为：'tf'：返回 TensorFlowtf.constant对象。'pt'：返回 PyTorchtorch.Tensor对象。'np'：返回 Numpynp.ndarray对象。
用于为一个或多个序列或一对或多对序列以及单词级标准化边界框和可选标签进行 tokenization 和模型准备的主要方法。
LayoutLMv3TokenizerFast
class transformers.LayoutLMv3TokenizerFast
< source >( vocab_file = None merges_file = None tokenizer_file = None errors = 'replace' bos_token = '<s>' eos_token = '</s>' sep_token = '</s>' cls_token = '<s>' unk_token = '<unk>' pad_token = '<pad>' mask_token = '<mask>' add_prefix_space = True trim_offsets = True cls_token_box = [0, 0, 0, 0] sep_token_box = [0, 0, 0, 0] pad_token_box = [0, 0, 0, 0] pad_token_label = -100 only_label_first_subword = True **kwargs )
参数
- vocab_file (
str) — 词汇表文件的路径。 - merges_file (
str) — merges 文件的路径。 - errors (
str, 可选, 默认为"replace") — 将字节解码为 UTF-8 时遵循的范例。 有关更多信息，请参阅 bytes.decode。 - bos_token (
str, 可选, 默认为"<s>") — 序列开始标记，在预训练期间使用。 可以用作序列分类器标记。当使用特殊标记构建序列时，这不是用于序列开始的标记。 使用的标记是
cls_token。 - eos_token (
str, 可选, 默认为"</s>") — 序列结束标记。当使用特殊标记构建序列时，这不是用于序列结束的标记。 使用的标记是
sep_token。 - sep_token (
str, 可选, 默认为"</s>") — 分隔符标记，用于从多个序列构建序列时，例如用于序列分类的两个序列或用于问答的文本和问题。 它也用作使用特殊标记构建的序列的最后一个标记。 - cls_token (
str, 可选, 默认为"<s>") — 分类器标记，用于进行序列分类（对整个序列而不是每个标记进行分类）。 当使用特殊标记构建序列时，它是序列的第一个标记。 - unk_token (
str, 可选, 默认为"<unk>") — 未知标记。 词汇表中没有的标记无法转换为 ID，而是设置为此标记。 - pad_token (
str, 可选, 默认为"<pad>") — 用于填充的标记，例如当批处理不同长度的序列时。 - mask_token (
str, 可选, 默认为"<mask>") — 用于掩码值的标记。 这是使用掩码语言建模训练此模型时使用的标记。 这是模型将尝试预测的标记。 - add_prefix_space (
bool, 可选, 默认为False) — 是否在输入中添加初始空格。 这允许将起始词语视为与任何其他词语一样。（RoBERTa 分词器通过前面的空格检测词语的开头）。 - trim_offsets (
bool, 可选, 默认为True) — 后处理步骤是否应修剪偏移量以避免包含空格。 - cls_token_box (
List[int], 可选, 默认为[0, 0, 0, 0]) — 用于特殊 [CLS] 标记的边界框。 - sep_token_box (
List[int], 可选, 默认为[0, 0, 0, 0]) — 用于特殊 [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) — 在提供词语标签的情况下，是否仅标记第一个子词。
构建一个“快速” LayoutLMv3 分词器（由 HuggingFace 的 tokenizers 库支持）。 基于 BPE。
此分词器继承自 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 )
参数
- 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时返回的溢出 token 将包含来自截断序列末尾的一些 token，以便在截断序列和溢出序列之间提供一些重叠。此参数的值定义了重叠 token 的数量。 - pad_to_multiple_of (
int, 可选) — 如果设置，则将序列填充到提供值的倍数。这对于在计算能力>= 7.5(Volta) 的 NVIDIA 硬件上启用 Tensor Core 非常有用。 - return_tensors (
str或 TensorType, 可选) — 如果设置，将返回 tensor 而不是 python 整数列表。可接受的值为：'tf': 返回 TensorFlowtf.constant对象。'pt': 返回 PyTorchtorch.Tensor对象。'np': 返回 Numpynp.ndarray对象。
- add_special_tokens (
bool, 可选, 默认为True) — 是否使用与其模型相关的特殊标记对序列进行编码。 - padding (
bool,str或 PaddingStrategy, 可选, 默认为False) — 激活和控制填充。 接受以下值：True或'longest'：填充到批次中最长的序列（如果仅提供单个序列，则不填充）。'max_length'：填充到使用参数max_length指定的最大长度，或者如果未提供该参数，则填充到模型可接受的最大输入长度。False或'do_not_pad'（默认）：不填充（即，可以输出具有不同长度序列的批次）。
- truncation (
bool,str或 TruncationStrategy, 可选, 默认为False) — 激活和控制截断。 接受以下值：True或'longest_first'：截断为使用参数max_length指定的最大长度，或者如果未提供该参数，则截断为模型可接受的最大输入长度。 如果提供了一对序列（或一批对），这将逐个标记地截断，从对中最长的序列中删除标记。'only_first'：截断为使用参数max_length指定的最大长度，或者如果未提供该参数，则截断为模型可接受的最大输入长度。 如果提供了一对序列（或一批对），则这将仅截断对的第一个序列。'only_second'：截断为使用参数max_length指定的最大长度，或者如果未提供该参数，则截断为模型可接受的最大输入长度。 如果提供了一对序列（或一批对），则这将仅截断对的第二个序列。False或'do_not_truncate'（默认）：不截断（即，可以输出序列长度大于模型最大允许输入大小的批次）。
- max_length (
int, 可选) — 控制截断/填充参数之一使用的最大长度。如果未设置或设置为None，这将使用预定义的模型最大长度（如果截断/填充参数之一需要最大长度）。如果模型没有特定的最大输入长度（如 XLNet），则将停用截断/填充到最大长度。 - stride (
int, 可选, 默认为 0) — 如果与max_length一起设置为一个数字，当return_overflowing_tokens=True时返回的溢出 token 将包含来自截断序列末尾的一些 token，以便在截断序列和溢出序列之间提供一些重叠。此参数的值定义了重叠 token 的数量。 - pad_to_multiple_of (
int, 可选) — 如果设置，则将序列填充到提供值的倍数。这对于在计算能力>= 7.5(Volta) 的 NVIDIA 硬件上启用 Tensor Core 非常有用。 - return_tensors (
str或 TensorType, 可选) — 如果设置，将返回 tensor 而不是 python 整数列表。可接受的值为：'tf': 返回 TensorFlowtf.constant对象。'pt': 返回 PyTorchtorch.Tensor对象。'np': 返回 Numpynp.ndarray对象。
用于为一个或多个序列或一对或多对序列以及单词级标准化边界框和可选标签进行 tokenization 和模型准备的主要方法。
LayoutLMv3Processor
class transformers.LayoutLMv3Processor
< source >( image_processor = None tokenizer = None **kwargs )
参数
- image_processor (
LayoutLMv3ImageProcessor, 可选) — LayoutLMv3ImageProcessor 的实例。图像处理器是必需的输入。 - tokenizer (
LayoutLMv3Tokenizer或LayoutLMv3TokenizerFast, 可选) — LayoutLMv3Tokenizer 或 LayoutLMv3TokenizerFast 的实例。分词器是必需的输入。
构造一个 LayoutLMv3 处理器，它将 LayoutLMv3 图像处理器和 LayoutLMv3 分词器组合成一个单独的处理器。
LayoutLMv3Processor 提供了准备模型数据所需的所有功能。
它首先使用 LayoutLMv3ImageProcessor 调整大小并标准化文档图像，并可选择应用 OCR 以获取单词和标准化边界框。然后将这些提供给 LayoutLMv3Tokenizer 或 LayoutLMv3TokenizerFast，后者将单词和边界框转换为 token 级别的 input_ids、attention_mask、token_type_ids、bbox。 可选地，可以提供整数 word_labels，这些标签将转换为 token 级别的 labels，用于 token 分类任务（例如 FUNSD、CORD）。
__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 = None 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()。如果 LayoutLMv3ImageProcessor 初始化时将 apply_ocr 设置为 True，它会将获得的单词和边界框以及其他参数传递给 call() 并返回输出，以及调整大小和标准化的 pixel_values。如果 LayoutLMv3ImageProcessor 初始化时将 apply_ocr 设置为 False，它会将用户指定的单词 (text/`text_pair) 和 boxes 以及其他参数传递给 call() 并返回输出，以及调整大小和标准化的 pixel_values。
有关更多信息，请参阅上述两个方法的文档字符串。
LayoutLMv3Model
class transformers.LayoutLMv3Model
< source >( config )
参数
- config (LayoutLMv3Config) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
裸 LayoutLMv3 模型 transformer 输出原始隐藏状态，顶部没有任何特定的 head。此模型是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参阅 PyTorch 文档，了解与常规用法和行为相关的所有事项。
forward
< source >( input_ids: Optional = None bbox: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None pixel_values: 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, token_sequence_length)) — 词汇表中输入序列 token 的索引。请注意，
sequence_length = token_sequence_length + patch_sequence_length + 1，其中1代表 [CLS] token。有关patch_sequence_length，请参阅pixel_values。索引可以使用 AutoTokenizer 获得。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- bbox (
torch.LongTensor，形状为(batch_size, token_sequence_length, 4), 可选) — 每个输入序列 token 的边界框。在范围[0, config.max_2d_position_embeddings-1]中选择。每个边界框应为 (x0, y0, x1, y1) 格式的标准化版本，其中 (x0, y0) 对应于边界框中左上角的位置，(x1, y1) 表示右下角的位置。请注意，
sequence_length = token_sequence_length + patch_sequence_length + 1，其中1代表 [CLS] token。有关patch_sequence_length，请参阅pixel_values。 - pixel_values (
torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 批量文档图像。每个图像被划分为形状为(num_channels, config.patch_size, config.patch_size)的 patch，并且 patch 的总数 (=patch_sequence_length) 等于((height / config.patch_size) * (width / config.patch_size))。 - attention_mask (
torch.FloatTensor，形状为(batch_size, token_sequence_length), 可选) — 掩码，用于避免对 padding token 索引执行注意力机制。掩码值在[0, 1]中选择：- 1 代表未掩码的 token，
- 0 代表已掩码的 token。
请注意，
sequence_length = token_sequence_length + patch_sequence_length + 1，其中1代表 [CLS] token。有关patch_sequence_length，请参阅pixel_values。 - token_type_ids (
torch.LongTensor，形状为(batch_size, token_sequence_length)，可选) — 分段 token 索引，用于指示输入的第一部分和第二部分。索引从[0, 1]中选择：- 0 对应于 句子 A token，
- 1 对应于 句子 B token。
请注意，
sequence_length = token_sequence_length + patch_sequence_length + 1，其中1是指 [CLS] token。关于patch_sequence_length，请参阅pixel_values。 - position_ids (
torch.LongTensor，形状为(batch_size, token_sequence_length)，可选) — 每个输入序列 token 在位置嵌入中的位置索引。从范围[0, config.max_position_embeddings - 1]中选择。请注意，
sequence_length = token_sequence_length + patch_sequence_length + 1，其中1是指 [CLS] token。关于patch_sequence_length，请参阅pixel_values。 - head_mask (
torch.FloatTensor，形状为(num_heads,)或(num_layers, num_heads)，可选) — 用于置空自注意力模块中选定 head 的掩码。掩码值从[0, 1]中选择：- 1 表示 head 未被掩蔽，
- 0 表示 head 被掩蔽。
- inputs_embeds (
torch.FloatTensor，形状为(batch_size, token_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 时），其中包含各种元素，具体取决于配置 (LayoutLMv3Config) 和输入。
-
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 之后的注意力权重，用于计算自注意力 head 中的加权平均值。
LayoutLMv3Model forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的配方需要在该函数内定义，但应在之后调用 Module 实例，而不是调用此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。
示例
>>> from transformers import AutoProcessor, AutoModel
>>> from datasets import load_dataset
>>> processor = AutoProcessor.from_pretrained("microsoft/layoutlmv3-base", apply_ocr=False)
>>> model = AutoModel.from_pretrained("microsoft/layoutlmv3-base")
>>> dataset = load_dataset("nielsr/funsd-layoutlmv3", split="train", trust_remote_code=True)
>>> example = dataset[0]
>>> image = example["image"]
>>> words = example["tokens"]
>>> boxes = example["bboxes"]
>>> encoding = processor(image, words, boxes=boxes, return_tensors="pt")
>>> outputs = model(**encoding)
>>> last_hidden_states = outputs.last_hidden_stateLayoutLMv3ForSequenceClassification
class transformers.LayoutLMv3ForSequenceClassification
< source >( config )
参数
- config (LayoutLMv3Config) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
带有序列分类 head 的 LayoutLMv3 模型（[CLS] token 的最终隐藏状态之上的线性层），例如用于文档图像分类任务，例如 RVL-CDIP 数据集。
此模型是一个 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参阅 PyTorch 文档以了解与常规用法和行为相关的所有事项。
forward
< source >( input_ids: 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 bbox: Optional = None pixel_values: Optional = None ) → transformers.modeling_outputs.SequenceClassifierOutput 或 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) 表示右下角的位置。 - pixel_values (
torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 文档图像批次。每个图像被划分为形状为(num_channels, config.patch_size, config.patch_size)的 patch，patch 的总数 (=patch_sequence_length) 等于((height / config.patch_size) * (width / config.patch_size))。 - attention_mask (
torch.FloatTensor，形状为(batch_size, sequence_length)，可选) — 用于避免对 padding 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.max_position_embeddings - 1]中选择。 - head_mask (
torch.FloatTensor，形状为(num_heads,)或(num_layers, num_heads)，可选) — 用于置空自注意力模块中选定 head 的掩码。掩码值从[0, 1]中选择：- 1 表示 head 未被掩蔽，
- 0 表示 head 被掩蔽。
- 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, optional) — 是否返回 ModelOutput 而不是普通元组。
返回
transformers.modeling_outputs.SequenceClassifierOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.SequenceClassifierOutput 或一个 torch.FloatTensor 元组 (如果传递了 return_dict=False 或者当 config.return_dict=False 时)，包含各种元素，具体取决于配置 (LayoutLMv3Config) 和输入。
-
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 之后的注意力权重，用于计算自注意力 head 中的加权平均值。
LayoutLMv3ForSequenceClassification 的 forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的配方需要在该函数内定义，但应在之后调用 Module 实例，而不是调用此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。
示例
>>> from transformers import AutoProcessor, AutoModelForSequenceClassification
>>> from datasets import load_dataset
>>> import torch
>>> processor = AutoProcessor.from_pretrained("microsoft/layoutlmv3-base", apply_ocr=False)
>>> model = AutoModelForSequenceClassification.from_pretrained("microsoft/layoutlmv3-base")
>>> dataset = load_dataset("nielsr/funsd-layoutlmv3", split="train", trust_remote_code=True)
>>> example = dataset[0]
>>> image = example["image"]
>>> words = example["tokens"]
>>> boxes = example["bboxes"]
>>> encoding = processor(image, words, boxes=boxes, return_tensors="pt")
>>> sequence_label = torch.tensor([1])
>>> outputs = model(**encoding, labels=sequence_label)
>>> loss = outputs.loss
>>> logits = outputs.logitsLayoutLMv3ForTokenClassification
class transformers.LayoutLMv3ForTokenClassification
< source >( config )
参数
- config (LayoutLMv3Config) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
带有 Token 分类头的 LayoutLMv3 模型（最终隐藏状态之上的线性层），例如用于序列标记（信息提取）任务，如 FUNSD、 SROIE、 CORD 和 Kleister-NDA。
此模型是一个 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参阅 PyTorch 文档以了解与常规用法和行为相关的所有事项。
forward
< source >( input_ids: Optional = None bbox: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None pixel_values: 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) 表示右下角的位置。 - pixel_values (
torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 批量的文档图像。每张图像被分成形状为(num_channels, config.patch_size, config.patch_size)的补丁，补丁的总数 (=patch_sequence_length) 等于((height / config.patch_size) * (width / config.patch_size))。 - 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)，可选) — 用于计算 Token 分类损失的标签。索引应在[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 时)，包含各种元素，具体取决于配置 (LayoutLMv3Config) 和输入。
-
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 之后的注意力权重，用于计算自注意力 head 中的加权平均值。
LayoutLMv3ForTokenClassification 的 forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的配方需要在该函数内定义，但应在之后调用 Module 实例，而不是调用此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。
示例
>>> from transformers import AutoProcessor, AutoModelForTokenClassification
>>> from datasets import load_dataset
>>> processor = AutoProcessor.from_pretrained("microsoft/layoutlmv3-base", apply_ocr=False)
>>> model = AutoModelForTokenClassification.from_pretrained("microsoft/layoutlmv3-base", num_labels=7)
>>> dataset = load_dataset("nielsr/funsd-layoutlmv3", split="train", trust_remote_code=True)
>>> example = dataset[0]
>>> image = example["image"]
>>> words = example["tokens"]
>>> boxes = example["bboxes"]
>>> word_labels = example["ner_tags"]
>>> encoding = processor(image, words, boxes=boxes, word_labels=word_labels, return_tensors="pt")
>>> outputs = model(**encoding)
>>> loss = outputs.loss
>>> logits = outputs.logitsLayoutLMv3ForQuestionAnswering
class transformers.LayoutLMv3ForQuestionAnswering
< source >( config )
参数
- config (LayoutLMv3Config) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
带有跨度分类头的 LayoutLMv3 模型，用于抽取式问答任务，例如 DocVQA （在隐藏状态的文本部分之上添加一个线性层，以计算 span start logits 和 span end logits）。
此模型是一个 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参阅 PyTorch 文档以了解与常规用法和行为相关的所有事项。
forward
< source >( input_ids: 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 bbox: Optional = None pixel_values: Optional = None ) → transformers.modeling_outputs.QuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (形状为
(batch_size, sequence_length)的torch.LongTensor) — 词汇表中输入序列 tokens 的索引。可以使用 AutoTokenizer 获取索引。 请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 了解详情。
- bbox (形状为
(batch_size, sequence_length, 4)的torch.LongTensor，可选) — 每个输入序列 token 的边界框。 在范围[0, config.max_2d_position_embeddings-1]中选择。 每个边界框都应该是 (x0, y0, x1, y1) 格式的归一化版本，其中 (x0, y0) 对应于边界框中左上角的位置，而 (x1, y1) 表示右下角的位置。 - pixel_values (形状为
(batch_size, num_channels, height, width)的torch.FloatTensor) — 文档图像批次。 每个图像被分成形状为(num_channels, config.patch_size, config.patch_size)的 patches，patches 的总数 (=patch_sequence_length) 等于((height / config.patch_size) * (width / config.patch_size))。 - attention_mask (形状为
(batch_size, sequence_length)的torch.FloatTensor，可选) — 用于避免在 padding token 索引上执行 attention 的掩码。 在[0, 1]中选择的掩码值：- 1 代表 未被掩盖 的 tokens，
- 0 代表 被掩盖 的 tokens。
- token_type_ids (形状为
(batch_size, sequence_length)的torch.LongTensor，可选) — 分段 token 索引，用于指示输入的第一部分和第二部分。 索引在[0, 1]中选择：- 0 对应于 句子 A token，
- 1 对应于 句子 B token。
- position_ids (形状为
(batch_size, sequence_length)的torch.LongTensor，可选) — 每个输入序列 token 在 position embeddings 中的位置索引。 在范围[0, config.max_position_embeddings - 1]中选择。 - head_mask (形状为
(num_heads,)或(num_layers, num_heads)的torch.FloatTensor，可选) — 用于使 self-attention 模块的选定 heads 无效的掩码。 在[0, 1]中选择的掩码值：- 1 表示 head 未被掩盖，
- 0 表示 head 被掩盖。
- inputs_embeds (形状为
(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。 如果您想要比模型的内部 embedding lookup matrix 更好地控制如何将 input_ids 索引转换为关联向量，这将非常有用。 - output_attentions (
bool，可选) — 是否返回所有 attention 层的 attentions tensors。 有关更多详细信息，请参阅返回的 tensors 下的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的 hidden states。 有关更多详细信息，请参阅返回的 tensors 下的hidden_states。 - return_dict (
bool，可选) — 是否返回 ModelOutput 而不是普通 tuple。 - start_positions (形状为
(batch_size,)的torch.LongTensor，可选) — 用于计算 token 分类损失的标记跨度开始位置（索引）的标签。 位置被限制为序列的长度 (sequence_length)。 序列之外的位置不计入损失计算。 - end_positions (形状为
(batch_size,)的torch.LongTensor，可选) — 用于计算 token 分类损失的标记跨度结束位置（索引）的标签。 位置被限制为序列的长度 (sequence_length)。 序列之外的位置不计入损失计算。
返回
transformers.modeling_outputs.QuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)
transformers.modeling_outputs.QuestionAnsweringModelOutput 或 torch.FloatTensor 的 tuple (如果传递了 return_dict=False，或者当 config.return_dict=False 时)，包括各种元素，具体取决于配置 (LayoutLMv3Config) 和输入。
-
loss (形状为
(1,)的torch.FloatTensor，可选，当提供labels时返回) — 总跨度提取损失是 start 和 end 位置的交叉熵之和。 -
start_logits (形状为
(batch_size, sequence_length)的torch.FloatTensor) — 跨度开始得分（SoftMax 之前）。 -
end_logits (形状为
(batch_size, sequence_length)的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 之后的注意力权重，用于计算自注意力 head 中的加权平均值。
LayoutLMv3ForQuestionAnswering forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的配方需要在该函数内定义，但应在之后调用 Module 实例，而不是调用此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。
示例
>>> from transformers import AutoProcessor, AutoModelForQuestionAnswering
>>> from datasets import load_dataset
>>> import torch
>>> processor = AutoProcessor.from_pretrained("microsoft/layoutlmv3-base", apply_ocr=False)
>>> model = AutoModelForQuestionAnswering.from_pretrained("microsoft/layoutlmv3-base")
>>> dataset = load_dataset("nielsr/funsd-layoutlmv3", split="train", trust_remote_code=True)
>>> example = dataset[0]
>>> image = example["image"]
>>> question = "what's his name?"
>>> words = example["tokens"]
>>> boxes = example["bboxes"]
>>> encoding = processor(image, question, words, boxes=boxes, return_tensors="pt")
>>> start_positions = torch.tensor([1])
>>> end_positions = torch.tensor([3])
>>> outputs = model(**encoding, start_positions=start_positions, end_positions=end_positions)
>>> loss = outputs.loss
>>> start_scores = outputs.start_logits
>>> end_scores = outputs.end_logitsTFLayoutLMv3Model
class transformers.TFLayoutLMv3Model
< source >( config *inputs **kwargs )
参数
- config (LayoutLMv3Config) — 具有模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型关联的权重，仅加载配置。 查看 from_pretrained() 方法来加载模型权重。
裸 LayoutLMv3 模型 transformer 输出原始 hidden-states，顶部没有任何特定的 head。 此模型继承自 TFPreTrainedModel。 查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入 embeddings 大小、pruning heads 等）。
此模型也是 keras.Model 子类。 将其用作常规 TF 2.0 Keras 模型，并参考 TF 2.0 文档，了解与常规用法和行为相关的所有事项。
transformers 中的 TensorFlow 模型和 layers 接受两种格式作为输入
- 将所有输入作为关键字参数（如 PyTorch 模型），或
- 将所有输入作为第一个位置参数中的 list、tuple 或 dict。
支持第二种格式的原因是 Keras 方法在将输入传递给模型和 layers 时更喜欢这种格式。 由于这种支持，当使用 model.fit() 之类的方法时，对于您来说，事情应该“正常工作” - 只需以 model.fit() 支持的任何格式传递您的输入和标签即可！ 但是，如果您想在 Keras 方法（如 fit() 和 predict()）之外使用第二种格式，例如在使用 Keras Functional API 创建您自己的 layers 或模型时，可以使用以下三种可能性来收集第一个位置参数中的所有输入 Tensors
- 仅使用
input_ids的单个 Tensor，没有其他内容：model(input_ids) - 长度可变的 list，其中包含 docstring 中给出的顺序的一个或多个输入 Tensors：
model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids]) - dictionary，其中包含与 docstring 中给出的输入名称关联的一个或多个输入 Tensors：
model({"input_ids": input_ids, "token_type_ids": token_type_ids})
请注意，当使用 subclassing 创建模型和 layers 时，您无需担心任何这些，因为您可以像对待任何其他 Python 函数一样传递输入！
call
< source >( input_ids: tf.Tensor | None = None bbox: tf.Tensor | None = None attention_mask: tf.Tensor | None = None token_type_ids: tf.Tensor | None = None position_ids: tf.Tensor | None = None head_mask: tf.Tensor | None = None inputs_embeds: tf.Tensor | None = None pixel_values: tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: bool = False ) → transformers.modeling_tf_outputs.TFBaseModelOutput 或 tuple(tf.Tensor)
参数
- input_ids (形状为
(batch_size, sequence_length)的Numpy array或tf.Tensor) — 词汇表中输入序列 tokens 的索引。请注意，
sequence_length = token_sequence_length + patch_sequence_length + 1，其中1用于 [CLS] token。 有关patch_sequence_length，请参阅pixel_values。可以使用 AutoTokenizer 获取索引。 请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 了解详情。
- bbox (形状为
(batch_size, sequence_length, 4)的Numpy array或tf.Tensor，可选) — 每个输入序列 tokens 的边界框。 在范围[0, config.max_2d_position_embeddings-1]中选择。 每个边界框都应该是 (x0, y0, x1, y1) 格式的归一化版本，其中 (x0, y0) 对应于边界框中左上角的位置，而 (x1, y1) 表示右下角的位置。请注意，
sequence_length = token_sequence_length + patch_sequence_length + 1，其中1用于 [CLS] token。 有关patch_sequence_length，请参阅pixel_values。 - pixel_values (
tf.Tensor，形状为(batch_size, num_channels, height, width)) — 文档图像批次。每张图像被分割成形状为(num_channels, config.patch_size, config.patch_size)的图像块，图像块的总数量 (=patch_sequence_length) 等于((height / config.patch_size) * (width / config.patch_size))。 - attention_mask (
tf.Tensor，形状为(batch_size, sequence_length)，可选) — 掩码，用于避免在填充 token 索引上执行注意力机制。掩码值在[0, 1]中选择：- 1 表示 token 未被掩盖，
- 0 表示 token 已被掩盖。
请注意，
sequence_length = token_sequence_length + patch_sequence_length + 1，其中1代表 [CLS] token。关于patch_sequence_length，请参阅pixel_values。 - token_type_ids (
Numpy array或tf.Tensor，形状为(batch_size, sequence_length)，可选) — 分段 token 索引，用于指示输入的第一部分和第二部分。索引在[0, 1]中选择：- 0 对应于 句子 A token，
- 1 对应于 句子 B token。
请注意，
sequence_length = token_sequence_length + patch_sequence_length + 1，其中1代表 [CLS] token。关于patch_sequence_length，请参阅pixel_values。 - position_ids (
Numpy array或tf.Tensor，形状为(batch_size, sequence_length)，可选) — 每个输入序列 token 在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。请注意，
sequence_length = token_sequence_length + patch_sequence_length + 1，其中1代表 [CLS] token。关于patch_sequence_length，请参阅pixel_values。 - head_mask (
tf.Tensor，形状为(num_heads,)或(num_layers, num_heads)，可选) — 掩码，用于使自注意力模块的选定 head 失效。掩码值在[0, 1]中选择：- 1 表示 head 未被掩盖，
- 0 表示 head 已被掩盖。
- inputs_embeds (
tf.Tensor，形状为(batch_size, sequence_length, hidden_size)，可选) — （可选）您可以选择直接传递嵌入表示，而不是传递input_ids。如果您希望更好地控制如何将 input_ids 索引转换为关联的向量，而不是模型的内部嵌入查找矩阵，这将非常有用。 - output_attentions (
bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。 - return_dict (
bool，可选) — 是否返回 ModelOutput 而不是普通元组。
返回
transformers.modeling_tf_outputs.TFBaseModelOutput 或 tuple(tf.Tensor)
一个 transformers.modeling_tf_outputs.TFBaseModelOutput 或一个 tf.Tensor 元组（如果传递了 return_dict=False，或者当 config.return_dict=False 时），其中包含取决于配置 (LayoutLMv3Config) 和输入的各种元素。
-
last_hidden_state (
tf.Tensor，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层的输出处的隐藏状态序列。 -
hidden_states (
tuple(tf.FloatTensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —tf.Tensor元组（embeddings 的输出一个，每层的输出一个），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出以及初始 embedding 输出处的隐藏状态。
-
attentions (
tuple(tf.Tensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回) —tf.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力 head 中的加权平均值。
TFLayoutLMv3Model 前向方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的配方需要在该函数内定义，但应在之后调用 Module 实例，而不是调用此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。
示例
>>> from transformers import AutoProcessor, TFAutoModel
>>> from datasets import load_dataset
>>> processor = AutoProcessor.from_pretrained("microsoft/layoutlmv3-base", apply_ocr=False)
>>> model = TFAutoModel.from_pretrained("microsoft/layoutlmv3-base")
>>> dataset = load_dataset("nielsr/funsd-layoutlmv3", split="train", trust_remote_code=True)
>>> example = dataset[0]
>>> image = example["image"]
>>> words = example["tokens"]
>>> boxes = example["bboxes"]
>>> encoding = processor(image, words, boxes=boxes, return_tensors="tf")
>>> outputs = model(**encoding)
>>> last_hidden_states = outputs.last_hidden_stateTFLayoutLMv3ForSequenceClassification
class transformers.TFLayoutLMv3ForSequenceClassification
< source >( config: LayoutLMv3Config **kwargs )
参数
- config (LayoutLMv3Config) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
带有序列分类 head 的 LayoutLMv3 模型（[CLS] token 的最终隐藏状态之上的线性层），例如用于文档图像分类任务，例如 RVL-CDIP 数据集。
此模型继承自 TFPreTrainedModel。查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入 embeddings 大小、剪枝 head 等）。
此模型也是 keras.Model 子类。 将其用作常规 TF 2.0 Keras 模型，并参考 TF 2.0 文档，了解与常规用法和行为相关的所有事项。
transformers 中的 TensorFlow 模型和 layers 接受两种格式作为输入
- 将所有输入作为关键字参数（如 PyTorch 模型），或
- 将所有输入作为第一个位置参数中的 list、tuple 或 dict。
支持第二种格式的原因是 Keras 方法在将输入传递给模型和 layers 时更喜欢这种格式。 由于这种支持，当使用 model.fit() 之类的方法时，对于您来说，事情应该“正常工作” - 只需以 model.fit() 支持的任何格式传递您的输入和标签即可！ 但是，如果您想在 Keras 方法（如 fit() 和 predict()）之外使用第二种格式，例如在使用 Keras Functional API 创建您自己的 layers 或模型时，可以使用以下三种可能性来收集第一个位置参数中的所有输入 Tensors
- 仅使用
input_ids的单个 Tensor，没有其他内容：model(input_ids) - 长度可变的 list，其中包含 docstring 中给出的顺序的一个或多个输入 Tensors：
model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids]) - dictionary，其中包含与 docstring 中给出的输入名称关联的一个或多个输入 Tensors：
model({"input_ids": input_ids, "token_type_ids": token_type_ids})
请注意，当使用 subclassing 创建模型和 layers 时，您无需担心任何这些，因为您可以像对待任何其他 Python 函数一样传递输入！
call
< source >( input_ids: tf.Tensor | None = None attention_mask: tf.Tensor | None = None token_type_ids: tf.Tensor | None = None position_ids: tf.Tensor | None = None head_mask: tf.Tensor | None = None inputs_embeds: tf.Tensor | None = None labels: tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None bbox: tf.Tensor | None = None pixel_values: tf.Tensor | None = None training: Optional[bool] = False ) → transformers.modeling_tf_outputs.TFSequenceClassifierOutput 或 tuple(tf.Tensor)
参数
- input_ids (
Numpy array或tf.Tensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列 token 的索引。请注意，
sequence_length = token_sequence_length + patch_sequence_length + 1，其中1代表 [CLS] token。关于patch_sequence_length，请参阅pixel_values。索引可以使用 AutoTokenizer 获得。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- bbox (
Numpy array或tf.Tensor，形状为(batch_size, sequence_length, 4)，可选) — 每个输入序列 token 的边界框。在范围[0, config.max_2d_position_embeddings-1]中选择。每个边界框应为 (x0, y0, x1, y1) 格式的归一化版本，其中 (x0, y0) 对应于边界框中左上角的位置，而 (x1, y1) 表示右下角的位置。请注意，
sequence_length = token_sequence_length + patch_sequence_length + 1，其中1代表 [CLS] token。关于patch_sequence_length，请参阅pixel_values。 - pixel_values (
tf.Tensor，形状为(batch_size, num_channels, height, width)) — 文档图像批次。每张图像被分割成形状为(num_channels, config.patch_size, config.patch_size)的图像块，图像块的总数量 (=patch_sequence_length) 等于((height / config.patch_size) * (width / config.patch_size))。 - attention_mask (
tf.Tensor，形状为(batch_size, sequence_length)，可选) — 掩码，用于避免在填充 token 索引上执行注意力机制。掩码值在[0, 1]中选择：- 1 表示 token 未被掩盖，
- 0 表示 token 已被掩盖。
请注意，
sequence_length = token_sequence_length + patch_sequence_length + 1，其中1代表 [CLS] token。关于patch_sequence_length，请参阅pixel_values。 - token_type_ids (
Numpy array或tf.Tensor，形状为(batch_size, sequence_length)，可选) — 分段 token 索引，用于指示输入的第一部分和第二部分。索引在[0, 1]中选择：- 0 对应于 句子 A token，
- 1 对应于 句子 B token。
请注意，
sequence_length = token_sequence_length + patch_sequence_length + 1，其中1代表 [CLS] token。关于patch_sequence_length，请参阅pixel_values。 - position_ids (
Numpy array或tf.Tensor，形状为(batch_size, sequence_length)，可选) — 每个输入序列 token 在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。请注意，
sequence_length = token_sequence_length + patch_sequence_length + 1，其中1代表 [CLS] token。关于patch_sequence_length，请参阅pixel_values。 - head_mask (
tf.Tensor，形状为(num_heads,)或(num_layers, num_heads)，可选) — 掩码，用于使自注意力模块的选定 head 失效。掩码值在[0, 1]中选择：- 1 表示 head 未被掩盖，
- 0 表示 head 已被掩盖。
- inputs_embeds (
tf.Tensor，形状为(batch_size, sequence_length, hidden_size)，可选) — （可选）您可以选择直接传递嵌入表示，而不是传递input_ids。如果您希望更好地控制如何将 input_ids 索引转换为关联的向量，而不是模型的内部嵌入查找矩阵，这将非常有用。 - output_attentions (
bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。 - return_dict (
bool，可选) — 是否返回 ModelOutput 而不是普通元组。
返回
transformers.modeling_tf_outputs.TFSequenceClassifierOutput 或 tuple(tf.Tensor)
一个 transformers.modeling_tf_outputs.TFSequenceClassifierOutput 或一个 tf.Tensor 元组（如果传递了 return_dict=False，或者当 config.return_dict=False 时），其中包含取决于配置 (LayoutLMv3Config) 和输入的各种元素。
-
loss (
tf.Tensor，形状为(batch_size, )，可选，当提供labels时返回) — 分类（如果 config.num_labels==1，则为回归）损失。 -
logits (
tf.Tensor，形状为(batch_size, config.num_labels)) — 分类（如果 config.num_labels==1，则为回归）得分（在 SoftMax 之前）。 -
hidden_states (
tuple(tf.Tensor)，可选，当传入output_hidden_states=True或config.output_hidden_states=True时返回) —tf.Tensor的元组（每个元素对应于嵌入层的输出 + 每个层的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出以及初始 embedding 输出处的隐藏状态。
-
attentions (
tuple(tf.Tensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回) —tf.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力 head 中的加权平均值。
TFLayoutLMv3ForSequenceClassification 的 forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的配方需要在该函数内定义，但应在之后调用 Module 实例，而不是调用此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。
示例
>>> from transformers import AutoProcessor, TFAutoModelForSequenceClassification
>>> from datasets import load_dataset
>>> import tensorflow as tf
>>> processor = AutoProcessor.from_pretrained("microsoft/layoutlmv3-base", apply_ocr=False)
>>> model = TFAutoModelForSequenceClassification.from_pretrained("microsoft/layoutlmv3-base")
>>> dataset = load_dataset("nielsr/funsd-layoutlmv3", split="train", trust_remote_code=True)
>>> example = dataset[0]
>>> image = example["image"]
>>> words = example["tokens"]
>>> boxes = example["bboxes"]
>>> encoding = processor(image, words, boxes=boxes, return_tensors="tf")
>>> sequence_label = tf.convert_to_tensor([1])
>>> outputs = model(**encoding, labels=sequence_label)
>>> loss = outputs.loss
>>> logits = outputs.logitsTFLayoutLMv3ForTokenClassification
class transformers.TFLayoutLMv3ForTokenClassification
< source >( config: LayoutLMv3Config **kwargs )
参数
- config (LayoutLMv3Config) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。查看 from_pretrained() 方法加载模型权重。
带有 Token 分类头的 LayoutLMv3 模型（最终隐藏状态之上的线性层），例如用于序列标记（信息提取）任务，如 FUNSD、 SROIE、 CORD 和 Kleister-NDA。
此模型继承自 TFPreTrainedModel。查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入 embeddings 大小、剪枝 head 等）。
此模型也是 keras.Model 子类。 将其用作常规 TF 2.0 Keras 模型，并参考 TF 2.0 文档，了解与常规用法和行为相关的所有事项。
transformers 中的 TensorFlow 模型和 layers 接受两种格式作为输入
- 将所有输入作为关键字参数（如 PyTorch 模型），或
- 将所有输入作为第一个位置参数中的 list、tuple 或 dict。
支持第二种格式的原因是 Keras 方法在将输入传递给模型和 layers 时更喜欢这种格式。 由于这种支持，当使用 model.fit() 之类的方法时，对于您来说，事情应该“正常工作” - 只需以 model.fit() 支持的任何格式传递您的输入和标签即可！ 但是，如果您想在 Keras 方法（如 fit() 和 predict()）之外使用第二种格式，例如在使用 Keras Functional API 创建您自己的 layers 或模型时，可以使用以下三种可能性来收集第一个位置参数中的所有输入 Tensors
- 仅使用
input_ids的单个 Tensor，没有其他内容：model(input_ids) - 长度可变的 list，其中包含 docstring 中给出的顺序的一个或多个输入 Tensors：
model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids]) - dictionary，其中包含与 docstring 中给出的输入名称关联的一个或多个输入 Tensors：
model({"input_ids": input_ids, "token_type_ids": token_type_ids})
请注意，当使用 subclassing 创建模型和 layers 时，您无需担心任何这些，因为您可以像对待任何其他 Python 函数一样传递输入！
call
< source >( input_ids: tf.Tensor | None = None bbox: tf.Tensor | None = None attention_mask: tf.Tensor | None = None token_type_ids: tf.Tensor | None = None position_ids: tf.Tensor | None = None head_mask: tf.Tensor | None = None inputs_embeds: tf.Tensor | None = None labels: tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None pixel_values: tf.Tensor | None = None training: Optional[bool] = False ) → transformers.modeling_tf_outputs.TFTokenClassifierOutput 或 tuple(tf.Tensor)
参数
- input_ids (
Numpy array或tf.Tensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。请注意，
sequence_length = token_sequence_length + patch_sequence_length + 1，其中1代表 [CLS] token。有关patch_sequence_length，请参阅pixel_values。索引可以使用 AutoTokenizer 获取。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- bbox (
Numpy array或tf.Tensor，形状为(batch_size, sequence_length, 4)，可选) — 每个输入序列 tokens 的边界框。在范围[0, config.max_2d_position_embeddings-1]中选择。每个边界框应为 (x0, y0, x1, y1) 格式的归一化版本，其中 (x0, y0) 对应于边界框中左上角的位置，而 (x1, y1) 表示右下角的位置。请注意，
sequence_length = token_sequence_length + patch_sequence_length + 1，其中1代表 [CLS] token。有关patch_sequence_length，请参阅pixel_values。 - pixel_values (
tf.Tensor，形状为(batch_size, num_channels, height, width)) — 批量文档图像。每个图像被分成形状为(num_channels, config.patch_size, config.patch_size)的 patches，并且 patches 的总数（=patch_sequence_length）等于((height / config.patch_size) * (width / config.patch_size))。 - attention_mask (
tf.Tensor，形状为(batch_size, sequence_length)，可选) — 用于避免在 padding token 索引上执行 attention 的掩码。掩码值在[0, 1]中选择：- 1 表示 tokens 未被掩盖，
- 0 表示 tokens 被掩盖。
请注意，
sequence_length = token_sequence_length + patch_sequence_length + 1，其中1代表 [CLS] token。有关patch_sequence_length，请参阅pixel_values。 - token_type_ids (
Numpy array或tf.Tensor，形状为(batch_size, sequence_length)，可选) — 用于指示输入的第一部分和第二部分的片段 token 索引。索引在[0, 1]中选择：- 0 对应于 句子 A token，
- 1 对应于 句子 B token。
请注意，
sequence_length = token_sequence_length + patch_sequence_length + 1，其中1代表 [CLS] token。有关patch_sequence_length，请参阅pixel_values。 - position_ids (
Numpy array或tf.Tensor，形状为(batch_size, sequence_length)，可选) — 位置嵌入中每个输入序列 tokens 的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。请注意，
sequence_length = token_sequence_length + patch_sequence_length + 1，其中1代表 [CLS] token。有关patch_sequence_length，请参阅pixel_values。 - head_mask (
tf.Tensor，形状为(num_heads,)或(num_layers, num_heads)，可选) — 用于使 self-attention 模块的选定 head 失效的掩码。掩码值在[0, 1]中选择：- 1 表示 head 未被掩盖，
- 0 表示 head 被掩盖。
- inputs_embeds (
tf.Tensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将 input_ids 索引转换为关联的向量，这将非常有用。 - output_attentions (
bool，可选) — 是否返回所有 attention 层的 attentions tensors。 有关更多详细信息，请参见返回 tensors 下的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的 hidden states。 有关更多详细信息，请参见返回 tensors 下的hidden_states。 - return_dict (
bool，可选) — 是否返回 ModelOutput 而不是普通的元组。 - labels (
tf.Tensor，形状为(batch_size, sequence_length)，可选) — 用于计算 token 分类损失的标签。索引应在[0, ..., config.num_labels - 1]中。
返回
transformers.modeling_tf_outputs.TFTokenClassifierOutput 或 tuple(tf.Tensor)
一个 transformers.modeling_tf_outputs.TFTokenClassifierOutput 或 tf.Tensor 的元组（如果传入 return_dict=False 或当 config.return_dict=False 时），包含各种元素，具体取决于配置 (LayoutLMv3Config) 和输入。
-
loss (
tf.Tensor，形状为(n,)，可选，其中 n 是未掩盖标签的数量，当提供labels时返回) — 分类损失。 -
logits (
tf.Tensor，形状为(batch_size, sequence_length, config.num_labels)) — 分类得分（在 SoftMax 之前）。 -
hidden_states (
tuple(tf.Tensor)，可选，当传入output_hidden_states=True或config.output_hidden_states=True时返回) —tf.Tensor的元组（每个元素对应于嵌入层的输出 + 每个层的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出以及初始 embedding 输出处的隐藏状态。
-
attentions (
tuple(tf.Tensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回) —tf.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力 head 中的加权平均值。
TFLayoutLMv3ForTokenClassification 的 forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的配方需要在该函数内定义，但应在之后调用 Module 实例，而不是调用此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。
示例
>>> from transformers import AutoProcessor, TFAutoModelForTokenClassification
>>> from datasets import load_dataset
>>> processor = AutoProcessor.from_pretrained("microsoft/layoutlmv3-base", apply_ocr=False)
>>> model = TFAutoModelForTokenClassification.from_pretrained("microsoft/layoutlmv3-base", num_labels=7)
>>> dataset = load_dataset("nielsr/funsd-layoutlmv3", split="train", trust_remote_code=True)
>>> example = dataset[0]
>>> image = example["image"]
>>> words = example["tokens"]
>>> boxes = example["bboxes"]
>>> word_labels = example["ner_tags"]
>>> encoding = processor(image, words, boxes=boxes, word_labels=word_labels, return_tensors="tf")
>>> outputs = model(**encoding)
>>> loss = outputs.loss
>>> logits = outputs.logitsTFLayoutLMv3ForQuestionAnswering
class transformers.TFLayoutLMv3ForQuestionAnswering
< source >( config: LayoutLMv3Config **kwargs )
参数
- config (LayoutLMv3Config) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。查看 from_pretrained() 方法加载模型权重。
带有跨度分类头的 LayoutLMv3 模型，用于抽取式问答任务，例如 DocVQA （在隐藏状态的文本部分之上添加一个线性层，以计算 span start logits 和 span end logits）。
此模型继承自 TFPreTrainedModel。查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入 embeddings 大小、剪枝 head 等）。
此模型也是 keras.Model 子类。 将其用作常规 TF 2.0 Keras 模型，并参考 TF 2.0 文档，了解与常规用法和行为相关的所有事项。
transformers 中的 TensorFlow 模型和 layers 接受两种格式作为输入
- 将所有输入作为关键字参数（如 PyTorch 模型），或
- 将所有输入作为第一个位置参数中的 list、tuple 或 dict。
支持第二种格式的原因是 Keras 方法在将输入传递给模型和 layers 时更喜欢这种格式。 由于这种支持，当使用 model.fit() 之类的方法时，对于您来说，事情应该“正常工作” - 只需以 model.fit() 支持的任何格式传递您的输入和标签即可！ 但是，如果您想在 Keras 方法（如 fit() 和 predict()）之外使用第二种格式，例如在使用 Keras Functional API 创建您自己的 layers 或模型时，可以使用以下三种可能性来收集第一个位置参数中的所有输入 Tensors
- 仅使用
input_ids的单个 Tensor，没有其他内容：model(input_ids) - 长度可变的 list，其中包含 docstring 中给出的顺序的一个或多个输入 Tensors：
model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids]) - dictionary，其中包含与 docstring 中给出的输入名称关联的一个或多个输入 Tensors：
model({"input_ids": input_ids, "token_type_ids": token_type_ids})
请注意，当使用 subclassing 创建模型和 layers 时，您无需担心任何这些，因为您可以像对待任何其他 Python 函数一样传递输入！
call
< source >( input_ids: tf.Tensor | None = None attention_mask: tf.Tensor | None = None token_type_ids: tf.Tensor | None = None position_ids: tf.Tensor | None = None head_mask: tf.Tensor | None = None inputs_embeds: tf.Tensor | None = None start_positions: tf.Tensor | None = None end_positions: tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None bbox: tf.Tensor | None = None pixel_values: tf.Tensor | None = None return_dict: Optional[bool] = None training: bool = False ) → transformers.modeling_tf_outputs.TFQuestionAnsweringModelOutput 或 tuple(tf.Tensor)
参数
- input_ids (
Numpy array或tf.Tensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。请注意，
sequence_length = token_sequence_length + patch_sequence_length + 1，其中1代表 [CLS] token。关于patch_sequence_length，请参阅pixel_values。索引可以使用 AutoTokenizer 获得。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- bbox (
Numpy array或tf.Tensor，形状为(batch_size, sequence_length, 4), 可选) — 每个输入序列 token 的边界框。在范围[0, config.max_2d_position_embeddings-1]中选择。每个边界框都应该是 (x0, y0, x1, y1) 格式的标准化版本，其中 (x0, y0) 对应于边界框中左上角的位置，而 (x1, y1) 表示右下角的位置。请注意，
sequence_length = token_sequence_length + patch_sequence_length + 1，其中1代表 [CLS] token。关于patch_sequence_length，请参阅pixel_values。 - pixel_values (
tf.Tensor，形状为(batch_size, num_channels, height, width)) — 文档图像的批次。每张图像被划分为形状为(num_channels, config.patch_size, config.patch_size)的 patches，patches 的总数 (=patch_sequence_length) 等于((height / config.patch_size) * (width / config.patch_size))。 - attention_mask (
tf.Tensor，形状为(batch_size, sequence_length), 可选) — 用于避免在 padding token 索引上执行 attention 的 Mask。Mask 值在[0, 1]中选择：- 1 表示 tokens 未被 masking，
- 0 表示 tokens 已被 masking。
请注意，
sequence_length = token_sequence_length + patch_sequence_length + 1，其中1代表 [CLS] token。关于patch_sequence_length，请参阅pixel_values。 - token_type_ids (
Numpy array或tf.Tensor，形状为(batch_size, sequence_length), 可选) — Segment token 索引，用于指示输入的第一个和第二个部分。索引在[0, 1]中选择：- 0 对应于 sentence A token，
- 1 对应于 sentence B token。
请注意，
sequence_length = token_sequence_length + patch_sequence_length + 1，其中1代表 [CLS] token。关于patch_sequence_length，请参阅pixel_values。 - position_ids (
Numpy array或tf.Tensor，形状为(batch_size, sequence_length), 可选) — 位置嵌入中每个输入序列 token 的位置索引。在[0, config.max_position_embeddings - 1]范围内选择。请注意，
sequence_length = token_sequence_length + patch_sequence_length + 1，其中1代表 [CLS] token。关于patch_sequence_length，请参阅pixel_values。 - head_mask (
tf.Tensor，形状为(num_heads,)或(num_layers, num_heads), 可选) — 用于 nullify self-attention 模块中选定 heads 的 Mask。Mask 值在[0, 1]中选择：- 1 表示 head 未被 masking，
- 0 表示 head 已被 masking。
- inputs_embeds (
tf.Tensor，形状为(batch_size, sequence_length, hidden_size), 可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将 input_ids 索引转换为关联的向量，这将非常有用。 - output_attentions (
bool, 可选) — 是否返回所有 attention 层的 attentions tensors。有关更多详细信息，请参阅返回 tensors 下的attentions。 - output_hidden_states (
bool, 可选) — 是否返回所有层的 hidden states。有关更多详细信息，请参阅返回 tensors 下的hidden_states。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通的 tuple。 - start_positions (
tf.Tensor，形状为(batch_size,), 可选) — 用于计算 token 分类损失的已标记 span 起始位置（索引）的标签。位置被限制在序列的长度 (sequence_length) 之内。序列之外的位置不计入损失计算。 - end_positions (
tf.Tensor，形状为(batch_size,), 可选) — 用于计算 token 分类损失的已标记 span 结束位置（索引）的标签。位置被限制在序列的长度 (sequence_length) 之内。序列之外的位置不计入损失计算。
返回
transformers.modeling_tf_outputs.TFQuestionAnsweringModelOutput 或 tuple(tf.Tensor)
一个 transformers.modeling_tf_outputs.TFQuestionAnsweringModelOutput 或 tf.Tensor 的 tuple（如果传递了 return_dict=False 或当 config.return_dict=False 时），其中包含各种元素，具体取决于配置 (LayoutLMv3Config) 和输入。
-
loss (
tf.Tensor，形状为(batch_size, ), 可选, 当提供start_positions和end_positions时返回) — 总 span 提取损失是 start 和 end 位置的 Cross-Entropy 之和。 -
start_logits (
tf.Tensor，形状为(batch_size, sequence_length)) — Span-start 分数（SoftMax 之前）。 -
end_logits (
tf.Tensor，形状为(batch_size, sequence_length)) — Span-end 分数（SoftMax 之前）。 -
hidden_states (
tuple(tf.Tensor)，可选，当传入output_hidden_states=True或config.output_hidden_states=True时返回) —tf.Tensor的元组（每个元素对应于嵌入层的输出 + 每个层的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出以及初始 embedding 输出处的隐藏状态。
-
attentions (
tuple(tf.Tensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回) —tf.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力 head 中的加权平均值。
TFLayoutLMv3ForQuestionAnswering forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的配方需要在该函数内定义，但应在之后调用 Module 实例，而不是调用此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。
示例
>>> from transformers import AutoProcessor, TFAutoModelForQuestionAnswering
>>> from datasets import load_dataset
>>> import tensorflow as tf
>>> processor = AutoProcessor.from_pretrained("microsoft/layoutlmv3-base", apply_ocr=False)
>>> model = TFAutoModelForQuestionAnswering.from_pretrained("microsoft/layoutlmv3-base")
>>> dataset = load_dataset("nielsr/funsd-layoutlmv3", split="train", trust_remote_code=True)
>>> example = dataset[0]
>>> image = example["image"]
>>> question = "what's his name?"
>>> words = example["tokens"]
>>> boxes = example["bboxes"]
>>> encoding = processor(image, question, words, boxes=boxes, return_tensors="tf")
>>> start_positions = tf.convert_to_tensor([1])
>>> end_positions = tf.convert_to_tensor([3])
>>> outputs = model(**encoding, start_positions=start_positions, end_positions=end_positions)
>>> loss = outputs.loss
>>> start_scores = outputs.start_logits
>>> end_scores = outputs.end_logits