Transformers 文档

LayoutLMv3

Hugging Face's logo
加入Hugging Face社区

并获取增强文档体验

开始使用

LayoutLMv3

概述

LayoutLMv3模型由Yupan Huang、Tengchao Lv、Lei Cui、Yutong Lu、Furu Wei在LayoutLMv3: 使用统一的文本和图像掩码进行文档AI预训练一文中提出。LayoutLMv3通过使用补丁嵌入(类似于ViT)而不是利用CNN主干来简化LayoutLMv2,并在3个目标上进行预训练:掩码语言建模(MLM)、掩码图像建模(MIM)和单词-补丁对齐(WPA)。

论文摘要如下

自监督预训练技术在文档人工智能领域取得了显著进步。大多数多模态预训练模型使用掩码语言模型目标在文本模态上学习双向表示,但在图像模态的预训练目标上有所不同。这种差异增加了多模态表示学习的难度。在这篇论文中,我们提出了LayoutLMv3,用于以统一的文本和图像掩码对文档人工智能的多模态Transformer进行预训练。此外,LayoutLMv3还通过预测文本单词的相应图像块是否被掩码来学习跨模态对齐,从而使用单词块对齐目标进行预训练。该简单的统一架构和训练目标使LayoutLMv3成为文本中心和图像中心的文档人工智能任务的通用预训练模型。实验结果表明,LayoutLMv3不仅在其文本中心的任务中(如表格理解、收据理解和文档视觉问答)表现出色,而且在图像中心的任务(如文档图像分类和文档布局分析)中也表现出卓越的能力。

drawing LayoutLMv3架构。图源原文

此模型由nielsr提供。此模型的TensorFlow版本由chriskootokeclre添加。原始代码可在此处找到。

使用技巧

  • 在数据处理的方面,LayoutLMv3与其前辈LayoutLMv2相同,除了
    • 需要将图像调整大小并使用RGB格式中的通道进行归一化。而另一方面,LayoutLMv2内部归一化图像,并期望通道以BGR格式。
    • 使用字节对编码(BPE)对文本进行标记,而不是WordPiece。由于这些数据预处理的差异,可以使用LayoutLMv3Processor,该Processor内部结合了一个LayoutLMv3ImageProcessor(用于图像模态)和一个LayoutLMv3Tokenizer/LayoutLMv3TokenizerFast(用于文本模态),以便为模型准备所有数据。
  • 关于LayoutLMv3Processor的使用,我们参考了其前辈使用指南

资源

提供了一份官方的Hugging Face和社区(用🌎表示)资源列表,帮助你开始LayoutLMv3的使用。如果你有兴趣提交资源以便加入到此处,请随时开源拉取请求,我们将审阅它!资源理想情况下应展示新的东西,而不是重复现有的资源。

LayoutLMv3几乎与LayoutLMv2相同,因此我们还包括您可以为LayoutLMv3任务调整的LayoutLMv2资源。对于这些笔记本,在准备模型数据时,请注意使用LayoutLMv2Processor

  • LayoutLMv3的演示笔记本可以在这里找到。
  • 演示脚本可以在这里找到。
文本分类
标记分类
问答

文档问答

LayoutLMv3Config

transformers.LayoutLMv3Config

< >

( 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 可以表示的不同令牌的数量。
  • hidden_sizeint,可选,默认为 768)— 编码层和池化层的维度。
  • num_hidden_layersint,可选,默认为 12)— Transformer 编码器中的隐藏层数量。
  • num_attention_headsint,可选,默认为 12)— Transformer 编码器每个注意力层中的注意力头数量。
  • intermediate_sizeint,可选,默认为 3072)— Transformer 编码器中“中间层”(也即前馈层)的维度。
  • hidden_act (strfunction可选,默认为 "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) — 所有权重矩阵初始化的截断正态初始化器的标准差。
  • 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_biasbool可选,默认为 True)— 是否在自注意力机制中使用相对注意力偏置。
  • rel_pos_binsint可选,默认为 32)— 自注意力机制中使用的相对位置桶的数量。
  • max_rel_posint可选,默认为 128)— 自注意力机制中使用的最大相对位置数。
  • max_rel_2d_posint可选,默认为 256)— 自注意力机制中使用的最大二维相对位置数。
  • rel_2d_pos_bins (int, 可选,默认为 64) — 自注意力机制中 2D 相对位置bins 的数量。
  • has_spatial_attention_bias (bool, 可选,默认为 True) — 是否在自注意力机制中使用空间注意力偏差。
  • visual_embed (bool, 可选,默认为 True) — 是否添加 patch 嵌入。
  • input_size (int, 可选,默认为 224) — 图片的大小(分辨率)。
  • num_channels (int, 可选, 默认 3) — 图像的通道数。
  • patch_size (int, 可选, 默认 16) — 片段的大小(分辨率)。
  • classifier_dropout (float, 可选) — 分类头的dropout比例。

这是用于存储LayoutLMv3模型配置的配置类。它用于根据指定的参数实例化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.config

LayoutLMv3FeatureExtractor

transformers.LayoutLMv3FeatureExtractor

< >

( *args **kwargs )

__call__

< >

( images **kwargs )

预处理图像或图像批处理。

LayoutLMv3ImageProcessor

transformers.LayoutLMv3ImageProcessor

< >

( do_resize: bool = Truesize: Dict = Noneresample: Resampling = <Resampling.BILINEAR: 2>do_rescale: bool = Truerescale_value: float = 0.00392156862745098do_normalize: bool = Trueimage_mean: Union = Noneimage_std: Union = Noneapply_ocr: bool = Trueocr_lang: Optional = Nonetesseract_config: Optional = ''**kwargs )

参数

  • do_resize (bool, 可选, 默认为 True) — 是否调整图像的宽高尺寸为 (size["height"], size["width"])。可以被 preprocess 中的 do_resize 覆盖。
  • size (Dict[str, int] 可选, 默认为 {"height" -- 224, "width": 224}): 调整大小后的图像尺寸。可以被 preprocess 中的 size 覆盖。
  • resample (PILImageResampling, 可选, 默认为 PILImageResampling.BILINEAR) — 在调整图像大小时使用的重采样过滤器。可以被 preprocess 中的 resample 覆盖。
  • do_rescale (bool, 可选,默认为 True) — 是否按指定 rescale_value 重新缩放图像的像素值。可以被 preprocess 中的 do_rescale 覆盖。
  • rescale_factor (float, 可选,默认为 1 / 255) — 重新缩放图像像素值的系数。可以被 preprocess 中的 rescale_factor 覆盖。
  • do_normalize (bool, 可选,默认为 True) — 是否对图像进行归一化。可以被 preprocess 方法中的 do_normalize 参数覆盖。
  • image_mean(《可变迭代浮点数` 或 `浮点数`, 可选,默认为 `IMAGENET_STANDARD_MEAN`)——用于图像归一化的均值。这是一个与图像通道数量相同长度的浮点数或浮点数列表。可以在`preprocess`方法的`image_mean`参数中覆盖。
  • image_std(《可变迭代浮点数` 或 `浮点数`, 可选,默认为 `IMAGENET_STANDARD_STD`)——用于图像归一化的标准差。这是一个与图像通道数量相同长度的浮点数或浮点数列表。可以在`preprocess`方法的`image_std`参数中覆盖。
  • apply_ocr(《布尔型`, 可选,默认为 `True`)——是否将Tesseract OCR引挚应用于获取文字和归一化边界框。可以在`preprocess`方法的`apply_ocr`参数中覆盖。
  • ocr_lang (str, 可选) — 使用Tesseract OCR引擎的指定ISO代码的语言。默认情况下,使用英语。可以由preprocess方法中的ocr_lang参数覆盖。
  • tesseract_config (str, 可选) — 在调用Tesseract时转发到config参数的任何其他自定义配置标志。例如:'—psm 6'。可以由preprocess方法中的tesseract_config参数覆盖。

构建LayoutLMv3图像处理器。

preprocess

< >

( images: 联集 do_resize: 布尔类型 = None size: 字典 = None resample: None do_rescale: 布尔类型 = None rescale_factor: 浮点数 = None do_normalize: 布尔类型 = None image_mean: 联集 = None image_std: 联集 = None apply_ocr: 布尔类型 = None ocr_lang: 可选 = None tesseract_config: 可选 = None return_tensors: 联集 = None data_format: 通道维度 = <ChannelDimension.FIRST: 'channels_first'> input_data_format: 联集 = None )

参数

  • images (ImageInput) — 待预处理图像。期望单个或多批图像,像素值范围为0到255。如果传入像素值在0到1之间的图像,请设置do_rescale=False
  • do_resize (bool, 可选,默认为 self.do_resize) — 是否调整图像大小。
  • size (Dict[str, int], 可选,默认为 self.size) — 应用 resize 后所需的输出图像大小。
  • resample (int, 可选,默认为 self.resample) — 如果调整图像大小,则使用的重采样过滤器。这可以是 PILImageResampling 过滤器之一。仅在 do_resize 设置为 True 时才有作用。
  • do_rescale (bool, 可选,默认为 self.do_rescale) — 是否将图像像素值重缩放到 [0, 1] 范围内。
  • rescale_factor (float, 可选,默认为 self.rescale_factor) — 适用于图像像素值的缩放因子。仅在将 do_rescale 设置为 True 时才生效。
  • do_normalize (bool, 可选,默认为 self.do_normalize) — 是否对图像进行归一化。
  • image_mean (floatIterable[float], 可选,默认为 self.image_mean) — 用于归一化的平均值。仅在将 do_normalize 设置为 True 时才生效。
  • image_std (floatIterable[float]可选,默认为 self.image_std) — 用于归一化的标准差值。只有在 do_normalize 设置为 True 时才有效。
  • apply_ocr (bool可选,默认为 self.apply_ocr) — 是否应用 Tesseract OCR 引擎以获取文字 + 光标框。
  • ocr_lang (str可选,默认为 self.ocr_lang) — Tesseract OCR 引擎使用的语言,由其 ISO 代码指定。默认使用英语。
  • tesseract_config (str, 可选) — 当调用 Tesseract 时,转发给 config 参数的任何附加自定义配置标志。
  • return_tensors (strTensorType, 可选) — 返回张量的类型。可以是以下之一:
    • 未设置:返回 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 (ChannelDimensionstr, 可选) — 输出图像的通道维度格式。可以是以下之一:
    • ChannelDimension.FIRST:图像格式为 (num_channels, height, width)。
    • ChannelDimension.LAST:图像格式为 (height, width, num_channels)。
  • input_data_format (ChannelDimensionstr, 可选) —— 输入图像的通道维度格式。如果未设置,通道维度格式将从输入图像中推断。可以是以下之一:

预处理图像或图像批次。

LayoutLMv3Tokenizer

transformers.LayoutLMv3Tokenizer

< >

( 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) — 词汇文件路径。
  • 合并文件 (str) — 合并文件的路径。
  • 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, 可选, 默认为 True) — 是否在输入的开始处添加一个初始空格。这允许将首单词视为其他任意单词。 (RoBERTa 分词器通过前一个空格检测单词的开始)。
  • 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 标记化器。基于 RoBERTaTokenizer (字节对编码或 BPE)。使用 LayoutLMv3Tokenizer 可以将词、词级边界框和可选的词标签转换为标记级的 input_idsattention_masktoken_type_idsbbox 和可选的 labels(用于标记分类)。

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

LayoutLMv3Tokenizer 进行端到端的标记化:标点分割和词部分分割。它还将词级边界框转换为标记级边界框。

__call__

< >

( text: 联合 text_pair: 联合 = None boxes: 联合 = None word_labels: 联合 = None add_special_tokens: bool = True padding: 联合 = False truncation: 联合 = None max_length: Optional = None stride: int = 0 pad_to_multiple_of: Optional = None return_tensors: 联合 = 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 (str列表, str列表列表) — 要编码的序列或序列批。每个序列都应该是一个字符串列表(预处理字符串)。
  • boxes (int列表列表, int列表列表列表) — 字词级别边界框。每个边界框应归一化到0-1000的尺度。
  • word_labels (int列表, int列表列表, 可选) — 字词级别的整数标签(用于如图FUNSD、CORD的标记分类任务)。
  • add_special_tokens (bool, 可选, 默认值为 True) — 是否使用特殊标记编码序列相对于其模型。
  • padding (bool, strPaddingStrategy, 可选,默认为 False) — 启用并控制填充。接受以下值:

    • True'longest':填充到批次中最长的序列(如果只提供了一个序列,则不需要填充)。
    • 'max_length':填充到与 max_length 参数指定的最大长度或模型可接受的最大输入长度。
    • False'do_not_pad'(默认):不进行填充(即,可以输出具有不同长度的序列的批次)。
  • truncation (bool, strTruncationStrategy, 可选,默认为 False) — 启用并控制截断。接受以下值:

    • True'longest_first':截断到与 max_length 参数指定的最大长度或模型可接受的最大输入长度。这将按顺序截断,如果提供了序列对(或一对序列的批次),则从最长的序列中去除一个标记。
    • 'only_first':截断到与 max_length 参数指定的最大长度或模型可接受的最大输入长度。如果提供了序列对(或一对序列的批次),则仅截断第一个序列。
    • 'only_second':截断到与 max_length 参数指定的最大长度或模型可接受的最大输入长度。如果提供了序列对(或一对序列的批次),则仅截断第二个序列。
    • False'do_not_truncate'(默认):不截断(即,可以输出序列长度大于模型最大可接受输入大小的批次)。
  • max_length (int, 可选) —通过截断/填充参数之一来控制使用的最大长度。

    如果未设置或设置为None,则在截断/填充参数需要最大长度的情况下,将使用预定义的模型最大长度。如果模型没有特定的最大输入长度(如XLNet),则将禁用截断/填充到最大长度。

  • stride (int, 可选,默认为0) —如果与max_length一起设置数字,当return_overflowing_tokens=True时返回的溢出标记将包含截断序列末尾的一些标记,从而在截断序列和溢出序列之间提供一些重叠。此参数的值定义了重叠标记的数量。
  • pad_to_multiple_of (int, 可选) —如果设置,则将序列填充到提供值的倍数。这对于在具有>= 7.5(Volta)计算功能的NVIDIA硬件上使用Tensor Core特别有用。
  • return_tensors (strTensorType可选)—如果设置,将返回张量而非Python整数的列表。接受值包括:
  • add_special_tokens (bool, 可选, 默认值为 True) — 是否使用特殊标记编码序列相对于其模型。
  • padding (bool, strPaddingStrategy, 可选,默认为 False) — 启用并控制填充。接受以下值:

    • True'longest':填充到批次中最长的序列(如果只提供了一个序列,则不需要填充)。
    • 'max_length':填充到与 max_length 参数指定的最大长度或模型可接受的最大输入长度。
    • False'do_not_pad'(默认):不进行填充(即,可以输出具有不同长度的序列的批次)。
  • truncation (bool, strTruncationStrategy, 可选,默认为 False) — 启用并控制截断。接受以下值:

    • True'longest_first':截断到与 max_length 参数指定的最大长度或模型可接受的最大输入长度。这将按顺序截断,如果提供了序列对(或一对序列的批次),则从最长的序列中去除一个标记。
    • 'only_first':截断到与 max_length 参数指定的最大长度或模型可接受的最大输入长度。如果提供了序列对(或一对序列的批次),则仅截断第一个序列。
    • 'only_second':截断到与 max_length 参数指定的最大长度或模型可接受的最大输入长度。如果提供了序列对(或一对序列的批次),则仅截断第二个序列。
    • False'do_not_truncate'(默认):不截断(即,可以输出序列长度大于模型最大可接受输入大小的批次)。
  • max_lengthint可选)—通过截断/填充参数之一控制使用的最大长度。如果未设置或设置为None,在截断/填充参数需要最大长度的情况下,将使用预定义模型的最大长度。如果模型没有特定的最大输入长度(如XLNet),将不激活截断/填充到最大长度。
  • stride (int, 可选,默认为0) —如果与max_length一起设置数字,当return_overflowing_tokens=True时返回的溢出标记将包含截断序列末尾的一些标记,从而在截断序列和溢出序列之间提供一些重叠。此参数的值定义了重叠标记的数量。
  • pad_to_multiple_of (int, 可选) —如果设置,则将序列填充到提供值的倍数。这对于在具有>= 7.5(Volta)计算功能的NVIDIA硬件上使用Tensor Core特别有用。
  • return_tensors (strTensorType可选)—如果设置,将返回张量而非Python整数的列表。接受值包括:

主方法,用于对模型进行标记和准备一个或多个序列(或一对或多个带有单词级规范化边缘框和可选标签的序列)。

保存词汇表

< >

( save_directory: str filename_prefix: Optional = None )

LayoutLMv3TokenizerFast

transformers.LayoutLMv3TokenizerFast

< >

( 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) — 合并文件的路径
  • errors (str, 可选, 默认值为 "replace") — 解码字节为UTF-8时遵循的范式。更多信息请参阅 bytes.decode
  • bos_token (str, 可选, 默认值为 "<s>") — 预训练期间使用的序列开始标记。可以用作序列分类标记。
  • eos_token (str, 可选,默认为 "</s>") — 序列结束标记。

    当使用特殊标记构建序列时,此标记不是用于序列结尾的标记。使用的标记是 sep_token

  • sep_token (str, 可选,默认为 "</s>") — 分隔符标记,用于从多个序列构建序列时,例如用于序列分类的两个序列或用于问答的文字和问题。它也被用作使用特殊标记构建的序列的最后一个标记。
  • cls_token (str, 可选,默认为 "<s>") — 当进行序列分类(整个序列的分类而不是每个标记的分类)时使用的分类器标记。当使用特殊标记构建序列时,它是序列的第一个标记。
  • unk_token (str, 可选, 默认为 "<unk>") — 未知token。不在词汇表中的token无法转换为ID并将被设置为该token。
  • pad_token (str, 可选, 默认为 "<pad>") — 填充token,例如在将不同长度的序列批处理时使用。
  • mask_token (str, 可选, 默认为 "<mask>") — 用于遮蔽值的token。这是在用遮蔽语言学习模型训练这个模型时使用的token。这是模型尝试预测的token。
  • 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__

< >

( text: 联合 text_pair: 联合 = None boxes: 联合 = None word_labels: 联合 = None add_special_tokens: bool = True padding: 联合 = False truncation: 联合 = None max_length: Optional = None stride: int = 0 pad_to_multiple_of: Optional = None return_tensors: 联合 = 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, strPaddingStrategy, 可选, 默认为 False) — 激活和控制填充。接受以下值:

    • True'longest':填充到批次中长度最长的序列(或者如果没有提供单序列则无填充)。
    • 'max_length':填充到由参数 max_length 指定的最大长度,或如果没有提供该参数,则填充到模型的最大可接受输入长度。
    • False'do_not_pad'(默认):不填充(即可以输出具有不同长度的序列的批次)。
  • 截断boolstr截断策略,可选,默认为 False)——访问并控制截断功能。接受以下值:

    • True'longest_first':根据参数 max_length 指定的最大长度进行截断或在没有提供该参数的情况下截断模型可接受的最大输入长度。如果提供了语句对(或语句对的批次),则将按顺序逐个截断标记,当出现语句对时,从最长的序列中移除一个标记。
    • 'only_first':根据参数 max_length 指定的最大长度进行截断或在没有提供该参数的情况下截断模型可接受的最大输入长度。如果提供了语句对(或语句对的批次),则只截断第一个序列。
    • 'only_second':根据参数 max_length 指定的最大长度进行截断或在没有提供该参数的情况下截断模型可接受的最大输入长度。如果提供了语句对(或语句对的批次),则只截断第二个序列。
    • False'do_not_truncate'(默认):不截断(即可能输出批量序列长度大于模型最大可接受输入大小的序列)。
  • 最大长度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 (strTensorType, 可选) — 如果设置,则返回张量而不是Python整数列表。可接受值有:

    • 'tf': 返回 TensorFlow tf.constant 对象。
    • 'pt': 返回 PyTorch torch.Tensor 对象。
    • 'np': 返回 Numpy np.ndarray 对象。
  • add_special_tokens (bool, 可选, 默认为 True) — 是否使用与模型相关的特殊标记对序列进行编码。
  • padding (bool, strPaddingStrategy, 可选, 默认为 False) — 激活和控制填充。接受以下值:

    • True'longest':填充到批次中长度最长的序列(或者如果没有提供单序列则无填充)。
    • 'max_length':填充到由参数 max_length 指定的最大长度,或如果没有提供该参数,则填充到模型的最大可接受输入长度。
    • False'do_not_pad'(默认):不填充(即可以输出具有不同长度的序列的批次)。
  • 截断boolstr截断策略,可选,默认为 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 (strTensorType, 可选) — 如果设置,则返回张量而不是Python整数列表。可接受值有:

    • 'tf': 返回 TensorFlow tf.constant 对象。
    • 'pt': 返回 PyTorch torch.Tensor 对象。
    • 'np': 返回 Numpy np.ndarray 对象。

主方法,用于对模型进行标记和准备一个或多个序列(或一对或多个带有单词级规范化边缘框和可选标签的序列)。

LayoutLMv3Processor

transformers.LayoutLMv3Processor

< >

( image_processor = None tokenizer = None **kwargs )

参数

构建一个 LayoutLMv3 处理器,将 LayoutLMv3 图像处理器和 LayoutLMv3 分词器结合成一个单一处理器。

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

它首先使用 LayoutLMv3ImageProcessor 来调整文档图像的大小并进行标准化,并可选地应用 OCR 以获取单词和标准化边框。然后将这些提供给 LayoutLMv3TokenizerLayoutLMv3TokenizerFast,这些将单词和边框转换为标记级别的 input_idsattention_masktoken_type_idsbbox。可选地,可以提供一个整数 word_labels,它将转换为标记级别的 labels,用于标记分类任务(如 FUNSD、CORD)。

__call__

< >

( images text: 联集 = 无 text_pair: 联集 = 无 boxes: 联集 = 无 word_labels: 联集 = 无 add_special_tokens: 布尔 = True padding: 联集 = False truncation: 联集 = 无 max_length: 可选 = 无 stride: int = 0 pad_to_multiple_of: 可选 = 无 return_token_type_ids: 可选 = 无 return_attention_mask: 可选 = 无 return_overflowing_tokens: 布尔 = False return_special_tokens_mask: 布尔 = False return_offsets_mapping: 布尔 = False return_length: 布尔 = False verbose: 布尔 = True return_tensors: 联集 = 无 **kwargs )

该方法首先将 images 参数转发到 call()。如果 LayoutLMv3ImageProcessor 初始化时将 apply_ocr 设置为 True,则它会将获得到的文字和边界框以及附加参数传递给 call(),并返回输出,同时还有调整大小和归一化的 pixel_values。如果 LayoutLMv3ImageProcessor 初始化时将 apply_ocr 设置为 False,则它会将用户指定的文字(text/`text_pair)和 boxes 以及附加参数传递给 call(),并返回输出,同时还有调整大小和归一化的 pixel_values

请参阅上述两个方法的说明字符串以获取更多信息。

Pytorch
隐藏 Pytorch 内容

LayoutLMv3Model

transformers.LayoutLMv3Model

< >

( config )

参数

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

一个裸露的 LayoutLMv3 模型transformer,输出原始隐藏状态,没有顶部的任何特定头部。此模型是 PyTorch torch.nn.Module 的子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档,了解所有与通用使用和行为相关的内容。

前向

< >

( 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 or tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor of shape (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()

    什么是输入ID?

  • bbox (torch.LongTensor of shape (batch_size, token_sequence_length, 4), 可选) — 每个输入序列token的边界框。在 [0, config.max_2d_position_embeddings-1] 范围内选择。每个边界框应该是 (x0, y0, x1, y1) 格式的归一化版本,其中 (x0, y0) 对应于边界框左上角的位置,而 (x1, y1) 表示边界框右下角的位置。

    请注意,《code>sequence_length = token_sequence_length + patch_sequence_length + 1 其中 1 为 [CLS] token。有关 patch_sequence_length 请参阅 pixel_values

  • pixel_valuestorch.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_masktorch.FloatTensor 数据类型,形状为 (batch_size, token_sequence_length)可选)— 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在 [0, 1]

    • 1 代表 未掩码 的标记,
    • 0 代表 掩码 的标记。

    注意,sequence_length = token_sequence_length + patch_sequence_length + 1,其中 1 是 [CLS] 标记。见 pixel_valuespatch_sequence_length

    什么是注意力掩码?

  • token_type_ids (\(torch.LongTensor\) 形状为 \((batch\_size, token\_sequence\_length)\),可选) — 段落标记索引,用于指示输入的第一部分和第二部分。索引选自 [0, 1]

    • 0 对应于 句子 A 标记,
    • 1 对应于 句子 B 标记。

    注意,\(sequence\_length = token\_sequence\_length + patch\_sequence\_length + 1\) 其中 1 是 [CLS] 标记。有关 patch\_sequence\_length,请参阅 pixel_values

    什么是标记类型 ID?

  • position_ids (\(torch.LongTensor\) 形状为 \((batch\_size, token\_sequence\_length)\),可选) — 每个输入序列标记在位置嵌入中的索引。选择在 [0, config.max\_position\_embeddings \- 1] 范围内。

    注意,\(sequence\_length = token\_sequence\_length + patch\_sequence\_length + 1\) 其中 1 是 [CLS] 标记。有关 patch\_sequence\_length,请参阅 pixel_values

    什么是位置 ID?

  • head\_mask (\(torch.FloatTensor\) 形状为 \((num\_heads,) 或 \((num\_layers, num\_heads)\),可选) — 用于取消选择自注意力模块选中头的掩码。掩码值选择在 [0, 1]

    • 1 表示头 未被掩码
    • 0 表示头被 掩码
  • 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.BaseModelOutputtuple(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的元组(如果模型有嵌入层,则为嵌入层输出的单个torch.FloatTensor和每个层输出的单个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之后,使用了这些权重计算自注意力头的加权平均值。

LayoutLMv3Model的forward方法覆盖了__call__特殊方法。

尽管向前推进的食谱需要在这个函数内定义,但应该调用该函数之后的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_state

LayoutLMv3ForSequenceClassification

class transformers.LayoutLMv3ForSequenceClassification

< >

( config )

参数

  • config (LayoutLMv3Config) — 模型配置类,包含所有模型参数。使用配置文件初始化模型不会加载与模型关联的权重,只会加载配置。请参考 from_pretrained() 方法来加载模型权重。

顶带序列分类头(在[CLS]标记的最后一个隐藏状态之上的线性层)的LayoutLMv3模型,例如用于文档图像分类任务,如RVL-CDIP数据集。

此模型是PyTorch torch.nn.Module子类。将其用作常规PyTorch模块,并参考PyTorch文档了解有关通用使用和行为的所有相关事项。

前向

< >

( input_ids:可选 = None attention_mask:可选 = None token_type_ids:可选 = None position_ids:可选 = None head_mask:可选 = None inputs_embeds:可选 = None labels:可选 = None output_attentions:可选 = None output_hidden_states:可选 = None return_dict:可选 = None bbox:可选 = None pixel_values:可选 = None ) transformers.modeling_outputs.SequenceClassifierOutputtuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 词汇中输入序列标记的索引。

    索引可以通过 AutoTokenizer 获取。请参阅 PreTrainedTokenizer.encode()PreTrainedTokenizer.call() 了解详情。

    什么是输入ID?

  • bboxtorch.LongTensor 形状 (batch_size, sequence_length, 4)可选) — 每个输入序列标记的边界框。在范围 [0, config.max_2d_position_embeddings-1] 中选择。每个边界框应该是格式为 (x0, y0, x1, y1) 的归一化版本,其中 (x0, y0) 对应于边界框右上角的位置,而 (x1, y1) 表示边界框左下角的位置。
  • pixel_valuestorch.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_masktorch.FloatTensor 形状 (batch_size, sequence_length)可选) — 避免在填充标记索引上执行注意力的掩码。掩码值在 [0, 1] 之间选择:

    • 1 对未掩码的标记,
    • 0 对掩码的标记。

    什么是注意掩码?

  • token_type_ids (torch.LongTensor of shape (batch_size, sequence_length), 可选) — 用于指示输入的两部分的段标记索引。索引选自 [0, 1]
    • 0 对应于 句子 A 标记;
    • 1 对应于 句子 B 标记。
    什么是标记类型 ID?
  • position_ids (torch.LongTensor of shape (batch_size, sequence_length), 可选) — 每个输入序列标记在位置嵌入中的索引。选择范围在 [0, config.max_position_embeddings - 1]什么是位置 ID?
  • head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), 可选) — 用于取消自注意力模块中选中头的掩码。掩码值选择在 [0, 1]
    • 1 表示头未被掩码;
    • 0 表示头被掩码。
  • inputs_embedstorch.FloatTensor 形状为 (batch_size, sequence_length, hidden_size)可选)—— 可以直接传递嵌入表示而不是 input_ids,这样在将 input_ids 的索引转换为相关向量时,可以比模型内部的嵌入查找矩阵有更多的控制。
  • output_attentionsbool可选)—— 是否返回所有注意力层的注意力张量。更多详细信息请参阅返回张量下的 attentions
  • output_hidden_statesbool可选)—— 是否返回所有层的隐藏状态。更多详细信息请参阅返回张量下的 hidden_states
  • return_dict (bool, optional) — 是否返回一个ModelOutput 而不是普通的元组。

返回值

transformers.modeling_outputs.SequenceClassifierOutputtuple(torch.FloatTensor)

transformers.modeling_outputs.SequenceClassifierOutput 或一个包含各种元素torch.FloatTensor 元组(如果 return_dict=False 被传递或当 config.return_dict=False 时),这些元素取决于配置(LayoutLMv3Config)和输入。

  • loss (torch.FloatTensor 形状 (1,)optional,在提供 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的元组(如果模型有嵌入层,则为嵌入层输出的单个torch.FloatTensor和每个层输出的单个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之后,使用了这些权重计算自注意力头的加权平均值。

LayoutLMv3ForSequenceClassification 前向方法,重载了 __call__ 特殊方法。

尽管向前推进的食谱需要在这个函数内定义,但应该调用该函数之后的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.logits

LayoutLMv3ForTokenClassification

transformers.LayoutLMv3ForTokenClassification

< >

( config )

参数

  • config (LayoutLMv3Config) — 模型参数类的配置,使用配置文件初始化不会加载模型相关的权重,只会加载配置。请检查from_pretrained()方法来加载模型权重。

在LayoutLMv3模型顶部添加token分类头(最终隐藏状态的线性层),例如用于序列标记(信息提取)的任务,如FUNSDSROIECORDKleister-NDA

此模型是PyTorch torch.nn.Module子类。将其用作常规PyTorch模块,并参考PyTorch文档了解有关通用使用和行为的所有相关事项。

前向

< >

( input_ids: 可选 = None bbox: 可选 = None attention_mask: 可选 = None token_type_ids: 可选 = None position_ids: 可选 = None head_mask: 可选 = None inputs_embeds: 可选 = None labels: 可选 = None output_attentions: 可选 = None output_hidden_states: 可选 = None return_dict: 可选 = None pixel_values: 可选 = None ) transformers.modeling_outputs.TokenClassifierOutputtuple(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] 范围内选择:

  • token_type_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 段落标记索引,以指示输入的第一和第二部分。索引选择在 [0, 1]:《p>
  • 0 对应于 句子 A 标记,
  • 1 对应于 句子 B 标记。
《p>什么是标记类型 ID?
  • position_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 每个输入序列标记在位置嵌入中的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。

    什么是位置 ID?

  • head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 将取消选择自注意力模块中选定的头部的掩码。在 [0, 1] 中选择的掩码值:

    • 1 表示头部 未掩码
    • 0 表示头部 已掩码
  • inputs_embeds (torch.FloatTensor 形状为 (batch_size, sequence_length, hidden_size)可选) — 可选地,您可以直接传递嵌入表示而不是 input_ids。如果您想要比模型内部嵌入查找矩阵更多的控制来将 input_ids 索引转换为相关向量,这将非常有用。
  • output_attentions (bool可选) — 是否返回所有注意力层的注意力张量。有关更多细节,请参阅返回张量下的 attentions
  • output_hidden_states (bool可选) — 是否返回所有层的隐藏状态。有关更多细节,请参阅返回张量下的 hidden_states
  • return_dict (bool可选) — 是否返回 ModelOutput 而不是普通的元组。
  • labels (torch.LongTensor 形状为 (batch_size, sequence_length)可选) — 用于计算标记分类损失的标签。索引应该在 [0, ..., config.num_labels - 1] 之间。
  • 返回值

    transformers.modeling_outputs.TokenClassifierOutputtuple(torch.FloatTensor)

    A transformers.modeling_outputs.TokenClassifierOutput 或一个 torch.FloatTensor 的元组(如果传递了 return_dict=False 或当 config.return_dict=False 时),包含的元素取决于配置(LayoutLMv3Config)和输入。

    • losstorch.FloatTensor 形状为 (1,)可选,当提供 labels 时返回) — 分类损失。

    • logitstorch.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的元组(如果模型有嵌入层,则为嵌入层输出的单个torch.FloatTensor和每个层输出的单个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之后,使用了这些权重计算自注意力头的加权平均值。

    LayoutLMv3ForTokenClassification 的 forward 方法,重写了 __call__ 特殊方法。

    尽管向前推进的食谱需要在这个函数内定义,但应该调用该函数之后的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.logits

    LayoutLMv3ForQuestionAnswering

    transformers.LayoutLMv3ForQuestionAnswering

    < >

    ( config )

    参数

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

    带有跨度分类头的LayoutLMv3模型,用于类似DocVQA的抽取式问答任务(在隐藏状态的文本部分顶部添加一个线性层,以计算跨度起始logits跨度结束logits)。

    此模型是PyTorch torch.nn.Module子类。将其用作常规PyTorch模块,并参考PyTorch文档了解有关通用使用和行为的所有相关事项。

    前向

    < >

    ( input_ids : 可选 = Noneattention_mask : 可选 = Nonetoken_type_ids : 可选 = Noneposition_ids : 可选 = Nonehead_mask : 可选 = Noneinputs_embeds : 可选 = Nonestart_positions : 可选 = Noneend_positions : 可选 = Noneoutput_attentions : 可选 = Noneoutput_hidden_states : 可选 = Nonereturn_dict : 可选 = Nonebbox : 可选 = Nonepixel_values : 可选 = None ) transformers.modeling_outputs.QuestionAnsweringModelOutputtuple(torch.FloatTensor)

    参数

    • input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 输入序列标记的索引,位于词汇表中。

      索引可以通过 AutoTokenizer 获取。有关详细信息,请参阅 PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

      什么是输入ID?

    • bbox (torch.LongTensor 形状 (batch_size, sequence_length, 4)可选) — 每个输入序列标记的边界框。选择范围为 [0, config.max_2d_position_embeddings-1]。每个边界框应采用 (x0, y0, x1, y1) 格式的归一化版本,其中 (x0, y0) 对应于边界框左上角的位置,(x1, y1) 表示边界框右下角的位置。
    • 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 of shape (batch_size, sequence_length), optional) — 段落标记索引以指示输入的前后部分。索引选择在 [0, 1] 范围内:

      • 0 对应于 句子 A 标记,
      • 1 对应于 句子 B 标记。

      什么是标记类型 ID?

    • position_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 在位置嵌入中的每个输入序列标记的位置索引。选择在 [0, config.max_position_embeddings - 1] 范围内。

      什么是位置 ID?

    • head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 针对自注意力模块中选择的首选头部进行屏蔽的掩码。掩码值选择在 [0, 1] 范围内:

      • 1 表示头部 未屏蔽
      • 0 表示头部 屏蔽
    • inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), 可选) — 可选地,您可以选择直接传递嵌入表示,而不是传递 input_ids。如果在将 input_ids 索引转换为相关向量方面需要比模型内部的嵌入查找矩阵更多的控制,则此操作很有用。
    • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关返回张量中的 attentions 的更多详细信息,请参阅。
    • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关返回张量中的 hidden_states 的更多详细信息,请参阅。
    • return_dict (bool, 可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。
    • start_positions (torch.LongTensor 形状为 (batch_size,), 可选) — 用于计算标记跨度(索引)开始的标记分类损失的标签。位置被缩放至序列长度(sequence_length)。序列外部的位置在计算损失时不予考虑。
    • end_positions (torch.LongTensor 形状为 (batch_size,), 可选) — 用于计算标记跨度(索引)结束的标记分类损失的标签。位置被缩放至序列长度(sequence_length)。序列外部的位置在计算损失时不予考虑。

    返回值

    transformers.modeling_outputs.QuestionAnsweringModelOutputtuple(torch.FloatTensor)

    一个 transformers.modeling_outputs.QuestionAnsweringModelOutput 或一个torch.FloatTensor的元组(如果传递了 return_dict=False 或当 config.return_dict=False)并包含各种根据配置(LayoutLMv3Config)和输入的不同元素。

    • loss (torch.FloatTensor 形状为 (1,), 可选, 在提供了 labels 时返回) — 总跨度提取损失是开始和结束位置的交叉熵之和。

    • start_logits (形状为 (batch_size, sequence_length)torch.FloatTensor)- Span起始分数(在SoftMax之前)。

    • end_logits (形状为 (batch_size, sequence_length)torch.FloatTensor)- Span结束分数(在SoftMax之前)。

    • hidden_states (tuple(torch.FloatTensor)可选,当传递参数output_hidden_states=True或当config.output_hidden_states=True时返回) — 包含每个层输出的torch.FloatTensor的元组(如果模型有嵌入层,则为嵌入层输出的单个torch.FloatTensor和每个层输出的单个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之后,使用了这些权重计算自注意力头的加权平均值。

    LayoutLMv3ForQuestionAnswering 的 forward 方法,重写了 __call__ 特殊方法。

    尽管向前推进的食谱需要在这个函数内定义,但应该调用该函数之后的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_logits
    TensorFlow
    隐藏TensorFlow内容

    TFLayoutLMv3Model

    class transformers.TFLayoutLMv3Model

    < >

    ( config *inputs **kwargs )

    参数

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

    一个裸的 LayoutLMv3 模型转换器,输出原始隐藏状态,没有顶部的任何特定头。此模型继承自 TFPreTrainedModel。请查看超类文档,其中包含库为所有模型(例如下载或保存、调整输入嵌入、修剪头部等)实现的通用方法。

    此模型也是 keras.Model 的子类。将其作为常规 TF 2.0 Keras 模型使用,并参考 TF 2.0 文档中的所有关于通用使用和行为的相关事项。

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

    • 所有输入作为关键字参数(如 PyTorch 模型),或
    • 所有输入作为第一个位置参数中的列表、元组或字典。

    支持第二种格式的原因是 Keras 方法更倾向于这种格式将输入传递给模型和层。因此,使用像 model.fit() 这样的方法时,事情应该“正常工作”——只需以 model.fit() 支持的任何格式传递您的输入和标签!但是,如果您想在没有像 fit()predict() 这样的 Keras 方法的情况下使用第二种格式,例如在创建自己的层或使用 Keras Functional API 的模型时,有以下三种你可以用来收集第一个位置参数中所有输入张量的方法

    • 仅包含 input_ids 的单个张量:model(input_ids)
    • 一个长度可变的列表,其中包含按文档字符串中给出的顺序排列的一个或多个输入张量:model([input_ids, attention_mask])model([input_ids, attention_mask, token_type_ids])
    • 一个字典,其中包含一个或多个与文档字符串中给出的输入名称关联的输入张量:model({"input_ids": input_ids, "token_type_ids": token_type_ids})

    请注意,在通过 子类化 创建模型和层时,您不需要担心任何这些问题,因为您可以像传递任何其他 Python 函数输入一样传递输入!

    调用

    < >

    ( 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.TFBaseModelOutputtuple(tf.Tensor)

    参数

    • input_ids (tf.Tensor 形状为 (batch_size, sequence_length)) — 输入序列标记在词汇表中的索引。

      注意,sequence_length = token_sequence_length + patch_sequence_length + 1 其中 1 是用于 [CLS] 标记的。参见 pixel_values 了解 patch_sequence_length

      索引可以使用 AutoTokenizer 获取。有关详细信息,请参阅 PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

      什么是输入 ID?

    • bbox (Numpy 数组tf.Tensor 形状为 (batch_size, sequence_length, 4)可选) — 每个输入序列标记的边界框。在 [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] 标记的。参见 pixel_values 了解 patch_sequence_length

    • 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 arraytf.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

      什么是token类型ID? 查看更多

    • position_ids (Numpy arraytf.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

      什么是位置ID? 查看更多

    • head_mask (形状为 (num_heads,(num_layers, num_heads)tf.Tensor,可选) —— 用于取消选定自注意力模块的头部选择的掩码。在 [0, 1] 中选择掩码值:

      • 1 表示头部未被 掩码
      • 0 表示头部被 掩码
    • inputs_embeds (形状为 (batch_size, sequence_length, hidden_size)tf.Tensor,可选) —— 可选,您可以选择直接传递嵌入表示而非传递 input_ids。如果您希望比模型内部的嵌入查找矩阵有更多的控制权来转换 input_ids 索引到相关向量,这很有用。
    • output_attentions (布尔值,可选) —— 是否返回所有注意力层的注意力张量。有关更详细的信息,请参阅返回张量中的 attentions
    • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关返回张量中 hidden_states 的更多信息,请参见。
    • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。

    返回值

    transformers.modeling_tf_outputs.TFBaseModelOutputtuple(tf.Tensor)

    transformers.modeling_tf_outputs.TFBaseModelOutputtf.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 的元组(一个用于词嵌入输出,一个用于每个层的输出)的形状为 (batch_size, sequence_length, hidden_size)

      各个层输出和初始嵌入输出的隐藏状态。

    • attentions (tuple(tf.Tensor)可选,传递 output_attentions=True 时返回,或当 config.output_attentions=True) — 每个层的 tf.Tensor 元组(形状为 (batch_size, num_heads, sequence_length, sequence_length))。

      在注意力softmax之后,使用了这些权重计算自注意力头的加权平均值。

    TFLayoutLMv3Model 的前向方法重写了特殊方法 __call__

    尽管向前推进的食谱需要在这个函数内定义,但应该调用该函数之后的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_state

    TFLayoutLMv3ForSequenceClassification

    transformers.TFLayoutLMv3ForSequenceClassification

    < >

    ( config: LayoutLMv3Config **kwargs )

    参数

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

    顶带序列分类头(在[CLS]标记的最后一个隐藏状态之上的线性层)的LayoutLMv3模型,例如用于文档图像分类任务,如RVL-CDIP数据集。

    该模型继承自 TFPreTrainedModel。检查基类的文档,了解库为所有模型实现的通用方法(例如下载或保存、调整输入嵌入的大小、剪枝头部等。)

    此模型也是 keras.Model 的子类。将其作为常规 TF 2.0 Keras 模型使用,并参考 TF 2.0 文档中的所有关于通用使用和行为的相关事项。

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

    • 所有输入作为关键字参数(如 PyTorch 模型),或
    • 所有输入作为第一个位置参数中的列表、元组或字典。

    支持第二种格式的原因是 Keras 方法更倾向于这种格式将输入传递给模型和层。因此,使用像 model.fit() 这样的方法时,事情应该“正常工作”——只需以 model.fit() 支持的任何格式传递您的输入和标签!但是,如果您想在没有像 fit()predict() 这样的 Keras 方法的情况下使用第二种格式,例如在创建自己的层或使用 Keras Functional API 的模型时,有以下三种你可以用来收集第一个位置参数中所有输入张量的方法

    • 仅包含 input_ids 的单个张量:model(input_ids)
    • 一个长度可变的列表,其中包含按文档字符串中给出的顺序排列的一个或多个输入张量:model([input_ids, attention_mask])model([input_ids, attention_mask, token_type_ids])
    • 一个字典,其中包含一个或多个与文档字符串中给出的输入名称关联的输入张量:model({"input_ids": input_ids, "token_type_ids": token_type_ids})

    请注意,在通过 子类化 创建模型和层时,您不需要担心任何这些问题,因为您可以像传递任何其他 Python 函数输入一样传递输入!

    调用

    < >

    ( 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.TFSequenceClassifierOutputtuple(tf.Tensor)

    参数

    • input_ids (NumPy数组tf.Tensor,形状为 (batch_size, sequence_length) ) — 输入序列词汇中的标记索引。

      注意,sequence_length = token_sequence_length + patch_sequence_length + 1,其中1是[CLS]标记。见pixel_values以了解patch_sequence_length

      索引可以通过使用 AutoTokenizer 获取。有关详细信息,请参阅 PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

      什么是输入ID?

    • bbox (NumPy数组tf.Tensor,形状为 (batch_size, sequence_length, 4)可选 ) — 每个输入序列标记的边界框。在 [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]标记。见 pixel_values 以了解 patch_sequence_length

    • 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)可选)— 用于避免对填充标记索引执行注意力的掩码。掩码值选择在 [0, 1]

      • 1 对 未掩码 的标记;
      • 0 对 掩码 的标记。

      注意 sequence_length = token_sequence_length + patch_sequence_length + 1,其中 1 是 [CLS] 标记。请参阅 pixel_values 中的 patch_sequence_length

      什么是注意力掩码?

    • token_type_idsNumpy 数组tf.Tensor,形状为 (batch_size, sequence_length)可选)— 指示输入的第一和第二部分的段标记索引。索引选择在 [0, 1] 范围内:

      • 0 对应于 句子 A 标记,
      • 1 对应于 句子 B 标记。

      注意 sequence_length = token_sequence_length + patch_sequence_length + 1,其中 1 是 [CLS] 标记。关于 patch_sequence_length,请参阅 pixel_values

      什么是标记类型 ID?

    • position_idsNumpy 数组tf.Tensor,形状为 (batch_size, sequence_length)可选)— 每个输入序列标记在位置嵌入中的位置索引。选择在 [0, config.max_position_embeddings - 1] 范围内。

      注意 sequence_length = token_sequence_length + patch_sequence_length + 1,其中 1 是 [CLS] 标记。关于 patch_sequence_length,请参阅 pixel_values

      什么是位置 ID?

    • 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.TFSequenceClassifierOutputtuple(tf.Tensor)

    一个transformers.modeling_tf_outputs.TFSequenceClassifierOutputtf.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)

      各个层输出和初始嵌入输出的隐藏状态。

    • attentions (tuple(tf.Tensor)可选,传递 output_attentions=True 时返回,或当 config.output_attentions=True) — 每个层的 tf.Tensor 元组(形状为 (batch_size, num_heads, sequence_length, sequence_length))。

      在注意力softmax之后,使用了这些权重计算自注意力头的加权平均值。

    TFLayoutLMv3ForSequenceClassification前向方法,重写了__call__特殊方法。

    尽管向前推进的食谱需要在这个函数内定义,但应该调用该函数之后的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.logits

    TFLayoutLMv3ForTokenClassification

    类名 transformers.TFLayoutLMv3ForTokenClassification

    < >

    ( config: LayoutLMv3Config **kwargs )

    参数

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

    在LayoutLMv3模型顶部添加token分类头(最终隐藏状态的线性层),例如用于序列标记(信息提取)的任务,如FUNSDSROIECORDKleister-NDA

    该模型继承自 TFPreTrainedModel。检查基类的文档,了解库为所有模型实现的通用方法(例如下载或保存、调整输入嵌入的大小、剪枝头部等。)

    此模型也是 keras.Model 的子类。将其作为常规 TF 2.0 Keras 模型使用,并参考 TF 2.0 文档中的所有关于通用使用和行为的相关事项。

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

    • 所有输入作为关键字参数(如 PyTorch 模型),或
    • 所有输入作为第一个位置参数中的列表、元组或字典。

    支持第二种格式的原因是 Keras 方法更倾向于这种格式将输入传递给模型和层。因此,使用像 model.fit() 这样的方法时,事情应该“正常工作”——只需以 model.fit() 支持的任何格式传递您的输入和标签!但是,如果您想在没有像 fit()predict() 这样的 Keras 方法的情况下使用第二种格式,例如在创建自己的层或使用 Keras Functional API 的模型时,有以下三种你可以用来收集第一个位置参数中所有输入张量的方法

    • 仅包含 input_ids 的单个张量:model(input_ids)
    • 一个长度可变的列表,其中包含按文档字符串中给出的顺序排列的一个或多个输入张量:model([input_ids, attention_mask])model([input_ids, attention_mask, token_type_ids])
    • 一个字典,其中包含一个或多个与文档字符串中给出的输入名称关联的输入张量:model({"input_ids": input_ids, "token_type_ids": token_type_ids})

    请注意,在通过 子类化 创建模型和层时,您不需要担心任何这些问题,因为您可以像传递任何其他 Python 函数输入一样传递输入!

    调用

    < >

    ( 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 or tuple(tf.Tensor)

    参数

    • input_ids (Numpy arraytf.Tensor 的形状为 (batch_size, sequence_length)) — 词库中输入序列的词索引。

      注意,sequence_length 等于 token_sequence_length + patch_sequence_length + 1,其中 1 是用于 [CLS] 令牌的。参见 pixel_values 了解 patch_sequence_length

      可以使用 AutoTokenizer 获取索引。请参阅 PreTrainedTokenizer.encode()PreTrainedTokenizer.call() 了解详细信息。

      什么是输入 ID?

    • bbox (Numpy arraytf.Tensor 的形状为 (batch_size, sequence_length, 4),可选) — 每个输入序列的词的包围盒。在 [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] 令牌的。参见 pixel_values 了解 patch_sequence_length

    • 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)可选) — 避免在填充标记索引上执行注意力的遮掩。遮掩值在 [0, 1] 中选择:

      • 1 代表未遮掩的标记,
      • 0 代表已遮掩的标记。

      注意,sequence_length = token_sequence_length + patch_sequence_length + 1,其中 1 代表 [CLS] 标记。关于 patch_sequence_length 请参见 pixel_values

      什么是注意力遮掩?

    • token_type_ids (Numpy arraytf.Tensor 形状为 (batch_size, sequence_length)可选) — 标记段索引,用于标识输入的第一和第二部分。索引在 [0, 1] 中选择:

      • 0 代表句子 A 标记,
      • 1 代表句子 B 标记。

      注意,sequence_length = token_sequence_length + patch_sequence_length + 1,其中 1 是 [CLS] 标记。关于 patch_sequence_length 请参见 pixel_values

      什么是标记类型 ID?

    • position_ids (Numpy arraytf.Tensor 形状为 (batch_size, sequence_length)可选) — 每个输入序列标记在位置嵌入中的索引。索引在 [0, config.max_position_embeddings - 1] 范围内选择。

      注意,sequence_length = token_sequence_length + patch_sequence_length + 1,其中 1 是 [CLS] 标记。关于 patch_sequence_length 请参见 pixel_values

      什么是位置 ID?

    • head_masktf.Tensor 形状为 (num_heads,)(num_layers, num_heads)可选)—— 空白化自注意力模块选中头的掩码。掩码值在 [0, 1] 中选择:

      • 1 表示头未被掩码
      • 0 表示头被掩码
    • inputs_embedstf.Tensor 形状为 (batch_size, sequence_length, hidden_size)可选)—— 可选地,您可以选择直接传递嵌入表示来代替 input_ids。如果想要比模型的内部嵌入查找矩阵有更多控制权,以便将 input_ids 索引转换为相关向量,这可能很有用。
    • output_attentionsbool可选)—— 是否返回所有注意力层的注意力张量。详细信息请参阅返回张量中的 attentions
    • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。请参阅返回的张量下的 hidden_states 以获取更多信息。
    • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是纯元组。
    • labels (tf.Tensor 形状 (batch_size, sequence_length)可选) — 用于计算标记分类损失的标签。索引应在 [0, ..., config.num_labels - 1] 范围内。

    返回值

    transformers.modeling_tf_outputs.TFTokenClassifierOutputtuple(tf.Tensor)

    一个 transformers.modeling_tf_outputs.TFTokenClassifierOutput 或一个包含 tf.Tensor 的元组(如果 return_dict=False 传递或当 config.return_dict=False 时),取决于配置(LayoutLMv3Config)和输入。

    • loss (tf.Tensor 形状 (n,)可选,其中 n 是未掩码标签的数量,当提供标签时返回) — 分类损失。

    • 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)

      各个层输出和初始嵌入输出的隐藏状态。

    • attentions (tuple(tf.Tensor)可选,传递 output_attentions=True 时返回,或当 config.output_attentions=True) — 每个层的 tf.Tensor 元组(形状为 (batch_size, num_heads, sequence_length, sequence_length))。

      在注意力softmax之后,使用了这些权重计算自注意力头的加权平均值。

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

    尽管向前推进的食谱需要在这个函数内定义,但应该调用该函数之后的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.logits

    TFLayoutLMv3ForQuestionAnswering

    transformers.TFLayoutLMv3ForQuestionAnswering

    < >

    ( config: LayoutLMv3Config **kwargs )

    参数

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

    带有跨度分类头的LayoutLMv3模型,用于类似DocVQA的抽取式问答任务(在隐藏状态的文本部分顶部添加一个线性层,以计算跨度起始logits跨度结束logits)。

    该模型继承自 TFPreTrainedModel。检查基类的文档,了解库为所有模型实现的通用方法(例如下载或保存、调整输入嵌入的大小、剪枝头部等。)

    此模型也是 keras.Model 的子类。将其作为常规 TF 2.0 Keras 模型使用,并参考 TF 2.0 文档中的所有关于通用使用和行为的相关事项。

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

    • 所有输入作为关键字参数(如 PyTorch 模型),或
    • 所有输入作为第一个位置参数中的列表、元组或字典。

    支持第二种格式的原因是 Keras 方法更倾向于这种格式将输入传递给模型和层。因此,使用像 model.fit() 这样的方法时,事情应该“正常工作”——只需以 model.fit() 支持的任何格式传递您的输入和标签!但是,如果您想在没有像 fit()predict() 这样的 Keras 方法的情况下使用第二种格式,例如在创建自己的层或使用 Keras Functional API 的模型时,有以下三种你可以用来收集第一个位置参数中所有输入张量的方法

    • 仅包含 input_ids 的单个张量:model(input_ids)
    • 一个长度可变的列表,其中包含按文档字符串中给出的顺序排列的一个或多个输入张量:model([input_ids, attention_mask])model([input_ids, attention_mask, token_type_ids])
    • 一个字典,其中包含一个或多个与文档字符串中给出的输入名称关联的输入张量:model({"input_ids": input_ids, "token_type_ids": token_type_ids})

    请注意,在通过 子类化 创建模型和层时,您不需要担心任何这些问题,因为您可以像传递任何其他 Python 函数输入一样传递输入!

    调用

    < >

    ( 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 or tuple(tf.Tensor)

    参数

    • input_idsNumpy arraytf.Tensor,形状为 (batch_size, sequence_length)) — 输入序列令牌在词汇表中的索引。

      注意:sequence_length = token_sequence_length + patch_sequence_length + 1,其中 1 是 [CLS] 令牌。有关 patch_sequence_length,见 pixel_values

      可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

      什么是输入 ID?

    • bboxNumpy arraytf.Tensor,形状为 (batch_size, sequence_length, 4)可选) — 每个输入序列令牌的边界框。选择范围在 [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] 令牌。有关 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)可选项) — 用于防止对填充令牌索引执行注意力操作的掩码。选定的掩码值在 [0, 1] 之间:

      • 1 代表 未掩码 的令牌,
      • 0 代表 掩码 的令牌。

      请注意,sequence_length = token_sequence_length + patch_sequence_length + 1,其中 1 是用于 [CLS] 令牌的。关于 patch_sequence_length,请参阅 pixel_values

      什么是注意力掩码?

    • token_type_ids (Numpy arraytf.Tensor 形状为 (batch_size, sequence_length)可选项) — 段落令牌索引,用于指示输入的第一个和第二个部分。索引选择在 [0, 1] 之间:

      • 0 对应于 A 句子 令牌,
      • 1 对应于 B 句子 令牌。

      请注意,sequence_length = token_sequence_length + patch_sequence_length + 1,其中 1 是用于 [CLS] 令牌的。关于 patch_sequence_length,请参阅 pixel_values

      什么是令牌类型 ID?

    • position_ids (Numpy arraytf.Tensor 形状为 (batch_size, sequence_length)可选) — 每个输入序列标记在位置嵌入中的位置索引。选择范围 [0, config.max_position_embeddings - 1]

      请注意,sequence_length = token_sequence_length + patch_sequence_length + 1 其中 1 为 [CLS] 标记。见 pixel_valuespatch_sequence_length

      什么是位置 ID?

    • head_mask (tf.Tensor 形状为 (num_heads,)(num_layers, num_heads)可选) — 用于取消选择自注意力模块中选定头部的掩码。掩码值选择范围 [0, 1]

      • 1 表示头部 未屏蔽
      • 0 表示头部 已屏蔽
    • inputs_embeds (tf.Tensor 形状为 (batch_size, sequence_length, hidden_size)可选) — 可选地,您可以直接传递嵌入表示,而不是传递 input_ids。如果您希望比模型内部嵌入查找矩阵有更多的控制权来将 input_ids 索引转换为相关向量,这非常有用。
    • output_attentions(《布尔值`, 可选)— 是否返回所有注意力层的注意力张量。有关详细信息,请参阅返回张量下的attentions
    • output_hidden_states(《布尔值`, 可选)— 是否返回所有层的隐藏状态。有关详细信息,请参阅返回张量下的hidden_states
    • return_dict(《布尔值`, 可选)— 是否返回ModelOutput对象而不是普通元组。
    • start_positions (形状为(batch_size,)tf.Tensor可选)——用于计算标记句子起始位置的标签。位置限制在序列长度(sequence_length)内。序列外的位置不参与损失计算。
    • end_positions (形状为(batch_size,)tf.Tensor可选)——用于计算标记句子结束位置的标签。位置限制在序列长度(sequence_length)内。序列外的位置不参与损失计算。

    返回值

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

    A transformers.modeling_tf_outputs.TFQuestionAnsweringModelOutput 或一个 tf.Tensor 的元组(如果传递了 return_dict=False 或当 config.return_dict=False),包括根据配置(LayoutLMv3Config)和输入的不同元素。

    • loss (如果提供了 start_positionsend_positions,则返回形状为 (batch_size, )tf.Tensor可选)——总范围提取损失是起始位置和结束位置的交叉熵损失的总和。

    • start_logits (形状为 (batch_size, sequence_length)tf.Tensor)——范围起始分数(在 SoftMax 之前)。

    • end_logits (形状为 (batch_size, sequence_length)tf.Tensor)——范围结束分数(在 SoftMax 之前)。

    • hidden_states (tuple(tf.Tensor)可选,在传递output_hidden_states=True时返回或当config.output_hidden_states=True时返回) — 一个tf.Tensor的元组(融入层输出+每层输出),形状为(batch_size, sequence_length, hidden_size)

      各个层输出和初始嵌入输出的隐藏状态。

    • attentions (tuple(tf.Tensor)可选,传递 output_attentions=True 时返回,或当 config.output_attentions=True) — 每个层的 tf.Tensor 元组(形状为 (batch_size, num_heads, sequence_length, sequence_length))。

      在注意力softmax之后,使用了这些权重计算自注意力头的加权平均值。

    TFLayoutLMv3ForQuestionAnswering 的正向方法覆盖了 __call__ 特殊方法。

    尽管向前推进的食谱需要在这个函数内定义,但应该调用该函数之后的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
    < > 更新 GitHub