Transformers--4-37-中文文档-四十四-

Transformers 4.37 中文文档（四十四）

原文：huggingface.co/docs/transformers

LayoutLMv3

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

概述

LayoutLMv3 模型由 Yupan Huang、Tengchao Lv、Lei Cui、Yutong Lu、Furu Wei 在LayoutLMv3: Pre-training for Document AI with Unified Text and Image Masking中提出。LayoutLMv3 通过使用补丁嵌入（如 ViT 中的方式）简化了 LayoutLMv2，并在 3 个目标上对模型进行了预训练：掩码语言建模（MLM）、掩码图像建模（MIM）和单词-补丁对齐（WPA）。

论文摘要如下：

自监督预训练技术在文档 AI 领域取得了显著进展。大多数多模态预训练模型使用掩码语言建模目标来学习文本模态上的双向表示，但它们在图像模态的预训练目标上有所不同。这种差异增加了多模态表示学习的难度。在本文中，我们提出了 LayoutLMv3，用于为文档 AI 预训练多模态 Transformers，统一文本和图像掩码。此外，LayoutLMv3 还使用了单词-补丁对齐目标进行预训练，通过预测文本单词的相应图像补丁是否被掩码来学习跨模态对齐。简单的统一架构和训练目标使 LayoutLMv3 成为文本中心和图像中心文档 AI 任务的通用预训练模型。实验结果表明，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 资源。在准备模型数据时，请务必使用 LayoutLMv2Processor！

• LayoutLMv3 的演示笔记本可以在这里找到。

• 演示脚本可以在这里找到。

文本分类

• 这个笔记本支持 LayoutLMv2ForSequenceClassification。

• 文本分类任务指南

标记分类

• 这个示例脚本和笔记本支持 LayoutLMv3ForTokenClassification。

• 一个关于如何使用 LayoutLMv2ForTokenClassification 进行推断的笔记本，以及一个关于如何在没有标签的情况下使用 LayoutLMv2ForTokenClassification 进行推断的笔记本。

• 一个关于如何使用🤗 Trainer 对 LayoutLMv2ForTokenClassification 进行微调的笔记本。

• 标记分类任务指南

问答

• 这个笔记本支持 LayoutLMv2ForQuestionAnswering。

• 问答任务指南

文档问答

• 文档问答任务指南

LayoutLMv3Config

class 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, optional, 默认为 50265) — LayoutLMv3 模型的词汇量。定义了在调用 LayoutLMv3Model 时可以表示的不同标记数量。

• hidden_size (int, optional, 默认为 768) — 编码器层和池化层的维度。

• num_hidden_layers (int, optional, 默认为 12) — Transformer 编码器中隐藏层的数量。

• num_attention_heads (int, optional, 默认为 12) — Transformer 编码器中每个注意力层的注意力头数。

• intermediate_size (int, optional, 默认为 3072) — Transformer 编码器中“中间”（即前馈）层的维度。

• hidden_act (str 或 function, optional, 默认为 "gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持 "gelu", "relu", "selu" 和 "gelu_new"。

• hidden_dropout_prob (float, optional, 默认为 0.1) — 嵌入、编码器和池化器中所有全连接层的 dropout 概率。

• attention_probs_dropout_prob (float, optional, 默认为 0.1) — 注意力概率的 dropout 比率。

• max_position_embeddings (int, optional, 默认为 512) — 该模型可能使用的最大序列长度。通常设置为一个较大的值以防万一（例如，512 或 1024 或 2048）。

• type_vocab_size (int, optional, 默认为 2) — 在调用 LayoutLMv3Model 时传递的 token_type_ids 的词汇表大小。

• initializer_range (float, optional, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。

• layer_norm_eps (float, optional, 默认为 1e-5) — 层归一化层使用的 epsilon。

• max_2d_position_embeddings (int, optional, 默认为 1024) — 2D 位置嵌入可能使用的最大值。通常设置为一个较大的值以防万一（例如，1024）。

• coordinate_size (int, optional, 默认为 128) — 坐标嵌入的维度。

• shape_size (int, optional, 默认为 128) — 宽度和高度嵌入的维度。

• has_relative_attention_bias (bool, optional, 默认为 True) — 是否在自注意力机制中使用相对注意力偏置。

• rel_pos_bins (int, optional, 默认为 32) — 在自注意力机制中使用的相对位置桶的数量。

• max_rel_pos (int, optional, 默认为 128) — 在自注意力机制中使用的最大相对位置数。

• max_rel_2d_pos (int, optional, 默认为 256) — 自注意力机制中的最大 2D 相对位置数。

• rel_2d_pos_bins (int, optional, 默认为 64) — 自注意力机制中的 2D 相对位置桶的数量。

• has_spatial_attention_bias (bool, optional, 默认为 True) — 是否在自注意力机制中使用空间注意偏置。

• visual_embed (bool, optional, 默认为 True) — 是否添加补丁嵌入。

• input_size (int, optional, 默认为 224) — 图像的大小（分辨率）。

• num_channels (int, optional, 默认为 3) — 图像的通道数。

• patch_size (int, optional, 默认为 16) — 补丁的大小（分辨率）。

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

LayoutLMv3FeatureExtractor

class transformers.LayoutLMv3FeatureExtractor

< source >

( *args **kwargs )

__call__

< source >

( images **kwargs )

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

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, 默认为 True) — 是否将图像的 (高度，宽度) 尺寸调整为 (size["height"], size["width"])。可以被 preprocess 中的 do_resize 覆盖。

• size (Dict[str, int] optional, 默认为 {"height" -- 224, "width": 224}): 调整大小后的图像尺寸。可以被 preprocess 中的 size 覆盖。

• resample (PILImageResampling, optional, 默认为 PILImageResampling.BILINEAR) — 如果调整图像大小，要使用的重采样滤波器。可以被 preprocess 中的 resample 覆盖。

• do_rescale (bool, optional, 默认为 True) — 是否按指定的 rescale_value 重新缩放图像的像素值。可以被 preprocess 中的 do_rescale 覆盖。

• rescale_factor (float, optional, 默认为 1 / 255) — 图像的像素值被重新缩放的值。可以被 preprocess 中的 rescale_factor 覆盖。

• do_normalize (bool, optional, 默认为 True) — 是否对图像进行规范化。可以被 preprocess 方法中的 do_normalize 参数覆盖。

• image_mean (Iterable[float] 或 float, optional, 默认为 IMAGENET_STANDARD_MEAN) — 如果规范化图像要使用的均值。这是一个浮点数或与图像通道数相同长度的浮点数列表。可以被 preprocess 方法中的 image_mean 参数覆盖。

• image_std (Iterable[float] 或 float, optional, 默认为 IMAGENET_STANDARD_STD) — 如果规范化图像要使用的标准差。这是一个浮点数或与图像通道数相同长度的浮点数列表。可以被 preprocess 方法中的 image_std 参数覆盖。

• apply_ocr (bool, optional, 默认为 True) — 是否应用 Tesseract OCR 引擎以获取单词 + 规范化边界框。可以被 preprocess 方法中的 apply_ocr 参数覆盖。

• ocr_lang (str, optional) — Tesseract OCR 引擎要使用的语言，由其 ISO 代码指定。默认情况下使用英语。可以被 preprocess 方法中的 ocr_lang 参数覆盖。

• tesseract_config (str, optional) — 转发到调用 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 **kwargs )

参数

• images (ImageInput) — 要预处理的图像。期望单个或批量图像，像素值范围为 0 到 255。如果传入像素值在 0 到 1 之间的图像，请设置 do_rescale=False。

• do_resize (bool, optional, 默认为 self.do_resize) — 是否调整图像大小。

• size (Dict[str, int], optional, 默认为 self.size) — 应用 resize 后输出图像的期望大小。

• resample (int, optional, defaults to self.resample) — 如果调整图像大小，则要使用的重采样滤波器。这可以是 PILImageResampling 滤波器之一。仅在 do_resize 设置为 True 时有效。

• do_rescale (bool, optional, defaults to self.do_rescale) — 是否将图像像素值重新缩放到 [0, 1] 之间。

• rescale_factor (float, optional, defaults to self.rescale_factor) — 应用于图像像素值的重新缩放因子。仅在 do_rescale 设置为 True 时有效。

• do_normalize (bool, optional, defaults to self.do_normalize) — 是否对图像进行归一化。

• image_mean (float or Iterable[float], optional, defaults to self.image_mean) — 用于归一化的均值。仅在 do_normalize 设置为 True 时有效。

• image_std (float or Iterable[float], optional, defaults to self.image_std) — 用于归一化的标准差值。仅在 do_normalize 设置为 True 时有效。

• apply_ocr (bool, optional, defaults to self.apply_ocr) — 是否应用 Tesseract OCR 引擎以获取单词 + 规范化边界框。

• ocr_lang (str, optional, defaults to self.ocr_lang) — Tesseract OCR 引擎使用的语言，由其 ISO 代码指定。默认情况下使用英语。

• tesseract_config (str, optional, defaults to self.tesseract_config) — 转发到调用 Tesseract 时 config 参数的任何额外自定义配置标志。

• return_tensors (str or TensorType, optional) — 要返回的张量类型。可以是以下之一：

  • 未设置：返回 np.ndarray 的列表。

  • TensorType.TENSORFLOW 或 'tf'：返回类型为 tf.Tensor 的批次。

  • TensorType.PYTORCH 或 'pt'：返回类型为 torch.Tensor 的批次。

  • TensorType.NUMPY 或 'np'：返回类型为 np.ndarray 的批次。

  • TensorType.JAX 或 'jax'：返回类型为 jax.numpy.ndarray 的批次。

• data_format (ChannelDimension 或 str, optional, defaults to ChannelDimension.FIRST) — 输出图像的通道维度格式。可以是以下之一：

  • ChannelDimension.FIRST：图像以 (通道数, 高度, 宽度) 格式。

  • ChannelDimension.LAST：图像以 (高度, 宽度, 通道数) 格式。

• input_data_format (ChannelDimension 或 str, optional) — 输入图像的通道维度格式。如果未设置，则从输入图像中推断通道维度格式。可以是以下之一：

  • "channels_first" 或 ChannelDimension.FIRST：图像以 (通道数, 高度, 宽度) 格式。

  • "channels_last" 或 ChannelDimension.LAST：图像以 (高度, 宽度, 通道数) 格式。

  • "none" 或 ChannelDimension.NONE：图像以 (高度, 宽度) 格式。

预处理图像或图像批次。

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) — 词汇文件的路径。

• merges_file (str) — 合并文件的路径。

• errors (str, optional, defaults to "replace") — 解码字节为 UTF-8 时要遵循的范例。有关更多信息，请参阅 bytes.decode。

• bos_token (str, optional, defaults to "<s>") — 在预训练期间使用的序列开头标记。可用作序列分类器标记。

  构建序列时使用特殊标记，这不是序列开头使用的标记。使用的标记是 cls_token。

• eos_token (str, optional, defaults to "</s>") — 序列结束标记。

  构建序列时使用特殊标记，这不是序列末尾使用的标记。使用的标记是 sep_token。

• sep_token (str, optional, 默认为 "</s>") — 分隔符标记，在构建来自多个序列的序列时使用，例如用于序列分类的两个序列或用于问题回答的文本和问题。它还用作使用特殊标记构建的序列的最后一个标记。

• cls_token (str, optional, 默认为 "<s>") — 分类器标记，用于进行序列分类（对整个序列进行分类，而不是每个标记进行分类）。它是使用特殊标记构建的序列的第一个标记。

• unk_token (str, optional, 默认为 "<unk>") — 未知标记。词汇表中没有的标记无法转换为 ID，而是设置为此标记。

• pad_token (str, optional, 默认为 "<pad>") — 用于填充的标记，例如在批处理不同长度的序列时使用。

• mask_token (str, optional, 默认为 "<mask>") — 用于屏蔽值的标记。这是在使用掩码语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。

• add_prefix_space (bool, optional, 默认为 True) — 是否在输入中添加初始空格。这允许将前导单词视为任何其他单词。（RoBERTa 分词器通过前面的空格检测单词的开头）。

• cls_token_box (List[int], optional, 默认为 [0, 0, 0, 0]) — 用于特殊[CLS]标记的边界框。

• sep_token_box (List[int], optional, 默认为 [0, 0, 0, 0]) — 用于特殊[SEP]标记的边界框。

• pad_token_box (List[int], optional, 默认为 [0, 0, 0, 0]) — 用于特殊[PAD]标记的边界框。

• pad_token_label (int, optional, 默认为 -100) — 用于填充标记的标签。默认为-100，这是 PyTorch 的 CrossEntropyLoss 的ignore_index。

• only_label_first_subword (bool, optional, 默认为 True) — 是否仅标记第一个子词，如果提供了单词标签。

构建一个 LayoutLMv3 分词器。基于RoBERTatokenizer（字节对编码或 BPE）。LayoutLMv3Tokenizer 可用于将单词、单词级边界框和可选单词标签转换为标记级input_ids、attention_mask、token_type_ids、bbox和可选labels（用于标记分类）。

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

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

__call__

<来源>

( text: Union text_pair: Union = None boxes: Union = None word_labels: Union = None add_special_tokens: bool = True padding: Union = False truncation: Union = None max_length: Optional = None stride: int = 0 pad_to_multiple_of: Optional = None return_tensors: Union = None return_token_type_ids: Optional = None return_attention_mask: Optional = None return_overflowing_tokens: bool = False return_special_tokens_mask: bool = False return_offsets_mapping: bool = False return_length: bool = False verbose: bool = True **kwargs )

参数

• text (str, List[str], List[List[str]]) — 要编码的序列或批次序列。每个序列可以是一个字符串，一个字符串列表（单个示例的单词或一批示例的问题）或一个字符串列表的列表（一批单词）。

• text_pair (List[str], List[List[str]]) — 要编码的序列或批次序列。每个序列应该是一个字符串列表（预分词的字符串）。

• boxes (List[List[int]], List[List[List[int]]]) — 单词级边界框。每个边界框应标准化为 0-1000 的比例。

• word_labels (List[int], List[List[int]], optional) — 单词级整数标签（用于诸如 FUNSD、CORD 之类的标记分类任务）。

• add_special_tokens (bool, optional, defaults to True) — 是否对序列进行编码，使用相对于其模型的特殊标记。

• padding (bool, str 或 PaddingStrategy, optional, defaults to False) — 激活并控制填充。接受以下值：

  • True 或 'longest': 填充到批次中最长的序列（如果只提供了单个序列，则不填充）。

  • 'max_length': 填充到指定的最大长度（使用参数 max_length）或模型的最大可接受输入长度（如果未提供该参数）。

  • False 或 'do_not_pad'（默认）：无填充（即，可以输出具有不同长度序列的批次）。

• truncation (bool, str 或 TruncationStrategy, optional, defaults to False) — 激活并控制截断。接受以下值：

  • True 或 'longest_first': 截断到指定的最大长度（使用参数 max_length）或模型的最大可接受输入长度（如果未提供该参数）。如果提供了一对序列（或一批对序列），则逐标记截断，从最长序列中删除一个标记。

  • 'only_first': 截断到指定的最大长度（使用参数 max_length）或模型的最大可接受输入长度（如果未提供该参数）。如果提供了一对序列（或一批对序列），则仅截断第一个序列。

  • 'only_second': 截断到指定的最大长度（使用参数 max_length）或模型的最大可接受输入长度（如果未提供该参数）。如果提供了一对序列（或一批对序列），则仅截断第二个序列。

  • False 或 'do_not_truncate'（默认）：无截断（即，可以输出具有大于模型最大可接受输入大小的序列长度的批次）。

• max_length (int, optional) — 控制截断/填充参数使用的最大长度。

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

• stride (int, optional, defaults to 0) — 如果设置为一个数字，并且与 max_length 一起使用，当 return_overflowing_tokens=True 时返回的溢出标记将包含截断序列末尾的一些标记，以提供截断和溢出序列之间的一些重叠。该参数的值定义了重叠标记的数量。

• pad_to_multiple_of (int, optional) — 如果设置，将填充序列到提供的值的倍数。这对于在具有计算能力 >= 7.5（Volta）的 NVIDIA 硬件上启用 Tensor Cores 特别有用。

• return_tensors (str 或 TensorType, optional) — 如果设置，将返回张量而不是 Python 整数列表。可接受的值为：

  • 'tf': 返回 TensorFlow tf.constant 对象。

  • 'pt': 返回 PyTorch torch.Tensor 对象。

  • 'np': 返回 Numpy np.ndarray 对象。

• add_special_tokens (bool, optional, defaults to True) — 是否对序列进行编码，使用相对于其模型的特殊标记。

• padding (bool, str 或 PaddingStrategy, optional, defaults to False) — 激活并控制填充。接受以下值：

  • True 或 'longest': 填充到批次中最长的序列（如果只提供了单个序列，则不填充）。

  • 'max_length': 填充到指定的最大长度，该长度由参数 max_length 指定，或者填充到模型的最大可接受输入长度，如果未提供该参数。

  • False 或 'do_not_pad'（默认）：不填充（即，可以输出具有不同长度序列的批次）。

• truncation (bool, str 或 TruncationStrategy, 可选, 默认为 False) — 激活和控制截断。接受以下值：

  • True 或 'longest_first': 截断到由参数 max_length 指定的最大长度，或者截断到模型的最大可接受输入长度，如果未提供该参数。如果提供了一对序列（或一批序列对），则将逐个标记截断，从较长序列中删除一个标记。

  • 'only_first': 截断到由参数 max_length 指定的最大长度，或者截断到模型的最大可接受输入长度，如果未提供该参数。如果提供了一对序列（或一批序列对），则仅截断第一个序列。

  • 'only_second': 截断到由参数 max_length 指定的最大长度，或者截断到模型的最大可接受输入长度，如果未提供该参数。如果提供了一对序列（或一批序列对），则仅截断第二个序列。

  • False 或 'do_not_truncate'（默认）：不截断（即，可以输出具有大于模型最大可接受输入大小的序列长度的批次）。

• max_length (int, 可选) — 控制截断/填充参数之一使用的最大长度。如果未设置或设置为 None，则将使用预定义的模型最大长度，如果截断/填充参数需要最大长度。如果模型没有特定的最大输入长度（如 XLNet），则将禁用截断/填充到最大长度。

• stride (int, 可选, 默认为 0) — 如果与 max_length 一起设置为一个数字，则当 return_overflowing_tokens=True 时返回的溢出标记将包含从截断序列末尾返回的一些标记，以提供截断和溢出序列之间的一些重叠。该参数的值定义了重叠标记的数量。

• pad_to_multiple_of (int, 可选) — 如果设置，将填充序列到提供的值的倍数。这对于在具有计算能力 >= 7.5（Volta）的 NVIDIA 硬件上启用 Tensor Cores 特别有用。

• return_tensors (str 或 TensorType, 可选) — 如果设置，将返回张量而不是 Python 整数列表。可接受的值为：

  • 'tf': 返回 TensorFlow tf.constant 对象。

  • 'pt': 返回 PyTorch torch.Tensor 对象。

  • 'np': 返回 Numpy np.ndarray 对象。

用于对一个或多个序列或一个或多个序列对进行标记化和为模型准备的主要方法，其中包括单词级别的归一化边界框和可选标签。

save_vocabulary

< source >

( save_directory: str filename_prefix: Optional = None )

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) — 合并文件的路径。

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

<来源>

( text: Union text_pair: Union = None boxes: Union = None word_labels: Union = None add_special_tokens: bool = True padding: Union = False truncation: Union = None max_length: Optional = None stride: int = 0 pad_to_multiple_of: Optional = None return_tensors: Union = None return_token_type_ids: Optional = None return_attention_mask: Optional = None return_overflowing_tokens: bool = False return_special_tokens_mask: bool = False return_offsets_mapping: bool = False return_length: bool = False verbose: bool = True **kwargs )

参数

• text (str, List[str], List[List[str]]) — 要编码的序列或序列批次。每个序列可以是一个字符串，一个字符串列表（单个示例的单词或一批示例的问题）或一个字符串列表的列表（单词批次）。

• text_pair (List[str], List[List[str]]) — 要编码的序列或序列批次。每个序列应该是一个字符串列表（预先标记化的字符串）。

• boxes (List[List[int]], List[List[List[int]]]) — 单词级别的边界框。每个边界框应该被归一化为 0-1000 的比例。

• word_labels（List[int]、List[List[int]]，可选） — 单词级整数标签（用于诸如 FUNSD、CORD 等标记分类任务）。

• add_special_tokens（bool，可选，默认为 True） — 是否使用相对于其模型的特殊标记对序列进行编码。

• padding（bool、str 或 PaddingStrategy，可选，默认为 False） — 激活和控制填充。接受以下值：

  • True 或 'longest'：填充到批次中最长的序列（如果只提供了单个序列，则不进行填充）。

  • 'max_length'：填充到由参数 max_length 指定的最大长度，或者填充到模型可接受的最大输入长度（如果未提供该参数）。

  • False 或 'do_not_pad'（默认）：不进行填充（即可以输出长度不同的批次）。

• truncation（bool、str 或 TruncationStrategy，可选，默认为 False） — 激活和控制截断。接受以下值：

  • True 或 'longest_first'：截断到由参数 max_length 指定的最大长度，或者截断到模型可接受的最大输入长度（如果未提供该参数）。如果提供了一对序列（或一批对序列），则将逐个标记进行截断，从一对序列中最长的序列中删除一个标记。

  • 'only_first'：截断到由参数 max_length 指定的最大长度，或者截断到模型可接受的最大输入长度（如果未提供该参数）。如果提供了一对序列（或一批对序列），则只会截断第一个序列。

  • 'only_second'：截断到由参数 max_length 指定的最大长度，或者截断到模型可接受的最大输入长度（如果未提供该参数）。如果提供了一对序列（或一批对序列），则只会截断第二个序列。

  • False 或 'do_not_truncate'（默认）：不进行截断（即可以输出长度大于模型最大可接受输入大小的批次）。

• max_length（int，可选） — 控制截断/填充参数之一使用的最大长度。

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

• stride（int，可选，默认为 0） — 如果设置为一个数字，并且与 max_length 一起使用，当 return_overflowing_tokens=True 时返回的溢出标记将包含截断序列末尾的一些标记，以提供截断和溢出序列之间的一些重叠。该参数的值定义了重叠标记的数量。

• pad_to_multiple_of（int，可选） — 如果设置，将填充序列到提供的值的倍数。这对于在具有计算能力 >= 7.5（Volta）的 NVIDIA 硬件上启用 Tensor Cores 特别有用。

• return_tensors（str 或 TensorType，可选） — 如果设置，将返回张量而不是 Python 整数列表。可接受的值为：

  • 'tf'：返回 TensorFlow tf.constant 对象。

  • 'pt'：返回 PyTorch torch.Tensor 对象。

  • 'np'：返回 Numpy np.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时返回的溢出标记将包含截断序列末尾的一些标记，以提供截断和溢出序列之间的一些重叠。该参数的值定义了重叠标记的数量。

• pad_to_multiple_of（int，可选） - 如果设置，将序列填充到提供的值的倍数。这对于启用具有计算能力>= 7.5（Volta）的 NVIDIA 硬件上的 Tensor Cores 特别有用。

• return_tensors（str或 TensorType，可选） - 如果设置，将返回张量而不是 Python 整数列表。可接受的值为：

  • 'tf': 返回 TensorFlow tf.constant对象。

  • 'pt': 返回 PyTorch torch.Tensor对象。

  • 'np': 返回 Numpy np.ndarray对象。

用于标记和准备一个或多个序列或一个或多个序列对的主要方法，具有单词级别的归一化边界框和可选标签。

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，将单词和边界框转换为标记级input_ids、attention_mask、token_type_ids、bbox。可选地，可以提供整数word_labels，这些标签被转换为用于标记分类任务（如 FUNSD、CORD）的标记级labels。

__call__

<来源>

( images text: Union = None text_pair: Union = None boxes: Union = None word_labels: Union = None add_special_tokens: bool = True padding: Union = False truncation: Union = 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`。

更多信息请参考上述两种方法的文档字符串。

Pytorch 隐藏 Pytorch 内容

LayoutLMv3Model

class transformers.LayoutLMv3Model

<来源>

( config )

参数

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

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

forward

<来源>

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

参数

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

  请注意，sequence_length = token_sequence_length + patch_sequence_length + 1，其中1代表[CLS]标记。有关patch_sequence_length，请参阅pixel_values。

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

  什么是输入 ID？

• bbox (torch.LongTensor of shape (batch_size, token_sequence_length, 4), optional) — 每个输入序列标记的边界框。选择范围为[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 (torch.FloatTensor of shape (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 of shape (batch_size, token_sequence_length), optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]之间：

  • 1 表示未被屏蔽的标记，

  • 0 表示被屏蔽的标记。

  请注意，sequence_length = token_sequence_length + patch_sequence_length + 1，其中1代表[CLS]标记。有关patch_sequence_length，请参阅pixel_values。

  什么是注意力掩码？

• token_type_ids (torch.LongTensor of shape (batch_size, token_sequence_length), optional) — 指示输入的第一部分和第二部分的段标记索引。索引选择在[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 of shape (batch_size, token_sequence_length), optional) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为[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 of shape (num_heads,) or (num_layers, num_heads), optional) — 用于使自注意力模块中的选定头部失效的掩码。掩码值选择在[0, 1]之间：

  • 1 表示头部未被屏蔽，

  • 0 表示头部被屏蔽。

• inputs_embeds (torch.FloatTensor of shape (batch_size, token_sequence_length, hidden_size), optional) — 可选地，您可以选择直接传递嵌入表示而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。

• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回的张量下的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（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor）— 模型最后一层输出的隐藏状态序列。

• hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回）— 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层的输出，则为嵌入层的输出+每层的输出）。

  模型在每一层的输出隐藏状态以及可选的初始嵌入输出。

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

  在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

LayoutLMv3Model 的前向方法，覆盖__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")
>>> 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()方法以加载模型权重。

LayoutLMv3 模型在顶部具有序列分类头部（在[CLS]标记的最终隐藏状态之上的线性层），例如用于文档图像分类任务，如RVL-CDIP数据集。

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

forward

<来源>

( 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 ) → export const metadata = 'undefined';transformers.modeling_outputs.SequenceClassifierOutput or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）— 词汇表中输入序列标记的索引。

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

  什么是输入 ID？

• bbox (torch.LongTensor，形状为 (batch_size, sequence_length, 4)，optional) — 每个输入序列标记的边界框。选定范围为 [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)，optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选定在 [0, 1] 之间：

  • 1 代表未被 masked 的标记，

  • 0 代表被 masked 的标记。

  什么是注意力掩码？

• token_type_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，optional) — 段标记索引，指示输入的第一部分和第二部分。索引选定在 [0, 1] 之间：

  • 0 对应于 句子 A 标记，

  • 1 对应于 句子 B 标记。

  什么是标记类型 ID？

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

  什么是位置 ID？

• head_mask (torch.FloatTensor，形状为 (num_heads,) 或 (num_layers, num_heads)，optional) — 用于使自注意力模块中的特定头部失效的掩码。掩码值选定在 [0, 1] 之间：

  • 1 表示头部未被 masked，

  • 0 表示头部被 masked。

• inputs_embeds (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)，optional) — 可选地，可以直接传递嵌入表示，而不是传递 input_ids。如果您想要更多控制权，以便将 input_ids 索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。

• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。

• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。

• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

返回

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

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

• loss（形状为(1,)的torch.FloatTensor，可选，当提供labels时返回）- 分类（如果 config.num_labels==1 则为回归）损失。

• logits（形状为(batch_size, config.num_labels)的torch.FloatTensor）- 分类（如果 config.num_labels==1 则为回归）得分（SoftMax 之前）。

• hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）- 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组。

  模型在每一层输出的隐藏状态以及可选的初始嵌入输出。

• attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）- 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组。

  注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

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

class transformers.LayoutLMv3ForTokenClassification

<来源>

( config )

参数

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

LayoutLMv3 模型，顶部带有一个标记分类头（最终隐藏状态之上的线性层），例如用于序列标记（信息提取）任务的FUNSD、SROIE、CORD和Kleister-NDA。

此模型是 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 labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None pixel_values: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.TokenClassifierOutput or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）- 词汇表中输入序列标记的索引。

  可以使用 AutoTokenizer 获取索引。查看 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()获取详细信息。

  什么是输入 ID？

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

• pixel_values (torch.FloatTensor of shape (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 of shape (batch_size, sequence_length), optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值在 [0, 1] 中选择：

  • 对于未被 masked 的标记为 1，

  • 对于被 masked 的标记为 0。

  什么是注意力掩码？

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

  • 0 对应于 句子 A 标记，

  • 1 对应于 句子 B 标记。

  什么是标记类型 ID？

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

  什么是位置 ID？

• head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于使自注意力模块的选定头部失效的掩码。掩码值在 [0, 1] 中选择：

  • 1 表示头部未被 masked，

  • 0 表示头部被 masked。

• inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，可以直接传递嵌入表示，而不是传递 input_ids。如果您想要更多控制权来将 input_ids 索引转换为相关向量，这将非常有用，而不是使用模型的内部嵌入查找矩阵。

• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。

• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。

• return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通元组。

• labels (torch.LongTensor of shape (batch_size, sequence_length), optional) — 用于计算标记分类损失的标签。索引应在 [0, ..., config.num_labels - 1] 中。

返回

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

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

• loss (torch.FloatTensor of shape (1,), optional, 当提供 labels 时返回) — 分类损失。

• logits (torch.FloatTensor of shape (batch_size, sequence_length, config.num_labels)) — 分类得分（SoftMax 之前）。

• hidden_states (tuple(torch.FloatTensor), 可选的, 当传递output_hidden_states=True或者当config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入的输出，如果模型有一个嵌入层，+ 一个用于每一层的输出）。

  模型每一层输出的隐藏状态以及可选的初始嵌入输出。

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

  在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

LayoutLMv3ForTokenClassification 的前向方法，覆盖__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")
>>> 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

class transformers.LayoutLMv3ForQuestionAnswering

<来源>

( config )

参数

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

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

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

forward

<来源>

( 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 ) → export const metadata = 'undefined';transformers.modeling_outputs.QuestionAnsweringModelOutput or tuple(torch.FloatTensor)

参数

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

  可以使用 AutoTokenizer 获取索引。详情请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

  什么是输入 ID？

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

• pixel_values (torch.FloatTensor of shape (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 of shape (batch_size, sequence_length), optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值在 [0, 1] 中选择：

  • 1 表示未被屏蔽的标记，

  • 0 表示被屏蔽的标记。

  什么是注意力掩码？

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

  • 0 对应于 句子 A 标记，

  • 1 对应于 句子 B 标记。

  什么是标记类型 ID？

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

  什么是位置 ID？

• head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于使自注意力模块中选择的头部失效的掩码。掩码值在 [0, 1] 中选择：

  • 1 表示头部未被屏蔽，

  • 0 表示头部被屏蔽。

• inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，可以直接传递嵌入表示，而不是传递 input_ids。如果您想要更多控制如何将 input_ids 索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。

• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的 attentions。

• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的 hidden_states。

• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

• start_positions (torch.LongTensor of shape (batch_size,), optional) — 用于计算标记范围开始位置的标签（索引）。位置被夹紧到序列的长度 (sequence_length)。超出序列范围的位置不会用于计算损失。

• end_positions (torch.LongTensor of shape (batch_size,), optional) — 用于计算标记范围结束位置的标签（索引）。位置被夹紧到序列的长度 (sequence_length)。超出序列范围的位置不会用于计算损失。

返回

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

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

• loss (torch.FloatTensor of shape (1,), optional, 当提供 labels 时返回) — 总跨度提取损失是开始和结束位置的交叉熵之和。

• 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时返回）-形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层的输出+每个层的输出）。

  模型在每个层的输出处的隐藏状态以及可选的初始嵌入输出。

• attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）-形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每个层一个）。

  在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

LayoutLMv3ForQuestionAnswering 的前向方法，覆盖了__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")
>>> 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](/docs/transformers/v4.37.2/en/main_classes/model#transformers.TFPreTrainedModel.from_pretrained)方法以加载模型权重。

裸的 LayoutLMv3 模型变压器输出原始隐藏状态，没有特定的头部。此模型继承自 TFPreTrainedModel。检查超类文档以获取库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入、修剪头等）。

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

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

• 将所有输入作为关键字参数（如 PyTorch 模型），

• 将所有输入作为列表、元组或字典放在第一个位置参数中。

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

• 只有input_ids的单个张量，没有其他内容：model(input_ids)

• 一个具有一个或多个输入张量的变长列表，按照文档字符串中给定的顺序：model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids])

• 一个字典，其中包含与文档字符串中给定的输入名称相关联的一个或多个输入张量：model({"input_ids": input_ids, "token_type_ids": token_type_ids})

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

call

<来源>

( input_ids: 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 ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFBaseModelOutput or tuple(tf.Tensor)

参数

• input_ids（形状为(batch_size, sequence_length)的Numpy数组或tf.Tensor）- 词汇表中输入序列标记的索引。

  请注意，sequence_length = token_sequence_length + patch_sequence_length + 1，其中1代表[CLS]标记。有关patch_sequence_length，请参阅pixel_values。

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

  什么是输入 ID？

• bbox（形状为(batch_size, sequence_length, 4)的Numpy数组或tf.Tensor，可选）- 每个输入序列标记的边界框。选择范围为[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（形状为(batch_size, num_channels, height, width)的tf.Tensor）- 文档图像的批处理。每个图像被分成形状为(num_channels, config.patch_size, config.patch_size)的补丁，并且补丁的总数（=patch_sequence_length）等于((height / config.patch_size) * (width / config.patch_size))。

• attention_mask（形状为(batch_size, sequence_length)的tf.Tensor，可选）- 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]之间：

  • 对于未被掩码的标记，为 1，

  • 对于被掩码的标记为 0。

  请注意，sequence_length = token_sequence_length + patch_sequence_length + 1，其中1代表[CLS]标记。有关patch_sequence_length，请参阅pixel_values。

  什么是注意力掩码？

• token_type_ids（形状为(batch_size, sequence_length)的Numpy数组或tf.Tensor，可选）- 指示输入的第一部分和第二部分的段标记索引。索引选择在[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（形状为(batch_size, sequence_length)的Numpy数组或tf.Tensor，可选）- 每个输入序列标记在位置嵌入中的位置索引。选择范围为[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（形状为(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（可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

• return_dict（可选）— 是否返回 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（形状为(batch_size, sequence_length, hidden_size)的tf.Tensor）— 模型最后一层的隐藏状态序列输出。

• hidden_states（可选的，当传递output_hidden_states=True或当config.output_hidden_states=True时返回）— 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入的输出 + 一个用于每一层的输出）。

  模型在每一层的输出隐藏状态以及初始嵌入输出。

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

  在自注意力头中用于计算加权平均值的注意力权重在注意力 softmax 之后。

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

class transformers.TFLayoutLMv3ForSequenceClassification

<来源>

( config: LayoutLMv3Config **kwargs )

参数

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

LayoutLMv3 模型在顶部带有序列分类头（在[CLS]标记的最终隐藏状态之上的线性层），例如用于文档图像分类任务的RVL-CDIP数据集。

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

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

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

• 将所有输入作为关键字参数（类似于 PyTorch 模型），或

• 将所有输入作为列表、元组或字典放在第一个位置参数中。

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

• 一个仅包含input_ids的单个张量，没有其他内容：model(input_ids)

• 一个长度可变的列表，其中包含按照文档字符串中给定的顺序的一个或多个输入张量：model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids])

• 一个字典，其中包含一个或多个与文档字符串中给定的输入名称相关联的输入张量：model({"input_ids": input_ids, "token_type_ids": token_type_ids})

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

call

<来源>

( input_ids: 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 ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFSequenceClassifierOutput or tuple(tf.Tensor)

参数

• input_ids（形状为(batch_size, sequence_length)的Numpy数组或tf.Tensor）- 词汇表中输入序列标记的索引。

  请注意，sequence_length = token_sequence_length + patch_sequence_length + 1，其中1代表[CLS]标记。查看pixel_values以获取patch_sequence_length。

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

  什么是输入 ID？

• bbox（形状为(batch_size, sequence_length, 4)的Numpy数组或tf.Tensor，可选）- 每个输入序列标记的边界框。选择范围为[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（形状为(batch_size, num_channels, height, width)的tf.Tensor）- 批量文档图像。每个图像被分成形状为(num_channels, config.patch_size, config.patch_size)的补丁，并且补丁的总数（=patch_sequence_length）等于((height / config.patch_size) * (width / config.patch_size))。

• attention_mask（形状为(batch_size, sequence_length)的tf.Tensor，可选）— 用于避免在填充标记索引上执行注意力的掩码。选择的掩码值在[0, 1]中：

  • 1 表示未被“masked”的标记，

  • 对于被masked的标记。

  请注意sequence_length = token_sequence_length + patch_sequence_length + 1，其中1代表[CLS]标记。有关patch_sequence_length，请参阅pixel_values。

  什么是注意力掩码？

• token_type_ids（Numpy 数组或形状为(batch_size, sequence_length)的tf.Tensor，可选）— 段标记索引，指示输入的第一部分和第二部分。索引在[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 数组或形状为(batch_size, sequence_length)的tf.Tensor，可选）— 每个输入序列标记在位置嵌入中的位置索引。在范围[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（形状为(num_heads,)或(num_layers, num_heads)的tf.Tensor，可选）— 用于使自注意力模块的选定头部失效的掩码。选择的掩码值在[0, 1]中：

  • 1 表示头部未被“masked”，

  • 0 表示头部被masked。

• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的tf.Tensor，可选）— 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您希望更多地控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。

• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。

• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

• return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。

返回

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

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

• loss（形状为(batch_size, )的tf.Tensor，可选，在提供labels时返回）— 分类（如果config.num_labels==1则为回归）损失。

• logits（形状为(batch_size, config.num_labels)的tf.Tensor）— 分类（如果config.num_labels==1则为回归）得分（SoftMax 之前）。

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

  模型在每一层输出的隐藏状态以及初始嵌入输出。

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

  在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

class transformers.TFLayoutLMv3ForTokenClassification

<来源>

( config: LayoutLMv3Config **kwargs )

参数

• config（LayoutLMv3Config](/docs/transformers/v4.37.2/en/main_classes/model#transformers.TFPreTrainedModel.from_pretrained)方法以加载模型权重。

LayoutLMv3 模型在顶部带有一个标记分类头（在最终隐藏状态的顶部有一个线性层），例如用于序列标记（信息提取）任务的FUNSD、SROIE、CORD和Kleister-NDA。

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

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

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

• 将所有输入作为关键字参数（类似于 PyTorch 模型），或

• 将所有输入作为列表、元组或字典放在第一个位置参数中。

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

• 只包含input_ids的单个张量，没有其他内容：model(input_ids)

• 按照文档字符串中给定的顺序，长度可变的列表，包含一个或多个输入张量：model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids])

• 一个字典，其中包含与文档字符串中给定的输入名称相关联的一个或多个输入张量：model({"input_ids": input_ids, "token_type_ids": token_type_ids})

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

call

<来源>

( input_ids: 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 ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFTokenClassifierOutput or tuple(tf.Tensor)

参数

• input_ids（形状为(batch_size, sequence_length)的Numpy数组或tf.Tensor）— 输入序列令牌在词汇表中的索引。

  注意，sequence_length = token_sequence_length + patch_sequence_length + 1，其中1代表[CLS]令牌。查看pixel_values以获取patch_sequence_length。

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

  什么是输入 ID？

• bbox（形状为(batch_size, sequence_length, 4)的Numpy数组或tf.Tensor，可选）— 每个输入序列令牌的边界框。选择范围为[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（形状为(batch_size, num_channels, height, width)的tf.Tensor）— 文档图像的批处理。每个图像被分成形状为(num_channels, config.patch_size, config.patch_size)的补丁，并且补丁的总数（=patch_sequence_length）等于((height / config.patch_size) * (width / config.patch_size))。

• attention_mask（形状为(batch_size, sequence_length)的tf.Tensor，可选）— 用于避免在填充令牌索引上执行注意力的掩码。选择在[0, 1]范围内的掩码值：

  • 1 表示未被掩码的令牌。

  • 0 表示被掩码的令牌。

  注意，sequence_length = token_sequence_length + patch_sequence_length + 1，其中1代表[CLS]令牌。查看pixel_values以获取patch_sequence_length。

  什么是注意力掩码？

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

  • 0 对应于句子 A令牌，

  • 1 对应于句子 B令牌。

  注意，sequence_length = token_sequence_length + patch_sequence_length + 1，其中1代表[CLS]令牌。查看pixel_values以获取patch_sequence_length。

  什么是令牌类型 ID？

• position_ids（形状为(batch_size, sequence_length)的Numpy数组或tf.Tensor，可选）— 每个输入序列令牌在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。

  注意，sequence_length = token_sequence_length + patch_sequence_length + 1，其中1代表[CLS]令牌。查看pixel_values以获取patch_sequence_length。

  什么是位置 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 (bool，可选） — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回的张量下的attentions。

• output_hidden_states (bool，可选） — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回的张量下的hidden_states。

• return_dict (bool，可选） — 是否返回 ModelOutput 而不是普通元组。

• labels (tf.Tensor of shape (batch_size, sequence_length)，可选） — 用于计算标记分类损失的标签。索引应在[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 of shape (n,)，可选，当提供labels时返回，其中 n 是未屏蔽标签的数量） — 分类损失。

• logits (tf.Tensor of shape (batch_size, sequence_length, config.num_labels)) — 分类得分（SoftMax 之前）。

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

  模型在每个层的隐藏状态以及初始嵌入输出。

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

  注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

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

class transformers.TFLayoutLMv3ForQuestionAnswering

< source >

( config: LayoutLMv3Config **kwargs )

参数

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

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

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

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

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

• 将所有输入作为关键字参数（类似于 PyTorch 模型），或者

• 将所有输入作为列表、元组或字典的第一个位置参数。

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

• 一个仅包含input_ids的单个张量，没有其他内容：model(input_ids)

• 一个长度可变的列表，其中包含一个或多个按照文档字符串中给定顺序的输入张量：model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids])

• 一个字典，其中包含一个或多个与文档字符串中给定的输入名称相关联的输入张量：model({"input_ids": input_ids, "token_type_ids": token_type_ids})

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

call

<来源>

( input_ids: 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 ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFQuestionAnsweringModelOutput or tuple(tf.Tensor)

参数

• input_ids（形状为(batch_size, sequence_length)的Numpy 数组或tf.Tensor） - 词汇表中输入序列标记的索引。

  请注意，sequence_length = token_sequence_length + patch_sequence_length + 1，其中1代表[CLS]标记。查看pixel_values以获取patch_sequence_length。

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

  什么是输入 ID？

• bbox（形状为(batch_size, sequence_length, 4)的Numpy 数组或tf.Tensor，可选） - 每个输入序列标记的边界框。在范围[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（形状为(batch_size, num_channels, height, width)的tf.Tensor） - 批量文档图像。每个图像被分成形状为(num_channels, config.patch_size, config.patch_size)的补丁，并且补丁的总数（=patch_sequence_length）等于((height / config.patch_size) * (width / config.patch_size))。

• attention_mask（形状为(batch_size, sequence_length)的tf.Tensor，可选）— 用于避免在填充标记索引上执行注意力的蒙版。蒙版值在[0, 1]中选择：

  • 1 表示标记未被遮蔽，

  • 0 表示标记被遮蔽。

  请注意，sequence_length = token_sequence_length + patch_sequence_length + 1，其中1代表[CLS]标记。有关patch_sequence_length的详细信息，请参见pixel_values。

  什么是注意力蒙版？

• token_type_ids（形状为(batch_size, sequence_length)的Numpy数组或tf.Tensor，可选）— 段标记索引，用于指示输入的第一部分和第二部分。索引在[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（形状为(batch_size, sequence_length)的Numpy数组或tf.Tensor，可选）— 每个输入序列标记在位置嵌入中的位置索引。在范围[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（形状为(num_heads,)或(num_layers, num_heads)的tf.Tensor，可选）— 用于使自注意力模块的选定头部无效的蒙版。蒙版值在[0, 1]中选择：

  • 1 表示头部未被遮蔽，

  • 0 表示头部被遮蔽。

• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的tf.Tensor，可选）— 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制权，以便将input_ids索引转换为相关向量，而不是模型的内部嵌入查找矩阵，则这很有用。

• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。

• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。

• return_dict（bool，可选）— 是否返回一个 ModelOutput 而不是一个普通元组。

• start_positions（形状为(batch_size,)的tf.Tensor，可选）— 用于计算标记分类损失的标记（索引）的标签的起始位置。位置被夹紧到序列的长度（sequence_length）。超出序列范围的位置不会用于计算损失。

• end_positions（形状为(batch_size,)的tf.Tensor，可选）— 用于计算标记分类损失的标记（索引）的标签。位置被夹紧到序列的长度（sequence_length）。超出序列范围的位置不会用于计算损失。

返回

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

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

• loss (tf.Tensor，形状为 (batch_size, )，可选，当提供 start_positions 和 end_positions 时返回） — 总跨度提取损失是起始位置和结束位置的交叉熵之和。

• start_logits (tf.Tensor，形状为 (batch_size, sequence_length)) — 跨度起始得分（SoftMax 之前）。

• end_logits (tf.Tensor，形状为 (batch_size, sequence_length)) — 跨度结束得分（SoftMax 之前）。

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

  模型在每个层的输出以及初始嵌入输出的隐藏状态。

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

  注意力权重在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

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

LayoutXLM

原文：huggingface.co/docs/transformers/v4.37.2/en/model_doc/layoutxlm

概述

LayoutXLM 是由 Yiheng Xu、Tengchao Lv、Lei Cui、Guoxin Wang、Yijuan Lu、Dinei Florencio、Cha Zhang、Furu Wei 提出的LayoutXLM: 多模态预训练用于多语言视觉丰富文档理解。它是在 53 种语言上训练的LayoutLMv2 模型的多语言扩展。

该论文的摘要如下：

最近，使用文本、布局和图像进行多模态预训练已经在视觉丰富文档理解任务中取得了 SOTA 性能，这表明跨不同模态的联合学习具有巨大潜力。在本文中，我们提出了 LayoutXLM，这是一个用于多语言文档理解的多模态预训练模型，旨在消除视觉丰富文档理解的语言障碍。为了准确评估 LayoutXLM，我们还介绍了一个名为 XFUN 的多语言表单理解基准数据集，其中包括 7 种语言（中文、日文、西班牙文、法文、意大利文、德文、葡萄牙文）的表单理解样本，并为每种语言手动标记了键值对。实验结果表明，LayoutXLM 模型在 XFUN 数据集上明显优于现有的 SOTA 跨语言预训练模型。

该模型由nielsr贡献。原始代码可在此处找到。

使用提示和示例

可以直接将 LayoutXLM 的权重插入到 LayoutLMv2 模型中，如下所示：

from transformers import LayoutLMv2Model

model = LayoutLMv2Model.from_pretrained("microsoft/layoutxlm-base")

请注意，LayoutXLM 有自己的分词器，基于 LayoutXLMTokenizer/LayoutXLMTokenizerFast。您可以按以下方式初始化它：

from transformers import LayoutXLMTokenizer

tokenizer = LayoutXLMTokenizer.from_pretrained("microsoft/layoutxlm-base")

与 LayoutLMv2 类似，您可以使用 LayoutXLMProcessor（内部应用 LayoutLMv2ImageProcessor 和 LayoutXLMTokenizer/LayoutXLMTokenizerFast）来为模型准备所有数据。

由于 LayoutXLM 的架构等同于 LayoutLMv2，可以参考 LayoutLMv2 的文档页面获取所有提示、代码示例和笔记本。

LayoutXLMTokenizer

class transformers.LayoutXLMTokenizer

<来源>

( vocab_file bos_token = '<s>' eos_token = '</s>' sep_token = '</s>' cls_token = '<s>' unk_token = '<unk>' pad_token = '<pad>' mask_token = '<mask>' cls_token_box = [0, 0, 0, 0] sep_token_box = [1000, 1000, 1000, 1000] pad_token_box = [0, 0, 0, 0] pad_token_label = -100 only_label_first_subword = True sp_model_kwargs: Optional = None **kwargs )

参数

• vocab_file (str) — 词汇文件路径。

• bos_token (str, 可选, 默认为 "<s>") — 在预训练期间使用的序列开始标记。可用作序列分类器标记。

  在使用特殊标记构建序列时，这不是用于序列开始的标记。使用的标记是cls_token。

• eos_token (str, 可选, 默认为 "</s>") — 序列结束标记。

  在使用特殊标记构建序列时，这不是用于序列结束的标记。使用的标记是sep_token。

• sep_token (str, 可选, 默认为 "</s>") — 分隔符标记，用于从多个序列构建序列，例如用于序列分类的两个序列或用于问题回答的文本和问题。它还用作使用特殊标记构建的序列的最后一个标记。

• cls_token (str, optional, defaults to "<s>") — 用于序列分类（整个序列的分类，而不是每个标记的分类）时使用的分类器标记。当使用特殊标记构建序列时，它是序列的第一个标记。

• unk_token (str, optional, defaults to "<unk>") — 未知标记。词汇表中没有的标记无法转换为 ID，而是设置为这个标记。

• pad_token (str, optional, defaults to "<pad>") — 用于填充的标记，例如在批处理不同长度的序列时使用。

• mask_token (str, optional, defaults to "<mask>") — 用于屏蔽值的标记。这是在使用掩码语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。

• cls_token_box (List[int], optional, defaults to [0, 0, 0, 0]) — 用于特殊[CLS]标记的边界框。

• sep_token_box (List[int], optional, defaults to [1000, 1000, 1000, 1000]) — 用于特殊[SEP]标记的边界框。

• pad_token_box (List[int], optional, defaults to [0, 0, 0, 0]) — 用于特殊[PAD]标记的边界框。

• pad_token_label (int, optional, defaults to -100) — 用于填充标记的标签。默认为-100，这是 PyTorch 的 CrossEntropyLoss 的ignore_index。

• only_label_first_subword (bool, optional, defaults to True) — 是否仅标记第一个子词，如果提供了单词标签。

• sp_model_kwargs (dict, optional) — 将传递给SentencePieceProcessor.__init__()方法。SentencePiece 的 Python 包装器可以用于设置：

  • enable_sampling：启用子词正则化。

  • nbest_size：unigram 的采样参数。对于 BPE-Dropout 无效。

    • nbest_size = {0,1}：不执行采样。

    • nbest_size > 1：从 nbest_size 结果中采样。

    • nbest_size < 0：假设 nbest_size 是无限的，并使用前向过滤和后向采样算法从所有假设（格）中采样。

  • alpha：用于 unigram 采样的平滑参数，以及 BPE-dropout 的合并操作的丢弃概率。

• sp_model (SentencePieceProcessor) — 用于每次转换（字符串、标记和 ID）的SentencePiece处理器。

改编自 RobertaTokenizer 和 XLNetTokenizer。基于SentencePiece。

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

__call__

<来源>

( text: Union text_pair: Union = None boxes: Union = None word_labels: Union = None add_special_tokens: bool = True padding: Union = False truncation: Union = None max_length: Optional = None stride: int = 0 pad_to_multiple_of: Optional = None return_tensors: Union = None return_token_type_ids: Optional = None return_attention_mask: Optional = None return_overflowing_tokens: bool = False return_special_tokens_mask: bool = False return_offsets_mapping: bool = False return_length: bool = False verbose: bool = True **kwargs ) → export const metadata = 'undefined';BatchEncoding

参数

• text (str, List[str], List[List[str]]) — 要编码的序列或序列批次。每个序列可以是一个字符串，一个字符串列表（单个示例的单词或一批示例的问题）或一个字符串列表的列表（单词批次）。

• text_pair (List[str], List[List[str]]) — 要编码的序列或序列批次。每个序列应该是一个字符串列表（预分词的字符串）。

• boxes (List[List[int]], List[List[List[int]]]) — 单词级边界框。每个边界框应该被归一化为 0-1000 的比例。

• word_labels (List[int], List[List[int]], optional) — 单词级整数标签（用于标记分类任务，如 FUNSD、CORD）。

• add_special_tokens (bool, optional, defaults to True) — 是否对序列进行编码，相对于其模型使用特殊标记。

• padding (bool, str 或 PaddingStrategy, optional, 默认为 False) — 激活和控制填充。接受以下值：

  • True 或 'longest'：填充到批次中最长的序列（如果只提供了单个序列，则不填充）。

  • 'max_length'：填充到指定的最大长度，使用参数max_length指定，或者填充到模型的最大可接受输入长度，如果未提供该参数。

  • False 或 'do_not_pad'（默认）：不填充（即，可以输出具有不同长度序列的批次）。

• truncation (bool, str 或 TruncationStrategy, optional, 默认为 False) — 激活和控制截断。接受以下值：

  • True 或 'longest_first'：截断到指定的最大长度，使用参数max_length指定，或者截断到模型的最大可接受输入长度，如果未提供该参数。如果提供了一对序列（或一批对序列），则逐个截断 token，从一对序列中最长的序列中删除一个 token。

  • 'only_first'：截断到指定的最大长度，使用参数max_length指定，或者截断到模型的最大可接受输入长度，如果未提供该参数。如果提供了一对序列（或一批对序列），则仅截断第一个序列。

  • 'only_second'：截断到指定的最大长度，使用参数max_length指定，或者截断到模型的最大可接受输入长度，如果未提供该参数。如果提供了一对序列（或一批对序列），则仅截断第二个序列。

  • False 或 'do_not_truncate'（默认）：不截断（即，可以输出序列长度大于模型最大可接受输入大小的批次）。

• max_length (int, optional) — 控制截断/填充参数使用的最大长度。

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

• stride (int, optional, 默认为 0) — 如果与max_length一起设置为一个数字，则当return_overflowing_tokens=True时返回的溢出 token 将包含截断序列末尾的一些 token，以提供截断和溢出序列之间的一些重叠。该参数的值定义重叠 token 的数量。

• pad_to_multiple_of (int, optional) — 如果设置，将序列填充到提供的值的倍数。这对于启用具有计算能力>= 7.5（Volta）的 NVIDIA 硬件上的 Tensor Cores 特别有用。

• return_tensors (str 或 TensorType, optional) — 如果设置，将返回张量而不是 Python 整数列表。可接受的值为：

  • 'tf'：返回 TensorFlow tf.constant对象。

  • 'pt'：返回 PyTorch torch.Tensor对象。

  • 'np'：返回 Numpy np.ndarray对象。

• return_token_type_ids (bool, optional) — 是否返回 token 类型 ID。如果保持默认设置，将根据特定分词器的默认设置返回 token 类型 ID，由return_outputs属性定义。

  什么是 token 类型 ID？

• return_attention_mask (bool, optional) — 是否返回注意力掩码。如果保持默认设置，将根据特定分词器的默认设置返回注意力掩码，由return_outputs属性定义。

  什么是注意力掩码？

• return_overflowing_tokens (bool, optional, 默认为 False) — 是否返回溢出的标记序列。如果提供了一对输入 ID 序列（或一批对），并且 truncation_strategy = longest_first 或 True，则会引发错误，而不是返回溢出的标记。

• return_special_tokens_mask (bool, optional, 默认为 False) — 是否返回特殊标记掩码信息。

• return_offsets_mapping (bool, optional, 默认为 False) — 是否返回每个标记的 (char_start, char_end)。

  仅在继承自 PreTrainedTokenizerFast 的快速标记器上可用，如果使用 Python 的标记器，此方法将引发 NotImplementedError。

• return_length (bool, optional, 默认为 False) — 是否返回编码输入的长度。

• verbose (bool, optional, 默认为 True) — 是否打印更多信息和警告。**kwargs — 传递给 self.tokenize() 方法

返回

BatchEncoding

具有以下字段的 BatchEncoding：

• input_ids — 要提供给模型的标记 ID 列表。

  什么是输入 ID？

• bbox — 要提供给模型的边界框列表。

• token_type_ids — 要提供给模型的标记类型 ID 列表（当 return_token_type_ids=True 或 token_type_ids 在 self.model_input_names 中时）。

  什么是标记类型 ID？

• attention_mask — 指定哪些标记应该被模型关注的索引列表（当 return_attention_mask=True 或 attention_mask 在 self.model_input_names 中时）。

  什么是注意力掩码？

• labels — 要提供给模型的标签列表（当指定 word_labels 时）。

• overflowing_tokens — 溢出的标记序列列表（当指定 max_length 并且 return_overflowing_tokens=True 时）。

• num_truncated_tokens — 被截断的标记数（当指定 max_length 并且 return_overflowing_tokens=True 时）。

• special_tokens_mask — 由 0 和 1 组成的列表，其中 1 指定添加的特殊标记，0 指定常规序列标记（当 add_special_tokens=True 和 return_special_tokens_mask=True 时）。

• length — 输入的长度（当 return_length=True 时）。

标记化和准备模型的一个或多个序列或一个或多个序列对的主要方法，具有单词级归一化的边界框和可选标签。

build_inputs_with_special_tokens

< source >

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

参数

• token_ids_0 (List[int]) — 要添加特殊标记的 ID 列表。

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

返回

List[int]

具有适当特殊标记的输入 ID 列表。

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

• 单个序列：<s> X </s>

• 序列对：<s> A </s></s> B </s>

get_special_tokens_mask

< source >

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

参数

• token_ids_0 (List[int]) — ID 列表。

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

• already_has_special_tokens (bool, optional, 默认为 False) — 标记列表是否已经使用特殊标记格式化为模型。

返回

List[int]

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

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

create_token_type_ids_from_sequences

<来源>

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

参数

• token_ids_0 (List[int]) — ID 列表。

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

返回

List[int]

零的列表。

从传递的两个序列创建用于序列对分类任务的掩码。XLM-RoBERTa 不使用标记类型 ID，因此返回零的列表。

save_vocabulary

<来源>

( save_directory: str filename_prefix: Optional = None )

LayoutXLMTokenizerFast

class transformers.LayoutXLMTokenizerFast

<来源>

( vocab_file = None tokenizer_file = None bos_token = '<s>' eos_token = '</s>' sep_token = '</s>' cls_token = '<s>' unk_token = '<unk>' pad_token = '<pad>' mask_token = '<mask>' cls_token_box = [0, 0, 0, 0] sep_token_box = [1000, 1000, 1000, 1000] pad_token_box = [0, 0, 0, 0] pad_token_label = -100 only_label_first_subword = True **kwargs )

参数

• vocab_file (str) — 词汇文件路径。

• bos_token (str, optional, defaults to "<s>") — 在预训练期间使用的序列开始标记。可以用作序列分类器标记。

  在使用特殊标记构建序列时，这不是用于序列开始的标记。使用的标记是cls_token。

• eos_token (str, optional, defaults to "</s>") — 序列结束标记。

  在使用特殊标记构建序列时，这不是用于序列结束的标记。使用的标记是sep_token。

• sep_token (str, optional, defaults to "</s>") — 分隔符标记，在构建来自多个序列的序列时使用，例如用于序列分类的两个序列或用于文本和问题的问题回答。它也用作使用特殊标记构建的序列的最后一个标记。

• cls_token (str, optional, defaults to "<s>") — 用于序列分类时使用的分类器标记（对整个序列进行分类，而不是对每个标记进行分类）。当使用特殊标记构建序列时，它是序列的第一个标记。

• unk_token (str, optional, defaults to "<unk>") — 未知标记。词汇表中没有的标记无法转换为 ID，而是设置为此标记。

• pad_token (str, optional, defaults to "<pad>") — 用于填充的标记，例如在批处理不同长度的序列时使用。

• mask_token (str, optional, defaults to "<mask>") — 用于屏蔽值的标记。在使用掩码语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。

• cls_token_box (List[int], optional, defaults to [0, 0, 0, 0]) — 用于特殊[CLS]标记的边界框。

• sep_token_box (List[int], optional, defaults to [1000, 1000, 1000, 1000]) — 用于特殊[SEP]标记的边界框。

• pad_token_box (List[int], optional, defaults to [0, 0, 0, 0]) — 用于特殊[PAD]标记的边界框。

• pad_token_label (int, optional, defaults to -100) — 用于填充标记的标签。默认为-100，这是 PyTorch 的 CrossEntropyLoss 的ignore_index。

• only_label_first_subword (bool, optional, defaults to True) — 是否仅标记第一个子词，如果提供了单词标签。

• additional_special_tokens (List[str], optional, defaults to ["<s>NOTUSED", "</s>NOTUSED"]) — 分词器使用的额外特殊标记。

构建一个“快速” LayoutXLM 分词器（由 HuggingFace 的 tokenizers 库支持）。改编自 RobertaTokenizer 和 XLNetTokenizer。基于 BPE。

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

__call__

<来源>

( text: Union text_pair: Union = None boxes: Union = None word_labels: Union = None add_special_tokens: bool = True padding: Union = False truncation: Union = None max_length: Optional = None stride: int = 0 pad_to_multiple_of: Optional = None return_tensors: Union = None return_token_type_ids: Optional = None return_attention_mask: Optional = None return_overflowing_tokens: bool = False return_special_tokens_mask: bool = False return_offsets_mapping: bool = False return_length: bool = False verbose: bool = True **kwargs ) → export const metadata = 'undefined';BatchEncoding

参数

• text (str, List[str], List[List[str]]) — 要编码的序列或序列批次。每个序列可以是一个字符串，一个字符串列表（单个示例的单词或一批示例的问题），或一个字符串列表的列表（单词批次）。

• text_pair (List[str], List[List[str]]) — 要编码的序列或序列批次。每个序列应该是一个字符串列表（预分词的字符串）。

• boxes (List[List[int]], List[List[List[int]]]) — 单词级别的边界框。每个边界框应标准化为 0-1000 的比例。

• word_labels (List[int], List[List[int]], 可选) — 单词级别的整数标签（用于诸如 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, optional, 默认为 0) — 如果设置为一个数字，并且与 max_length 一起使用，当 return_overflowing_tokens=True 时返回的溢出 token 将包含截断序列末尾的一些 token，以提供截断和溢出序列之间的一些重叠。此参数的值定义重叠 token 的数量。

• pad_to_multiple_of (int, optional) — 如果设置，将填充序列到提供的值的倍数。这对于在具有计算能力 >= 7.5（Volta）的 NVIDIA 硬件上启用 Tensor Cores 特别有用。

• return_tensors (str 或 TensorType, optional) — 如果设置，将返回张量而不是 Python 整数列表。可接受的值为：

  • 'tf': 返回 TensorFlow tf.constant 对象。

  • 'pt': 返回 PyTorch torch.Tensor 对象。

  • 'np': 返回 Numpy np.ndarray 对象。

• return_token_type_ids (bool, optional) — 是否返回 token 类型 ID。如果保持默认设置，将根据特定分词器的默认值返回 token 类型 ID，由 return_outputs 属性定义。

  什么是 token 类型 ID？

• return_attention_mask (bool, optional) — 是否返回注意力掩码。如果保持默认设置，将根据特定分词器的默认值返回注意力掩码，由 return_outputs 属性定义。

  什么是注意力掩码？

• return_overflowing_tokens (bool, optional, 默认为 False) — 是否返回溢出的 token 序列。如果提供了一对输入 id 序列（或一批对）并且 truncation_strategy = longest_first 或 True，则会引发错误，而不是返回溢出的 token。

• return_special_tokens_mask (bool, optional, 默认为 False) — 是否返回特殊 token 掩码信息。

• return_offsets_mapping (bool, optional, 默认为 False) — 是否返回每个 token 的 (char_start, char_end)。

  这仅适用于继承自 PreTrainedTokenizerFast 的快速分词器，如果使用 Python 的分词器，此方法将引发 NotImplementedError。

• return_length (bool, optional, 默认为 False) — 是否返回编码输入的长度。

• verbose (bool, optional, 默认为 True) — 是否打印更多信息和警告。 **kwargs — 传递给 self.tokenize() 方法

返回

BatchEncoding

一个包含以下字段的 BatchEncoding：

• input_ids — 要提供给模型的 token id 列表。

  什么是输入 ID？

• bbox — 要提供给模型的边界框列表。

• token_type_ids — 要提供给模型的 token 类型 id 列表（当 return_token_type_ids=True 或 token_type_ids 在 self.model_input_names 中时）。

  什么是 token 类型 ID？

• attention_mask — 指定哪些 token 应该被模型关注的索引列表（当 return_attention_mask=True 或 attention_mask 在 self.model_input_names 中时）。

  什么是注意力掩码？

• labels — 要提供给模型的标签列表（当指定 word_labels 时）。

• overflowing_tokens — 溢出的 token 序列列表（当指定 max_length 并且 return_overflowing_tokens=True 时）。

• num_truncated_tokens — 截断的标记数量（当指定max_length并且return_overflowing_tokens=True时）。

• special_tokens_mask — 由 0 和 1 组成的列表，其中 1 指定添加的特殊标记，0 指定常规序列标记（当add_special_tokens=True且return_special_tokens_mask=True时）。

• length — 输入的长度（当return_length=True时）。

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

LayoutXLMProcessor

class transformers.LayoutXLMProcessor

< source >

( image_processor = None tokenizer = None **kwargs )

参数

• image_processor（LayoutLMv2ImageProcessor，可选） — LayoutLMv2ImageProcessor 的实例。图像处理器是必需的输入。

• tokenizer（LayoutXLMTokenizer或LayoutXLMTokenizerFast，可选） — LayoutXLMTokenizer 或 LayoutXLMTokenizerFast 的实例。标记器是必需的输入。

构建一个 LayoutXLM 处理器，将 LayoutXLM 图像处理器和 LayoutXLM 标记器组合成一个单一处理器。

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

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

__call__

< source >

( images text: Union = None text_pair: Union = None boxes: Union = None word_labels: Union = None add_special_tokens: bool = True padding: Union = False truncation: Union = 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参数转发给~LayoutLMv2ImagePrpcessor.__call__。如果LayoutLMv2ImagePrpcessor初始化时apply_ocr设置为True，它将获取的单词和边界框以及其他参数传递给call()并返回输出，同时返回调整大小后的images。如果LayoutLMv2ImagePrpcessor初始化时apply_ocr设置为False，它将用户指定的单词（text/text_pair）和boxes以及其他参数传递给 call()并返回输出，同时返回调整大小后的images。

更多信息请参考上述两种方法的文档字符串。

LiLT

原文：huggingface.co/docs/transformers/v4.37.2/en/model_doc/lilt

概述

LiLT 模型在Jiapeng Wang, Lianwen Jin, Kai Ding 撰写的《LiLT: A Simple yet Effective Language-Independent Layout Transformer for Structured Document Understanding》中提出。LiLT 允许将任何预训练的 RoBERTa 文本编码器与轻量级的 Layout Transformer 结合起来，以实现多种语言的 LayoutLM 类似文档理解。

从论文摘要中得出的结论是：

结构化文档理解近年来引起了广泛关注并取得了显著进展，这归功于其在智能文档处理中的关键作用。然而，大多数现有的相关模型只能处理特定语言（通常是英语）的文档数据，这些文档数据包含在预训练集合中，这是极其有限的。为了解决这个问题，我们提出了一个简单而有效的 Language-independent Layout Transformer（LiLT）用于结构化文档理解。LiLT 可以在单一语言的结构化文档上进行预训练，然后直接在其他语言上进行对应的现成的单语/多语预训练文本模型的微调。在八种语言上的实验结果表明，LiLT 可以在各种广泛使用的下游基准测试中取得竞争性甚至优越的性能，这使得可以从文档布局结构的预训练中获益而不受语言限制。

LiLT 架构。摘自原始论文。

此模型由nielsr贡献。原始代码可以在此处找到。

使用提示

• 将 Language-Independent Layout Transformer 与来自hub的新 RoBERTa 检查点结合起来，请参考此指南。脚本将导致config.json和pytorch_model.bin文件被存储在本地。完成此操作后，可以执行以下操作（假设您已登录您的 HuggingFace 帐户）：

from transformers import LiltModel

model = LiltModel.from_pretrained("path_to_your_files")
model.push_to_hub("name_of_repo_on_the_hub")

• 在为模型准备数据时，请确保使用与您与 Layout Transformer 结合的 RoBERTa 检查点相对应的标记词汇表。

• 由于lilt-roberta-en-base使用与 LayoutLMv3 相同的词汇表，因此可以使用 LayoutLMv3TokenizerFast 来为模型准备数据。对于lilt-roberta-en-base也是如此：可以使用 LayoutXLMTokenizerFast 来为该模型准备数据。

资源

官方 Hugging Face 和社区（由🌎表示）资源列表，可帮助您开始使用 LiLT。

• 可以在此处找到 LiLT 的演示笔记本。

文档资源

• 文本分类任务指南

• 标记分类任务指南

• 问答任务指南

如果您有兴趣提交资源以包含在此处，请随时打开 Pull Request，我们将对其进行审查！资源应该展示一些新内容，而不是重复现有资源。

LiltConfig

class transformers.LiltConfig

<来源>

( vocab_size = 30522 hidden_size = 768 num_hidden_layers = 12 num_attention_heads = 12 intermediate_size = 3072 hidden_act = 'gelu' hidden_dropout_prob = 0.1 attention_probs_dropout_prob = 0.1 max_position_embeddings = 512 type_vocab_size = 2 initializer_range = 0.02 layer_norm_eps = 1e-12 pad_token_id = 0 position_embedding_type = 'absolute' classifier_dropout = None channel_shrink_ratio = 4 max_2d_position_embeddings = 1024 **kwargs )

参数

• vocab_size (int, optional, 默认为 30522) — LiLT 模型的词汇量。定义了在调用 LiltModel 时可以表示的不同标记数量。

• hidden_size (int, optional, 默认为 768) — 编码器层和池化器层的维度。应为 24 的倍数。

• num_hidden_layers (int, optional, 默认为 12) — Transformer 编码器中的隐藏层数量。

• num_attention_heads (int, optional, 默认为 12) — Transformer 编码器中每个注意力层的注意力头数量。

• intermediate_size (int, optional, 默认为 3072) — Transformer 编码器中“中间”（通常称为前馈）层的维度。

• hidden_act (str 或 Callable, optional, 默认为"gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu", "relu", "silu" 和 "gelu_new"。

• hidden_dropout_prob (float, optional, 默认为 0.1) — 嵌入层、编码器和池化器中所有全连接层的 dropout 概率。

• attention_probs_dropout_prob (float, optional, 默认为 0.1) — 注意力概率的 dropout 比率。

• max_position_embeddings (int, optional, 默认为 512) — 该模型可能使用的最大序列长度。通常设置为较大的值以防万一（例如 512、1024 或 2048）。

• type_vocab_size (int, optional, 默认为 2) — 在调用 LiltModel 时传递的token_type_ids的词汇量。

• initializer_range (float, optional, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。

• layer_norm_eps (float, optional, 默认为 1e-12) — 层归一化层使用的 epsilon。

• position_embedding_type (str, optional, 默认为"absolute") — 位置嵌入的类型。选择"absolute", "relative_key", "relative_key_query"之一。对于位置嵌入，请使用"absolute"。有关"relative_key"的更多信息，请参阅Self-Attention with Relative Position Representations (Shaw et al.)。有关"relative_key_query"的更多信息，请参阅Improve Transformer Models with Better Relative Position Embeddings (Huang et al.)中的Method 4。

• classifier_dropout (float, optional) — 分类头的 dropout 比率。

• channel_shrink_ratio (int, optional, 默认为 4) — 与布局嵌入的hidden_size相比，通道维度的收缩比率。

• max_2d_position_embeddings (int, optional, 默认为 1024) — 2D 位置嵌入可能使用的最大值。通常设置为较大的值以防万一（例如 1024）。

这是一个配置类，用于存储 LiltModel 的配置。根据指定的参数实例化一个 LiLT 模型，定义模型架构。使用默认值实例化配置将产生与 LiLT SCUT-DLVCLab/lilt-roberta-en-base架构类似的配置。配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。

示例：

>>> from transformers import LiltConfig, LiltModel

>>> # Initializing a LiLT SCUT-DLVCLab/lilt-roberta-en-base style configuration
>>> configuration = LiltConfig()
>>> # Randomly initializing a model from the SCUT-DLVCLab/lilt-roberta-en-base style configuration
>>> model = LiltModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config

LiltModel

class transformers.LiltModel

< source >

( config add_pooling_layer = True )

参数

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

裸 LiLT 模型变压器输出原始隐藏状态，没有特定的头部。这个模型继承自 PreTrainedModel。检查超类文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入、修剪头等）。

这个模型也是一个 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 output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutputWithPooling or tuple(torch.FloatTensor)

参数

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

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

  什么是 input IDs？

• bbox (torch.LongTensor of shape (batch_size, sequence_length, 4), optional) — 每个输入序列标记的边界框。选择范围为[0, config.max_2d_position_embeddings-1]。每个边界框应该是一个规范化版本，格式为(x0, y0, x1, y1)，其中(x0, y0)对应于边界框左上角的位置，(x1, y1)表示右下角的位置。有关规范化，请参见概述。

• attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]之间：

  • 1 表示未被masked的标记，

  • 0 表示被masked的标记。

  什么是 attention masks？

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

  • 0 对应于句子 A标记，

  • 1 对应于句子 B标记。

  什么是 token type IDs？

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

  什么是 position IDs？

• head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于使自注意力模块中的选定头部失效的掩码。掩码值选择在[0, 1]之间：

  • 1 表示头部未被masked，

  • 0 表示头部被masked。

• inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制权，以便将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。

• output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。

• output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

• return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。

返回

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

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

• last_hidden_state (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列。

• pooler_output (torch.FloatTensor，形状为(batch_size, hidden_size)) — 序列第一个标记（分类标记）的最后一层隐藏状态，在通过用于辅助预训练任务的层进一步处理后。例如，对于 BERT 系列模型，这返回经过线性层和 tanh 激活函数处理后的分类标记。线性层的权重在预训练期间从下一个句子预测（分类）目标中训练。

• hidden_states (tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入的输出，如果模型有嵌入层，+ 一个用于每个层的输出）。

  模型在每一层输出的隐藏状态以及可选的初始嵌入输出。

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

  注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoTokenizer, AutoModel
>>> from datasets import load_dataset

>>> tokenizer = AutoTokenizer.from_pretrained("SCUT-DLVCLab/lilt-roberta-en-base")
>>> model = AutoModel.from_pretrained("SCUT-DLVCLab/lilt-roberta-en-base")

>>> dataset = load_dataset("nielsr/funsd-layoutlmv3", split="train")
>>> example = dataset[0]
>>> words = example["tokens"]
>>> boxes = example["bboxes"]

>>> encoding = tokenizer(words, boxes=boxes, return_tensors="pt")

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

LiltForSequenceClassification

class transformers.LiltForSequenceClassification

<来源>

( config )

参数

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

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

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

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

forward

<来源>

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

参数

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

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

  什么是输入 ID？

• bbox (torch.LongTensor of shape (batch_size, sequence_length, 4), optional) — 每个输入序列标记的边界框。选择范围为[0, config.max_2d_position_embeddings-1]。每个边界框应该是(x0, y0, x1, y1)格式的归一化版本，其中(x0, y0)对应于边界框左上角的位置，(x1, y1)表示右下角的位置。有关归一化，请参阅概述。

• attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]之间：

  • 对于未被masked的标记为 1，

  • 对于被masked的标记为 0。

  什么是注意力掩码？

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

  • 0 对应于句子 A标记，

  • 1 对应于句子 B标记。

  什么是标记类型 ID？

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

  什么是位置 ID？

• head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于使自注意力模块中选择的头部失效的掩码。掩码值选择在[0, 1]之间：

  • 1 表示头部未被masked，

  • 0 表示头部被masked。

• inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，您可以选择直接传递嵌入表示而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，这将非常有用，而不是使用模型的内部嵌入查找矩阵。

• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。

• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

• labels (torch.LongTensor，形状为(batch_size,), 可选的) — 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels == 1，则计算回归损失（均方损失），如果config.num_labels > 1，则计算分类损失（交叉熵）。

返回

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

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

• 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时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入的输出，如果模型有一个嵌入层，+ 一个用于每一层的输出）。

  模型在每一层输出的隐藏状态以及可选的初始嵌入输出。

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

  在自注意力头中用于计算加权平均值的注意力 softmax 之后的注意力权重。

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

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

示例：

>>> from transformers import AutoTokenizer, AutoModelForSequenceClassification
>>> from datasets import load_dataset

>>> tokenizer = AutoTokenizer.from_pretrained("SCUT-DLVCLab/lilt-roberta-en-base")
>>> model = AutoModelForSequenceClassification.from_pretrained("SCUT-DLVCLab/lilt-roberta-en-base")

>>> dataset = load_dataset("nielsr/funsd-layoutlmv3", split="train")
>>> example = dataset[0]
>>> words = example["tokens"]
>>> boxes = example["bboxes"]

>>> encoding = tokenizer(words, boxes=boxes, return_tensors="pt")

>>> outputs = model(**encoding)
>>> predicted_class_idx = outputs.logits.argmax(-1).item()
>>> predicted_class = model.config.id2label[predicted_class_idx]

LiltForTokenClassification

class transformers.LiltForTokenClassification

<来源>

( config )

参数

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

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

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

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

forward

<来源>

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

参数

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

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

  什么是输入 ID？

• bbox (torch.LongTensor，形状为(batch_size, sequence_length, 4)，可选) — 每个输入序列标记的边界框。在范围[0, config.max_2d_position_embeddings-1]中选择。每个边界框应该是(x0, y0, x1, y1)格式的归一化版本，其中(x0, y0)对应于边界框左上角的位置，(x1, y1)表示右下角的位置。有关归一化，请参阅概览。

• attention_mask (torch.FloatTensor，形状为(batch_size, sequence_length)，可选) — 避免在填充标记索引上执行注意力的掩码。掩码值在[0, 1]中选择：

  • 对于未屏蔽的标记，

  • 对于被屏蔽的标记，为 0。

  什么是注意力掩码？

• token_type_ids (torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 指示输入的第一部分和第二部分的段标记索引。索引在[0, 1]中选择：

  • 0 对应于 句子 A 标记，

  • 1 对应于 句子 B 标记。

  什么是标记类型 ID？

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

  什么是位置 ID？

• head_mask (torch.FloatTensor，形状为(num_heads,)或(num_layers, num_heads)，可选) — 用于使自注意力模块的选定头部失效的掩码。掩码值在[0, 1]中选择：

  • 1 表示头部未屏蔽，

  • 0 表示头部被屏蔽。

• inputs_embeds (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。

• output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。

• output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

• return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。

• labels (torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 用于计算标记分类损失的标签。索引应在[0, ..., config.num_labels - 1]中。

返回

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

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

• loss（形状为(1,)的torch.FloatTensor，可选，当提供labels时返回）— 分类损失。

• logits（形状为(batch_size, sequence_length, config.num_labels)的torch.FloatTensor）— 分类分数（SoftMax 之前）。

• hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）— 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入的输出和每一层的输出）。

  模型在每一层输出处的隐藏状态以及可选的初始嵌入输出。

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

  注意力权重在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoTokenizer, AutoModelForTokenClassification
>>> from datasets import load_dataset

>>> tokenizer = AutoTokenizer.from_pretrained("SCUT-DLVCLab/lilt-roberta-en-base")
>>> model = AutoModelForTokenClassification.from_pretrained("SCUT-DLVCLab/lilt-roberta-en-base")

>>> dataset = load_dataset("nielsr/funsd-layoutlmv3", split="train")
>>> example = dataset[0]
>>> words = example["tokens"]
>>> boxes = example["bboxes"]

>>> encoding = tokenizer(words, boxes=boxes, return_tensors="pt")

>>> outputs = model(**encoding)
>>> predicted_class_indices = outputs.logits.argmax(-1)

LiltForQuestionAnswering

class transformers.LiltForQuestionAnswering

< source >

( config )

参数

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

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

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

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

forward

< source >

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

参数

• input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）— 词汇表中输入序列标记的索引。

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

  什么是输入 ID？

• bbox (torch.LongTensor，形状为(batch_size, sequence_length, 4)，optional) — 每个输入序列标记的边界框。选择范围为[0, config.max_2d_position_embeddings-1]。每个边界框应该是(x0, y0, x1, y1)格式的归一化版本，其中(x0, y0)对应于边界框左上角的位置，(x1, y1)表示右下角的位置。有关归一化，请参阅概述。

• attention_mask (torch.FloatTensor，形状为(batch_size, sequence_length)，optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]之间：

  • 1 表示未被masked的标记，

  • 0 表示被masked的标记。

  什么是注意力掩码？

• token_type_ids (torch.LongTensor，形状为(batch_size, sequence_length)，optional) — 段标记索引，指示输入的第一部分和第二部分。索引选择在[0, 1]之间：

  • 0 对应于句子 A标记，

  • 1 对应于句子 B标记。

  什么是标记类型 ID？

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

  什么是位置 ID？

• head_mask (torch.FloatTensor，形状为(num_heads,)或(num_layers, num_heads)，optional) — 用于使自注意力模块的选定头部失效的掩码。掩码值选择在[0, 1]之间：

  • 1 表示头部未被masked，

  • 0 表示头部被masked。

• inputs_embeds (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，optional) — 可选地，可以直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。

• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的attentions。

• output_hidden_states (bool，optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。

• return_dict (bool，optional) — 是否返回 ModelOutput 而不是普通元组。

• start_positions (torch.LongTensor，形状为(batch_size,)，optional) — 用于计算标记分类损失的标记跨度开始位置（索引）的标签。位置被夹紧到序列的长度(sequence_length)。序列外的位置不会用于计算损失。

• end_positions (torch.LongTensor，形状为(batch_size,)，optional) — 用于计算标记分类损失的标记跨度结束位置（索引）的标签。位置被夹紧到序列的长度(sequence_length)。序列外的位置不会用于计算损失。

返回

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

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

• loss（形状为(1,)的torch.FloatTensor，可选，当提供labels时返回）- 总跨度提取损失是起始和结束位置的交叉熵之和。

• 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时返回）- 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入层的输出，如果模型有嵌入层，+ 一个用于每个层的输出）。

  模型在每一层输出的隐藏状态加上可选的初始嵌入输出。

• attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）- 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每个层一个）。

  在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoTokenizer, AutoModelForQuestionAnswering
>>> from datasets import load_dataset

>>> tokenizer = AutoTokenizer.from_pretrained("SCUT-DLVCLab/lilt-roberta-en-base")
>>> model = AutoModelForQuestionAnswering.from_pretrained("SCUT-DLVCLab/lilt-roberta-en-base")

>>> dataset = load_dataset("nielsr/funsd-layoutlmv3", split="train")
>>> example = dataset[0]
>>> words = example["tokens"]
>>> boxes = example["bboxes"]

>>> encoding = tokenizer(words, boxes=boxes, return_tensors="pt")

>>> outputs = model(**encoding)

>>> answer_start_index = outputs.start_logits.argmax()
>>> answer_end_index = outputs.end_logits.argmax()

>>> predict_answer_tokens = encoding.input_ids[0, answer_start_index : answer_end_index + 1]
>>> predicted_answer = tokenizer.decode(predict_answer_tokens)

LLaVa

原始文本：huggingface.co/docs/transformers/v4.37.2/en/model_doc/llava

概述

LLaVa 是通过在 GPT 生成的多模态指令遵循数据上进行 LlamA/Vicuna 微调而训练的开源聊天机器人。它是一种基于变压器架构的自回归语言模型。换句话说，它是为聊天/指令微调的 LLMs 的多模态版本。

LLaVa 模型最初在视觉指导调整中提出，并在通过视觉指导调整改进基线中由 Haotian Liu、Chunyuan Li、Yuheng Li 和 Yong Jae Lee 改进。

论文摘要如下：

最近，大型多模态模型（LMM）在视觉指导调整方面取得了令人鼓舞的进展。在这篇文章中，我们展示了 LLaVA 中的全连接视觉-语言跨模态连接器出人意料地强大且高效。通过对 LLaVA 进行简单修改，即使用 CLIP-ViT-L-336px 与 MLP 投影，并添加学术任务导向的 VQA 数据以及简单的响应格式提示，我们建立了更强的基线，实现了 11 个基准测试中的最新技术。我们的最终 13B 检查点仅使用了 120 万个公开可用的数据，并在单个 8-A100 节点上的约 1 天内完成了完整训练。我们希望这可以使最先进的 LMM 研究更易于访问。代码和模型将会公开发布

LLaVa 架构。摘自原始论文。

该模型由ArthurZ和ybelkada贡献。原始代码可以在这里找到。

使用提示

• 我们建议用户在计算批量生成时使用padding_side="left"，因为这会导致更准确的结果。只需确保在生成之前调用processor.tokenizer.padding_side = "left"。

• 请注意，该模型尚未明确训练以处理同一提示中的多个图像，尽管从技术上讲这是可能的，但您可能会遇到不准确的结果。

• 为了获得更好的结果，我们建议用户使用正确的提示格式提示模型：

"USER: <image>\n<prompt>ASSISTANT:"

对于多轮对话：

"USER: <image>\n<prompt1>ASSISTANT: <answer1>USER: <prompt2>ASSISTANT: <answer2>USER: <prompt3>ASSISTANT:"

使用 Flash Attention 2

Flash Attention 2 是先前优化的更快、更优化的版本，请参阅性能文档中的 Flash Attention 2 部分。

资源

一份官方 Hugging Face 和社区（由🌎表示）资源列表，可帮助您开始使用 BEiT。

图像到文本

• 关于如何在免费的 Google Colab 实例上运行 Llava 的Google Colab 演示，利用 4 位推理。

• 展示批量推理的类似笔记本。🌎

LlavaConfig

class transformers.LlavaConfig

<来源>

( vision_config = None text_config = None ignore_index = -100 image_token_index = 32000 projector_hidden_act = 'gelu' vision_feature_select_strategy = 'default' vision_feature_layer = -2 vocab_size = 32000 **kwargs )

参数

• vision_config（LlavaVisionConfig，可选）— 自定义视觉配置或字典

• text_config（Union[AutoConfig, dict]，可选）— 文本主干的配置对象。可以是LlamaConfig或MistralConfig之一。

• ignore_index（int，可选，默认为-100）— 损失函数的忽略索引。

• image_token_index（int，可选，默认为 32000）— 用于编码图像提示的图像标记索引。

• projector_hidden_act（str，可选，默认为"gelu"）— 多模态投影器使用的激活函数。

• vision_feature_select_strategy (str, optional, 默认为"default") — 用于从 CLIP 骨干中选择视觉特征的特征选择策略。

• vision_feature_layer (int, optional, 默认为-2) — 选择视觉特征的层的索引。

• vocab_size (int, optional, 默认为 32000) — Llava 模型的词汇表大小。定义了在调用~LlavaForConditionalGeneration 时可以由inputs_ids表示的不同标记数量。

这是用于存储 LlavaForConditionalGeneration 配置的配置类。它用于根据指定的参数实例化一个 Llava 模型，定义模型架构。使用默认值实例化配置将产生类似于 Llava-9B 的配置。

例如 llava-hf/llava-9b

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

示例：

>>> from transformers import LlavaForConditionalGeneration, LlavaConfig, CLIPVisionConfig, LlamaConfig

>>> # Initializing a CLIP-vision config
>>> vision_config = CLIPVisionConfig()

>>> # Initializing a Llama config
>>> text_config = LlamaConfig()

>>> # Initializing a Llava llava-1.5-7b style configuration
>>> configuration = LlavaConfig(vision_config, text_config)

>>> # Initializing a model from the llava-1.5-7b style configuration
>>> model = LlavaForConditionalGeneration(configuration)

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

LlavaProcessor

class transformers.LlavaProcessor

<来源>

( image_processor = None tokenizer = None )

参数

• image_processor (CLIPImageProcessor, optional) — 图像处理器是必需的输入。

• tokenizer (LlamaTokenizerFast, optional) — Tokenizer 是必需的输入。

构建一个 Llava 处理器，将 Llava 图像处理器和 Llava 分词器封装成一个单一处理器。

LlavaProcessor 提供了 CLIPImageProcessor 和 LlamaTokenizerFast 的所有功能。查看__call__()和 decode()以获取更多信息。

batch_decode

<来源>

( *args **kwargs )

此方法将所有参数转发给 LlamaTokenizerFast 的 batch_decode()。请参考此方法的文档字符串以获取更多信息。

decode

<来源>

( *args **kwargs )

此方法将所有参数转发给 LlamaTokenizerFast 的 decode()。请参考此方法的文档字符串以获取更多信息。

LlavaForConditionalGeneration

class transformers.LlavaForConditionalGeneration

<来源>

( config: LlavaConfig )

参数

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

LLAVA 模型由视觉主干和语言模型组成。此模型继承自 PreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入、修剪头等）。

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

forward

<来源>

( input_ids: LongTensor = None pixel_values: FloatTensor = None attention_mask: Optional = None position_ids: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None vision_feature_layer: Optional = None vision_feature_select_strategy: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.llava.modeling_llava.LlavaCausalLMOutputWithPast or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）—词汇表中输入序列标记的索引。默认情况下，如果提供填充，则将忽略填充。

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

  什么是输入 ID？

• pixel_values (torch.FloatTensor of shape (batch_size, num_channels, image_size, image_size)) -- 输入图像对应的张量。像素值可以使用 AutoImageProcessor 获得。有关详细信息，请参阅 CLIPImageProcessor.__call__()（[]LlavaProcessor`]使用 CLIPImageProcessor 来处理图像）。

• attention_mask（形状为(batch_size, sequence_length)的torch.Tensor，可选）—用于避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]之间：

  • 1 表示未被掩码的标记，

  • 0 表示被掩码的标记。

  什么是注意力掩码？

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

  如果使用past_key_values，则只需输入最后的decoder_input_ids（请参阅past_key_values）。

  如果要更改填充行为，应阅读modeling_opt._prepare_decoder_attention_mask并根据需要进行修改。有关默认策略的更多信息，请参阅论文中的图表 1。

  • 1 表示头部未被掩码，

  • 0 表示头部被掩码。

• position_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）—每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.n_positions - 1]。什么是位置 ID？

• past_key_values (tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或config.use_cache=True时返回） — 长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量，以及 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。

  包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码（请参见past_key_values输入）。

  如果使用了past_key_values，用户可以选择仅输入最后的decoder_input_ids（这些没有将其过去的键值状态提供给此模型）的形状为(batch_size, 1)，而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。

• inputs_embeds (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选） — 可选地，可以直接传递嵌入表示，而不是传递input_ids。如果您希望更多地控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。

• use_cache (bool, optional) — 如果设置为True，则返回past_key_values键值状态，并可用于加速解码（请参见past_key_values）。

• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量中的attentions。

• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量中的hidden_states。

• return_dict (bool，可选） — 是否返回一个 ModelOutput 而不是一个普通元组。

  参数 — labels (torch.LongTensor，形状为(batch_size, sequence_length)，可选）：用于计算掩码语言建模损失的标签。索引应该在[0, ..., config.vocab_size]范围内，或者为-100（请参见input_ids文档字符串）。索引设置为-100的标记将被忽略（掩码），损失仅计算具有标签在[0, ..., config.vocab_size]范围内的标记。

返回

transformers.models.llava.modeling_llava.LlavaCausalLMOutputWithPast 或 tuple(torch.FloatTensor)

一个transformers.models.llava.modeling_llava.LlavaCausalLMOutputWithPast或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含根据配置（LlavaConfig）和输入的不同元素。

• loss (torch.FloatTensor，形状为(1,)，可选，当提供labels时返回） — 语言建模损失（用于下一个标记预测）。

• logits (torch.FloatTensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。

• past_key_values (tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或config.use_cache=True时返回） — 长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量。

  包含预先计算的隐藏状态（自注意力块中的键和值），可用于加速顺序解码（请参见past_key_values输入）。

• hidden_states (tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回） — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型具有嵌入层，则为嵌入的输出 + 每层的输出）。

  模型在每一层输出的隐藏状态以及可选的初始嵌入输出。

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

  注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

• image_hidden_states (tuple(torch.FloatTensor), 可选的) — 图像嵌入输出的元组torch.FloatTensor（形状为(batch_size, num_images, sequence_length, hidden_size)）。

  由视觉编码器产生的模型的图像隐藏状态，以及可选的由感知器产生的隐藏状态。

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

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

例如：

>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, LlavaForConditionalGeneration

>>> model = LlavaForConditionalGeneration.from_pretrained("llava-hf/llava-1.5-7b-hf")
>>> processor = AutoProcessor.from_pretrained("llava-hf/llava-1.5-7b-hf")

>>> prompt = "<image>\nUSER: What's the content of the image?\nASSISTANT:"
>>> url = "https://www.ilankelman.org/stopsigns/australia.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> inputs = processor(text=prompt, images=image, return_tensors="pt")

>>> # Generate
>>> generate_ids = model.generate(**inputs, max_length=30)
>>> processor.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
"\nUSER: What's the content of the image?\nASSISTANT: The image features a stop sign on a street corner"

LXMERT

原始文本：huggingface.co/docs/transformers/v4.37.2/en/model_doc/lxmert

概述

LXMERT 模型是由 Hao Tan 和 Mohit Bansal 在LXMERT: Learning Cross-Modality Encoder Representations from Transformers中提出的。它是一系列双向 Transformer 编码器（一个用于视觉模态，一个用于语言模态，然后一个用于融合两种模态），使用一种组合的方法进行预训练，包括遮蔽语言建模、视觉-语言文本对齐、ROI 特征回归、遮蔽视觉属性建模、遮蔽视觉对象建模和视觉问题回答目标。预训练包括多个多模态数据集：MSCOCO、Visual-Genome + Visual-Genome Question Answering、VQA 2.0 和 GQA。

摘要如下：

视觉与语言推理需要理解视觉概念、语言语义，最重要的是理解这两种模态之间的对齐和关系。因此，我们提出了 LXMERT（Learning Cross-Modality Encoder Representations from Transformers）框架来学习这些视觉与语言的连接。在 LXMERT 中，我们构建了一个大规模的 Transformer 模型，包括三个编码器：对象关系编码器、语言编码器和跨模态编码器。接下来，为了赋予我们的模型连接视觉和语言语义的能力，我们使用大量的图像和句子对进行预训练，通过五种不同的代表性预训练任务：遮蔽语言建模、遮蔽对象预测（特征回归和标签分类）、跨模态匹配和图像问题回答。这些任务有助于学习模态内部和模态间的关系。在从我们的预训练参数微调后，我们的模型在两个视觉问题回答数据集（即 VQA 和 GQA）上取得了最先进的结果。我们还展示了我们预训练的跨模态模型的泛化能力，通过将其适应具有挑战性的视觉推理任务 NLVR，将先前的最佳结果提高了 22%绝对值（从 54%到 76%）。最后，我们进行了详细的消融研究，证明了我们的新颖模型组件和预训练策略对我们强大结果的显著贡献；并展示了不同编码器的几个注意力可视化

此模型由eltoto1219贡献。原始代码可在此处找到。

使用提示

• 在视觉特征嵌入中不必使用边界框，任何类型的视觉空间特征都可以使用。

• LXMERT 输出的语言隐藏状态和视觉隐藏状态都经过了跨模态层，因此它们包含来自两种模态的信息。要访问仅关注自身的模态，请从元组中的第一个输入中选择视觉/语言隐藏状态。

• 双向跨模态编码器注意力仅在语言模态用作输入且视觉模态用作上下文向量时返回注意力值。此外，虽然跨模态编码器包含每个相应模态的自注意力和交叉注意力，但只返回交叉注意力，两个自注意力输出都被忽略。

资源

• 问答任务指南

LxmertConfig

class transformers.LxmertConfig

<来源>

( vocab_size = 30522 hidden_size = 768 num_attention_heads = 12 num_qa_labels = 9500 num_object_labels = 1600 num_attr_labels = 400 intermediate_size = 3072 hidden_act = 'gelu' hidden_dropout_prob = 0.1 attention_probs_dropout_prob = 0.1 max_position_embeddings = 512 type_vocab_size = 2 initializer_range = 0.02 layer_norm_eps = 1e-12 l_layers = 9 x_layers = 5 r_layers = 5 visual_feat_dim = 2048 visual_pos_dim = 4 visual_loss_normalizer = 6.67 task_matched = True task_mask_lm = True task_obj_predict = True task_qa = True visual_obj_loss = True visual_attr_loss = True visual_feat_loss = True **kwargs )

参数

• vocab_size (int, optional, defaults to 30522) — LXMERT 模型的词汇表大小。定义了在调用 LxmertModel 或 TFLxmertModel 时可以由 inputs_ids 表示的不同标记数量。

• hidden_size (int, optional, defaults to 768) — 编码器层和池化器层的维度。

• num_attention_heads (int, optional, defaults to 12) — Transformer 编码器中每个注意力层的注意力头数量。

• num_qa_labels (int, optional, defaults to 9500) — 这表示不同的问题回答（QA）标签的总数。如果使用多个具有 QA 的数据集，用户需要考虑所有数据集总共拥有的标签数量。

• num_object_labels (int, optional, defaults to 1600) — 这表示 LXMERT 将能够将池化对象特征分类为所属的语义唯一对象的总数。

• num_attr_labels (int, optional, defaults to 400) — 这表示 LXMERT 将能够将池化对象特征分类为具有的语义唯一属性的总数。

• intermediate_size (int, optional, defaults to 3072) — Transformer 编码器中“中间”（通常称为前馈）层的维度。

• hidden_act (str or Callable, optional, defaults to "gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持 "gelu", "relu", "silu" 和 "gelu_new"。

• hidden_dropout_prob (float, optional, defaults to 0.1) — 嵌入层、编码器和池化器中所有全连接层的丢失概率。

• attention_probs_dropout_prob (float, optional, defaults to 0.1) — 注意力概率的丢失比率。

• max_position_embeddings (int, optional, defaults to 512) — 该模型可能会与的最大序列长度。通常将其设置为较大的值以防万一（例如，512、1024 或 2048）。

• type_vocab_size (int, optional, defaults to 2) — 传递给 BertModel 的 token_type_ids 的词汇表大小。

• initializer_range (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。

• layer_norm_eps (float, optional, defaults to 1e-12) — 层归一化层使用的 epsilon。

• l_layers (int, optional, defaults to 9) — Transformer 语言编码器中的隐藏层数量。

• x_layers (int, optional, defaults to 5) — Transformer 跨模态编码器中的隐藏层数量。

• r_layers (int, optional, defaults to 5) — Transformer 视觉编码器中的隐藏层数量。

• visual_feat_dim (int, optional, defaults to 2048) — 这表示用作模型输入的池化对象特征的最后维度，表示每个对象特征本身的大小。

• visual_pos_dim (int, optional, defaults to 4) — 这表示混合到视觉特征中的空间特征的数量。默认设置为 4，因为通常这将表示边界框的位置。即 (x, y, 宽度, 高度)

• visual_loss_normalizer (float, optional, defaults to 6.67) — 这表示如果在预训练期间决定使用多个基于视觉的损失目标进行训练，则每个视觉损失将乘以的缩放因子。

• task_matched (bool, optional, defaults to True) — 该任务用于句子-图像匹配。如果句子正确描述图像，则标签为 1。如果句子未正确描述图像，则标签为 0。

• task_mask_lm (bool, optional, defaults to True) — 是否添加掩码语言建模（如 BERT 中使用的）到损失目标中。

• task_obj_predict (bool, optional, defaults to True) — 是否添加对象预测、属性预测和特征回归到损失目标中。

• task_qa (bool, optional, defaults to True) — 是否将问答损失添加到目标中。

• visual_obj_loss (bool, optional, defaults to True) — 是否计算对象预测损失目标

• visual_attr_loss (bool, optional, defaults to True) — 是否计算属性预测损失目标

• visual_feat_loss (bool, optional, defaults to True) — 是否计算特征回归损失目标

这是用于存储 LxmertModel 或 TFLxmertModel 配置的配置类。它用于根据指定的参数实例化一个 LXMERT 模型，定义模型架构。使用默认值实例化配置将产生与 Lxmert unc-nlp/lxmert-base-uncased架构类似的配置。

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

LxmertTokenizer

class transformers.LxmertTokenizer

<来源>

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

参数

• vocab_file (str) — 包含词汇表的文件。

• do_lower_case (bool, optional, defaults to True) — 在标记化时是否将输入转换为小写。

• do_basic_tokenize (bool, optional, defaults to True) — 在 WordPiece 之前是否进行基本标记化。

• never_split (Iterable, optional) — 在标记化期间永远不会拆分的标记集合。仅在do_basic_tokenize=True时有效。

• unk_token (str, optional, defaults to "[UNK]") — 未知标记。词汇表中不存在的标记无法转换为 ID，而是设置为此标记。

• sep_token (str, optional, defaults to "[SEP]") — 分隔符标记，用于从多个序列构建序列，例如用于序列分类的两个序列或用于文本和问题的问题回答。它还用作使用特殊标记构建的序列的最后一个标记。

• pad_token (str, optional, defaults to "[PAD]") — 用于填充的标记，例如在批处理不同长度的序列时使用。

• cls_token (str, optional, defaults to "[CLS]") — 用于进行序列分类（对整个序列进行分类而不是对每个标记进行分类）时使用的分类器标记。它是使用特殊标记构建的序列的第一个标记。

• mask_token (str, optional, defaults to "[MASK]") — 用于屏蔽值的标记。这是在使用掩码语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。

• tokenize_chinese_chars (bool, optional, defaults to True) — 是否对中文字符进行标记化。

  这可能应该在日语中停用（请参阅此问题）。

• strip_accents (bool, optional) — 是否去除所有重音符号。如果未指定此选项，则将由lowercase的值确定（与原始 Lxmert 中相同）。

构建一个 Lxmert 标记器。基于 WordPiece。

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

build_inputs_with_special_tokens

<来源>

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

参数

• token_ids_0 (List[int]) — 将添加特殊标记的 ID 列表。

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

返回值

List[int]

带有适当特殊标记的输入 ID 列表。

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

• 单个序列：[CLS] X [SEP]

• 序列对：[CLS] A [SEP] B [SEP]

convert_tokens_to_string

<来源>

( tokens )

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

create_token_type_ids_from_sequences

<来源>

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

参数

• token_ids_0 (List[int]) — ID 列表。

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

返回值

List[int]

根据给定序列的标记类型 ID 列表。

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

序列对掩码的格式如下：

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

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

get_special_tokens_mask

<来源>

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

参数

• token_ids_0 (List[int]) — ID 列表。

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

• already_has_special_tokens (bool, 可选, 默认为 False) — 标记列表是否已经使用特殊标记格式化。

返回值

List[int]

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

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

LxmertTokenizerFast

class transformers.LxmertTokenizerFast

<来源>

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

参数

• vocab_file (str) — 包含词汇表的文件。

• do_lower_case (bool, 可选, 默认为 True) — 在标记化时是否将输入转换为小写。

• unk_token (str, 可选, 默认为 "[UNK]") — 未知标记。词汇表中没有的标记无法转换为 ID，而是设置为此标记。

• sep_token (str, 可选, 默认为 "[SEP]") — 分隔符标记，在构建多个序列的序列时使用，例如用于序列分类的两个序列或用于文本和问题的问题回答。它也用作使用特殊标记构建的序列的最后一个标记。

• pad_token (str, 可选, 默认为 "[PAD]") — 用于填充的标记，例如在批处理不同长度的序列时使用。

• cls_token (str, 可选, 默认为 "[CLS]") — 用于进行序列分类（对整个序列进行分类而不是每个标记的分类）时使用的分类器标记。当使用特殊标记构建序列时，它是序列的第一个标记。

• mask_token (str, 可选, 默认为 "[MASK]") — 用于屏蔽值的标记。这是在使用掩码语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。

• clean_text (bool, 可选, 默认为 True) — 是否在分词之前清理文本，通过删除所有控制字符并将所有空格替换为经典空格。

• tokenize_chinese_chars (bool, 可选, 默认为 True) — 是否对中文字符进行分词。这可能应该在日语中停用（参见此问题）。

• strip_accents (bool, 可选) — 是否去除所有重音符号。如果未指定此选项，则将由lowercase的值确定（与原始 Lxmert 中一样）。

• wordpieces_prefix (str, 可选, 默认为 "##") — 用于子词的前缀。

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

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

build_inputs_with_special_tokens

< source >

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

参数

• token_ids_0 (List[int]) — 将添加特殊标记的 ID 列表。

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

返回

List[int]

带有适当特殊标记的输入 ID 列表。

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

• 单个序列：[CLS] X [SEP]

• 序列对：[CLS] A [SEP] B [SEP]

create_token_type_ids_from_sequences

< source >

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

参数

• token_ids_0 (List[int]) — ID 列表。

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

返回

List[int]

根据给定序列的标记类型 ID 列表。

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

序列掩码的格式如下：

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

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

Lxmert 特定输出

class transformers.models.lxmert.modeling_lxmert.LxmertModelOutput

< source >

( language_output: Optional = None vision_output: Optional = None pooled_output: Optional = None language_hidden_states: Optional = None vision_hidden_states: Optional = None language_attentions: Optional = None vision_attentions: Optional = None cross_encoder_attentions: Optional = None )

参数

• language_output (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)) — 语言编码器最后一层的隐藏状态序列。

• vision_output (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)) — 视觉编码器最后一层的隐藏状态序列。

• pooled_output (torch.FloatTensor，形状为 (batch_size, hidden_size)) — 序列第一个标记（分类，CLS，标记）的最后一层隐藏状态，进一步通过线性层和 Tanh 激活函数处理。线性

• language_hidden_states (tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回） — 形状为 (batch_size, sequence_length, hidden_size) 的torch.FloatTensor元组（一个用于输入特征 + 一个用于每个跨模态层的输出）。

• vision_hidden_states (tuple(torch.FloatTensor), optional, 当output_hidden_states=True被传递或者config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于输入特征，一个用于每个跨模态层的输出）。

• language_attentions (tuple(torch.FloatTensor), optional, 当output_attentions=True被传递或者config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每个层一个）。注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

• vision_attentions (tuple(torch.FloatTensor), optional, 当output_attentions=True被传递或者config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每个层一个）。注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

• cross_encoder_attentions (tuple(torch.FloatTensor), optional, 当output_attentions=True被传递或者config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每个层一个）。注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

Lxmert 的输出包含语言、视觉和跨模态编码器的最后隐藏状态、汇总输出和注意力概率。（注意：在 Lxmert 中，视觉编码器被称为“关系-ship”编码器）

class transformers.models.lxmert.modeling_lxmert.LxmertForPreTrainingOutput

<来源>

( loss: Optional = None prediction_logits: Optional = None cross_relationship_score: Optional = None question_answering_score: Optional = None language_hidden_states: Optional = None vision_hidden_states: Optional = None language_attentions: Optional = None vision_attentions: Optional = None cross_encoder_attentions: Optional = None )

参数

• loss (optional, 当提供labels时返回，形状为(1,)的torch.FloatTensor) — 总损失，作为掩码语言建模损失和下一个序列预测（分类）损失的总和。

• prediction_logits (torch.FloatTensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。

• cross_relationship_score (torch.FloatTensor，形状为(batch_size, 2)) — 文本匹配目标（分类）头的预测分数（SoftMax 之前的 True/False 继续分数）。

• question_answering_score (torch.FloatTensor，形状为(batch_size, n_qa_answers)) — 问答目标（分类）的预测分数。

• language_hidden_states (tuple(torch.FloatTensor), optional, 当output_hidden_states=True被传递或者config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于输入特征，一个用于每个跨模态层的输出）。

• vision_hidden_states (tuple(torch.FloatTensor), optional, 当output_hidden_states=True被传递或者config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于输入特征，一个用于每个跨模态层的输出）。

• language_attentions (tuple(torch.FloatTensor), optional, 当output_attentions=True被传递或者config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每个层一个）。注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

• vision_attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）— 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组。注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

• cross_encoder_attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）— 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组。注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

LxmertForPreTraining 的输出类型。

class transformers.models.lxmert.modeling_lxmert.LxmertForQuestionAnsweringOutput

<来源>

( loss: Optional = None question_answering_score: Optional = None language_hidden_states: Optional = None vision_hidden_states: Optional = None language_attentions: Optional = None vision_attentions: Optional = None cross_encoder_attentions: Optional = None )

参数

• loss（可选，当提供labels时返回，形状为(1,)的torch.FloatTensor）— 总损失，作为掩码语言建模损失和下一个序列预测（分类）损失的总和。

• question_answering_score（形状为(batch_size, n_qa_answers)的torch.FloatTensor，可选）— 问题回答目标（分类）的预测分数。

• language_hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）— 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组。

• vision_hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）— 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组。

• language_attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）— 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组。注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

• vision_attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）— 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组。注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

• cross_encoder_attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）— 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组。注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

LxmertForQuestionAnswering 的输出类型。

class transformers.models.lxmert.modeling_tf_lxmert.TFLxmertModelOutput

<来源>

( language_output: tf.Tensor | None = None vision_output: tf.Tensor | None = None pooled_output: tf.Tensor | None = None language_hidden_states: Tuple[tf.Tensor] | None = None vision_hidden_states: Tuple[tf.Tensor] | None = None language_attentions: Tuple[tf.Tensor] | None = None vision_attentions: Tuple[tf.Tensor] | None = None cross_encoder_attentions: Tuple[tf.Tensor] | None = None )

参数

• language_output（形状为(batch_size, sequence_length, hidden_size)的tf.Tensor）— 语言编码器最后一层的隐藏状态序列。

• vision_output (tf.Tensor of shape (batch_size, sequence_length, hidden_size)) — 视觉编码器最后一层的隐藏状态序列。

• pooled_output (tf.Tensor of shape (batch_size, hidden_size)) — 序列第一个标记的最后一层隐藏状态（分类，CLS，标记），经过线性层和 Tanh 激活函数进一步处理的隐藏状态。

• language_hidden_states (tuple(tf.Tensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回） — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于输入特征 + 一个用于每个跨模态层的输出）。

• vision_hidden_states (tuple(tf.Tensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回） — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于输入特征 + 一个用于每个跨模态层的输出）。

• language_attentions (tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每个层一个）。注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

• vision_attentions (tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每个层一个）。注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

• cross_encoder_attentions (tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每个层一个）。注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

Lxmert 的输出包含语言、视觉和跨模态编码器的最后隐藏状态、汇聚输出和注意力概率。（注意：在 Lxmert 中，视觉编码器被称为“关系-ship”编码器）

class transformers.models.lxmert.modeling_tf_lxmert.TFLxmertForPreTrainingOutput

< source >

( loss: tf.Tensor | None = None prediction_logits: tf.Tensor | None = None cross_relationship_score: tf.Tensor | None = None question_answering_score: tf.Tensor | None = None language_hidden_states: Tuple[tf.Tensor] | None = None vision_hidden_states: Tuple[tf.Tensor] | None = None language_attentions: Tuple[tf.Tensor] | None = None vision_attentions: Tuple[tf.Tensor] | None = None cross_encoder_attentions: Tuple[tf.Tensor] | None = None )

参数

• loss（可选，在提供labels时返回，tf.Tensor of shape (1,)） — 总损失，作为掩码语言建模损失和下一个序列预测（分类）损失的总和。

• prediction_logits (tf.Tensor of shape (batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。

• cross_relationship_score (tf.Tensor of shape (batch_size, 2)) — 文本匹配目标（分类）头的预测分数（SoftMax 之前的 True/False 连续性分数）。

• question_answering_score (tf.Tensor of shape (batch_size, n_qa_answers)) — 问答目标（分类）的预测分数。

• language_hidden_states (tuple(tf.Tensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回） — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于输入特征 + 一个用于每个跨模态层的输出）。

• vision_hidden_states (tuple(tf.Tensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回） — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于输入特征 + 一个用于每个跨模态层的输出）。

• language_attentions (tuple(tf.Tensor), 可选的, 当传递output_attentions=True或者当config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。在自注意力头中用于计算加权平均值的注意力权重。

• vision_attentions (tuple(tf.Tensor), 可选的, 当传递output_attentions=True或者当config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。在自注意力头中用于计算加权平均值的注意力权重。

• cross_encoder_attentions (tuple(tf.Tensor), 可选的, 当传递output_attentions=True或者当config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。在自注意力头中用于计算加权平均值的注意力权重。

LxmertForPreTraining 的输出类型。

PytorchHide Pytorch 内容

LxmertModel

class transformers.LxmertModel

<来源>

( config )

参数

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

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

LXMERT 模型是由 Hao Tan 和 Mohit Bansal 在LXMERT: Learning Cross-Modality Encoder Representations from Transformers中提出的。这是一个视觉和语言变换器模型，预训练于包括 GQA、VQAv2.0、MSCOCO 标题和 Visual genome 在内的各种多模态数据集，使用掩码语言建模、感兴趣区域特征回归、交叉熵损失用于问题回答属性预测和对象标签预测。

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

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

forward

<来源>

( input_ids: Optional = None visual_feats: Optional = None visual_pos: Optional = None attention_mask: Optional = None visual_attention_mask: Optional = None token_type_ids: Optional = None inputs_embeds: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.lxmert.modeling_lxmert.LxmertModelOutput or tuple(torch.FloatTensor)

参数

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

  可以使用 AutoTokenizer 获取索引。查看 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()获取详细信息。

  什么是输入 ID？

• visual_feats (torch.FloatTensor of shape (batch_size, num_visual_features, visual_feat_dim)) — 此输入表示视觉特征。它们是使用 faster-RCNN 模型从边界框中 ROI 池化的对象特征）

  目前 transformers 库中没有提供这些。

• visual_pos (torch.FloatTensor of shape (batch_size, num_visual_features, visual_pos_dim)) — 此输入表示与它们的相对（通过索引）视觉特征对应的空间特征。预训练的 LXMERT 模型期望这些空间特征是在 0 到

  目前 transformers 库中没有提供这些。

• attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 避免在填充标记索引上执行注意力的掩码。掩码值在 [0, 1] 中选择：

  • 1 表示未被屏蔽的标记，

  • 0 表示被屏蔽的标记。

  什么是注意力掩码？

• visual_attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 避免在填充标记索引上执行注意力的掩码。掩码值在 [0, 1] 中选择：

  • 1 表示未被屏蔽的标记，

  • 0 表示被屏蔽的标记。

  什么是注意力掩码？

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

  • 0 对应于 句子 A 标记，

  • 1 对应于 句子 B 标记。

  什么是标记类型 ID？

• inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，您可以直接传递嵌入表示，而不是传递 input_ids。如果您想要更多控制如何将 input_ids 索引转换为相关向量，这将很有用，而不是使用模型的内部嵌入查找矩阵。

• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。

• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。

• return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通的元组。

返回

transformers.models.lxmert.modeling_lxmert.LxmertModelOutput 或 tuple(torch.FloatTensor)

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

• language_output (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size)) — 语言编码器最后一层的隐藏状态序列。

• vision_output (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size)) — 视觉编码器最后一层的隐藏状态序列。

• pooled_output (torch.FloatTensor of shape (batch_size, hidden_size)) — 序列第一个标记（分类，CLS，标记）的最后一层隐藏状态，进一步由线性层和 Tanh 激活函数处理。线性

• language_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于输入特征，一个用于每个交叉模态层的输出）。

• vision_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于输入特征，一个用于每个交叉模态层的输出）。

• language_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组。在自注意力头中用于计算加权平均值的注意力权重 softmax 后。

• vision_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组。在自注意力头中用于计算加权平均值的注意力权重 softmax 后。

• cross_encoder_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组。在自注意力头中用于计算加权平均值的注意力权重 softmax 后。

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

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

示例：

>>> from transformers import AutoTokenizer, LxmertModel
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("unc-nlp/lxmert-base-uncased")
>>> model = LxmertModel.from_pretrained("unc-nlp/lxmert-base-uncased")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)

>>> last_hidden_states = outputs.last_hidden_state

LxmertForPreTraining

class transformers.LxmertForPreTraining

< source >

( config )

参数

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

具有指定预训练头的 Lxmert 模型。

LXMERT 模型是由 Hao Tan 和 Mohit Bansal 在LXMERT: Learning Cross-Modality Encoder Representations from Transformers中提出的。它是一个视觉和语言变换器模型，预训练于包括 GQA、VQAv2.0、MSCOCO 标题和 Visual genome 在内的各种多模态数据集，使用掩码语言建模、感兴趣区域特征回归、交叉熵损失用于问题回答属性预测和对象标签预测的组合。

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

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

forward

< source >

( input_ids: Optional = None visual_feats: Optional = None visual_pos: Optional = None attention_mask: Optional = None visual_attention_mask: Optional = None token_type_ids: Optional = None inputs_embeds: Optional = None labels: Optional = None obj_labels: Optional = None matched_label: Optional = None ans: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None **kwargs ) → export const metadata = 'undefined';transformers.models.lxmert.modeling_lxmert.LxmertForPreTrainingOutput or tuple(torch.FloatTensor)

参数

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

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

  什么是输入 ID？

• visual_feats (torch.FloatTensor of shape (batch_size, num_visual_features, visual_feat_dim)) — 这个输入表示视觉特征。它们是通过 faster-RCNN 模型从边界框中 ROI 池化的对象特征。

  目前这些由 transformers 库不提供。

• visual_pos (torch.FloatTensor of shape (batch_size, num_visual_features, visual_pos_dim)) — 这个输入表示与它们的相对（通过索引）视觉特征对应的空间特征。预训练的 LXMERT 模型期望这些空间特征是在 0 到 1 的范围内归一化的边界框。

  目前这些由 transformers 库不提供。

• attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), 可选) — 避免在填充标记索引上执行注意力的掩码。掩码值选择在 [0, 1]：

  • 1 代表未被 masked 的标记，

  • 0 代表被 masked 的标记。

  什么是注意力掩码？

• visual_attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), 可选) — 避免在填充标记索引上执行注意力的掩码。掩码值选择在 [0, 1]：

  • 1 代表未被 masked 的标记，

  • 0 代表被 masked 的标记。

  什么是注意力掩码？

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

  • 0 对应于 句子 A 标记，

  • 1 对应于 句子 B 标记。

  什么是标记类型 ID？

• 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 而不是普通的元组。

• labels (torch.LongTensor of shape (batch_size, sequence_length), 可选) — 用于计算掩码语言建模损失的标签。索引应在 [-100, 0, ..., config.vocab_size]（参见 input_ids 文档字符串）。索引设置为 -100 的标记将被忽略（被 masked），损失仅计算具有标签在 [0, ..., config.vocab_size] 中的标记。

• obj_labels (Dict[Str -- Tuple[Torch.FloatTensor, Torch.FloatTensor]], 可选): 每个键以视觉损失中的每一个命名，元组的每个元素的形状分别为 (batch_size, num_features) 和 (batch_size, num_features, visual_feature_dim)，用于标签 ID 和标签分数

• matched_label（形状为(batch_size,)的torch.LongTensor，可选） - 用于计算文本输入是否与图像匹配（分类）损失的标签。输入应为一个序列对（参见input_ids文档字符串）。索引应在[0, 1]中：

  • 0 表示句子与图像不匹配，

  • 1 表示句子与图像匹配。

• ans（形状为(batch_size)的Torch.Tensor，可选） - 正确答案的独热表示可选

返回

transformers.models.lxmert.modeling_lxmert.LxmertForPreTrainingOutput 或tuple(torch.FloatTensor)

一个 transformers.models.lxmert.modeling_lxmert.LxmertForPreTrainingOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包括根据配置（LxmertConfig）和输入的不同元素。

• loss（可选，当提供labels时返回，形状为(1,)的torch.FloatTensor） - 作为掩码语言建模损失和下一个序列预测（分类）损失之和的总损失。

• prediction_logits（形状为(batch_size, sequence_length, config.vocab_size)的torch.FloatTensor） - 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。

• cross_relationship_score（形状为(batch_size, 2)的torch.FloatTensor） - 文本匹配目标（分类）头的预测分数（SoftMax 之前的 True/False 继续分数）。

• question_answering_score（形状为(batch_size, n_qa_answers)的torch.FloatTensor） - 问题回答目标（分类）的预测分数。

• language_hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回） - 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于输入特征+一个用于每个跨模态层的输出）。

• vision_hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回） - 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于输入特征+一个用于每个跨模态层的输出）。

• language_attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回） - 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组。注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

• vision_attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回） - 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组。注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

• cross_encoder_attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回） - 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组。注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

LxmertForQuestionAnswering

class transformers.LxmertForQuestionAnswering

<来源>

( config )

参数

• config（LxmertConfig](/docs/transformers/v4.37.2/en/main_classes/model#transformers.PreTrainedModel.from_pretrained)方法以加载模型权重。

带有视觉回答头的 Lxmert 模型，用于下游 QA 任务

LXMERT 模型是由 Hao Tan 和 Mohit Bansal 在LXMERT: Learning Cross-Modality Encoder Representations from Transformers中提出的。这是一个视觉和语言变换器模型，预训练于各种多模态数据集，包括 GQA、VQAv2.0、MSCOCO 字幕和 Visual genome，使用掩码语言建模、感兴趣区域特征回归、交叉熵损失用于问题回答属性预测和对象标签预测的组合。

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

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

forward

<来源>

( input_ids: Optional = None visual_feats: Optional = None visual_pos: Optional = None attention_mask: Optional = None visual_attention_mask: Optional = None token_type_ids: Optional = None inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.lxmert.modeling_lxmert.LxmertForQuestionAnsweringOutput or tuple(torch.FloatTensor)

参数

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

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

  什么是输入 ID？

• visual_feats（形状为(batch_size, num_visual_features, visual_feat_dim)的torch.FloatTensor）—这个输入表示视觉特征。它们是使用 faster-RCNN 模型从边界框中 ROI 池化的对象特征）

  这些目前不是由 transformers 库提供的。

• visual_pos（形状为(batch_size, num_visual_features, visual_pos_dim)的torch.FloatTensor）—这个输入表示与它们的相对（通过索引）视觉特征对应的空间特征。预训练的 LXMERT 模型期望这些空间特征是在 0 到 1 的范围内的归一化边界框

  这些目前不是由 transformers 库提供的。

• attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）—避免在填充标记索引上执行注意力的掩码。选择的掩码值在[0, 1]范围内：

  • 1 表示“未屏蔽”的标记，

  • 0 表示“屏蔽”的标记。

  什么是注意力掩码？

• visual_attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）—避免在填充标记索引上执行注意力的掩码。选择的掩码值在[0, 1]范围内：

  • 1 表示“未屏蔽”的标记，

  • 0 对于被 masked 的标记。

  什么是注意力掩码？

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

  • 0 对应 句子 A 标记，

  • 1 对应 句子 B 标记。

  什么是标记类型 ID？

• inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，可以直接传递嵌入表示，而不是传递 input_ids。如果您想要更多控制如何将 input_ids 索引转换为相关向量，这将非常有用。

• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。

• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。

• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

• labels (Torch.Tensor of shape (batch_size), optional) — 正确答案的独热表示

返回

transformers.models.lxmert.modeling_lxmert.LxmertForQuestionAnsweringOutput 或 tuple(torch.FloatTensor)

一个 transformers.models.lxmert.modeling_lxmert.LxmertForQuestionAnsweringOutput 或一个 torch.FloatTensor 元组（如果传递 return_dict=False 或 config.return_dict=False）包含根据配置（LxmertConfig）和输入的不同元素。

• loss (optional, 当提供 labels 时返回，形状为 (1,) 的 torch.FloatTensor) — 作为掩码语言建模损失和下一个序列预测（分类）损失之和的总损失。

• question_answering_score (torch.FloatTensor of shape (batch_size, n_qa_answers), optional) — 问题回答目标（分类）的预测分数。

• language_hidden_states (tuple(torch.FloatTensor), optional, 当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor 元组（一个用于输入特征 + 一个用于每个跨模态层的输出）。

• vision_hidden_states (tuple(torch.FloatTensor), optional, 当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor 元组（一个用于输入特征 + 一个用于每个跨模态层的输出）。

• language_attentions (tuple(torch.FloatTensor), optional, 当传递 output_attentions=True 或 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 torch.FloatTensor 元组（每个层一个）。注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

• vision_attentions (tuple(torch.FloatTensor), optional, 当传递 output_attentions=True 或 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 torch.FloatTensor 元组（每个层一个）。注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

• cross_encoder_attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回） - 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

例子：

>>> from transformers import AutoTokenizer, LxmertForQuestionAnswering
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("unc-nlp/lxmert-base-uncased")
>>> model = LxmertForQuestionAnswering.from_pretrained("unc-nlp/lxmert-base-uncased")

>>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"

>>> inputs = tokenizer(question, text, return_tensors="pt")
>>> with torch.no_grad():
...     outputs = model(**inputs)

>>> answer_start_index = outputs.start_logits.argmax()
>>> answer_end_index = outputs.end_logits.argmax()

>>> predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1]

>>> # target is "nice puppet"
>>> target_start_index = torch.tensor([14])
>>> target_end_index = torch.tensor([15])

>>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)
>>> loss = outputs.loss

隐藏 TensorFlow 内容

TFLxmertModel

class transformers.TFLxmertModel

<来源>

( config *inputs **kwargs )

参数

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

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

LXMERT 模型是由 Hao Tan 和 Mohit Bansal 在LXMERT: Learning Cross-Modality Encoder Representations from Transformers中提出的。这是一个视觉和语言变换器模型，预训练于各种多模态数据集，包括 GQA、VQAv2.0、MCSCOCO 字幕和 Visual genome，使用掩码语言建模、感兴趣区域特征回归、交叉熵损失用于问题回答属性预测和对象标签预测。

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

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

• 将所有输入作为关键字参数（类似于 PyTorch 模型），或者

• 将所有输入作为列表、元组或字典放在第一个位置参数中。

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

• 一个只包含input_ids的单个张量，没有其他内容：model(input_ids)

• 一个长度不定的列表，其中包含一个或多个按照文档字符串中给定顺序的输入张量：model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids])

• 一个与文档字符串中给定的输入名称相关联的包含一个或多个输入张量的字典：model({"input_ids": input_ids, "token_type_ids": token_type_ids})

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

call

<来源>

( input_ids: TFModelInputType | None = None visual_feats: tf.Tensor | None = None visual_pos: tf.Tensor | None = None attention_mask: np.ndarray | tf.Tensor | None = None visual_attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: bool = False ) → export const metadata = 'undefined';transformers.models.lxmert.modeling_tf_lxmert.TFLxmertModelOutput or tuple(tf.Tensor)

参数

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

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

  什么是输入 ID？

• visual_feats (tf.Tensor，形状为 (batch_size, num_visual_features, visual_feat_dim)) — 此输入表示视觉特征。它们是使用 faster-RCNN 模型从边界框中 ROI 池化的对象特征。

  这些目前不由 transformers 库提供。

• visual_pos (tf.Tensor，形状为 (batch_size, num_visual_features, visual_feat_dim)) — 此输入表示与它们的相对（通过索引）视觉特征对应的空间特征。预训练的 LXMERT 模型期望这些空间特征是在 0 到 之间的归一化边界框

  这些目前不由 transformers 库提供。

• attention_mask (tf.Tensor，形状为 (batch_size, sequence_length)，可选) — 避免在填充标记索引上执行注意力的掩码。掩码值选在 [0, 1]：

  • 1 用于未被掩码的标记，

  • 0 用于被掩码的标记。

  什么是注意力掩码？

• visual_attention_mask (tf.Tensor，形状为 (batch_size, sequence_length)，可选) — 避免在填充标记索引上执行注意力的掩码。掩码值选在 [0, 1]：

  • 1 用于未被掩码的标记，

  • 0 用于被掩码的标记。

  什么是注意力掩码？

• token_type_ids (tf.Tensor，形状为 (batch_size, sequence_length)，可选) — 段标记索引，指示输入的第一部分和第二部分。索引选在 [0, 1]：

  • 0 对应于 句子 A 的标记，

  • 1 对应于 句子 B 的标记。

  什么是标记类型 ID？

• 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 而不是普通元组。此参数可以在急切模式下使用，在图模式下该值将始终设置为 True。

• training (bool，可选，默认为 False) — 是否在训练模式下使用模型（一些模块，如 dropout 模块，在训练和评估之间有不同的行为）。

返回

transformers.models.lxmert.modeling_tf_lxmert.TFLxmertModelOutput 或 tuple(tf.Tensor)

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

• language_output (tf.Tensor，形状为(batch_size, sequence_length, hidden_size)) — 语言编码器最后一层的隐藏状态序列。

• vision_output (tf.Tensor，形状为(batch_size, sequence_length, hidden_size)) — 视觉编码器最后一层的隐藏状态序列。

• pooled_output (tf.Tensor，形状为(batch_size, hidden_size)) — 序列第一个标记的最后一层隐藏状态（分类，CLS，标记），经过线性层和 Tanh 激活函数进一步处理。线性

• language_hidden_states (tuple(tf.Tensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于输入特征，一个用于每个跨模态层的输出）。

• vision_hidden_states (tuple(tf.Tensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于输入特征，一个用于每个跨模态层的输出）。

• language_attentions (tuple(tf.Tensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组。在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

• vision_attentions (tuple(tf.Tensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组。在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

• cross_encoder_attentions (tuple(tf.Tensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组。在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

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

>>> tokenizer = AutoTokenizer.from_pretrained("unc-nlp/lxmert-base-uncased")
>>> model = TFLxmertModel.from_pretrained("unc-nlp/lxmert-base-uncased")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")
>>> outputs = model(inputs)

>>> last_hidden_states = outputs.last_hidden_state

TFLxmertForPreTraining

class transformers.TFLxmertForPreTraining

< source >

( config *inputs **kwargs )

参数

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

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

LXMERT 模型是由 Hao Tan 和 Mohit Bansal 在LXMERT: Learning Cross-Modality Encoder Representations from Transformers中提出的。这是一个视觉和语言变换器模型，使用遮蔽语言建模、感兴趣区域特征回归、交叉熵损失用于问题回答属性预测和对象标签预测，预先在各种多模态数据集上进行了预训练，包括 GQA、VQAv2.0、MCSCOCO 标题和 Visual genome。

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

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

• 将所有输入作为关键字参数（类似于 PyTorch 模型），或

• 将所有输入作为列表、元组或字典放在第一个位置参数中。

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

• 一个仅包含input_ids的单个张量，没有其他内容：model(input_ids)

• 按照文档字符串中给定的顺序，一个长度可变的列表，包含一个或多个输入张量：model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids])

• 一个包含一个或多个与文档字符串中给定的输入名称相关联的输入张量的字典：model({"input_ids": input_ids, "token_type_ids": token_type_ids})

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

call

<来源>

( input_ids: TFModelInputType | None = None visual_feats: tf.Tensor | None = None visual_pos: tf.Tensor | None = None attention_mask: tf.Tensor | None = None visual_attention_mask: tf.Tensor | None = None token_type_ids: tf.Tensor | None = None inputs_embeds: tf.Tensor | None = None masked_lm_labels: tf.Tensor | None = None obj_labels: Dict[str, Tuple[tf.Tensor, tf.Tensor]] | None = None matched_label: tf.Tensor | None = None ans: tf.Tensor | None = None output_attentions: bool | None = None output_hidden_states: bool | None = None return_dict: bool | None = None training: bool = False ) → export const metadata = 'undefined';transformers.models.lxmert.modeling_tf_lxmert.TFLxmertForPreTrainingOutput or tuple(tf.Tensor)

参数

• input_ids（形状为(batch_size, sequence_length)的np.ndarray或tf.Tensor）- 词汇表中输入序列标记的索引。

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

  什么是 input IDs？

• visual_feats（形状为(batch_size, num_visual_features, visual_feat_dim)的tf.Tensor）- 此输入表示视觉特征。它们是使用 faster-RCNN 模型从边界框中 ROI 池化的对象特征。

  目前 transformers 库中没有提供这些。

• visual_pos（形状为(batch_size, num_visual_features, visual_feat_dim)的tf.Tensor）- 此输入表示与它们的相对（通过索引）视觉特征对应的空间特征。预训练的 LXMERT 模型期望这些空间特征是在 0 到 1 的范围内的归一化边界框。

  目前 transformers 库中没有提供这些。

• attention_mask（形状为(batch_size, sequence_length)的tf.Tensor，可选）- 用于避免在填充标记索引上执行注意力的掩码。选择在[0, 1]中的掩码值：

  • 对于未被“masked”（掩盖）的标记，值为 1，

  • 对于被masked（掩盖）的标记，值为 0。

  什么是 attention masks？

• visual_attention_mask (tf.Tensor of shape (batch_size, sequence_length), optional) — 避免在填充令牌索引上执行注意力的 MMask。在[0, 1]中选择的掩码值：

  • 1 表示未被masked的令牌，

  • 0 表示被masked的令牌。

  什么是注意力掩码？

• token_type_ids (tf.Tensor of shape (batch_size, sequence_length), optional) — 段令牌索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：

  • 0 对应于句子 A令牌，

  • 1 对应于句子 B令牌。

  什么是令牌类型 ID？

• inputs_embeds (tf.Tensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，您可以选择直接传递嵌入表示而不是传递input_ids。如果您希望更多地控制如何将input_ids索引转换为相关向量，而不是模型的内部嵌入查找矩阵，则这很有用。

• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。此参数仅在急切模式下可用，在图模式下将使用配置中的值。

• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。此参数仅在急切模式下可用，在图模式下将使用配置中的值。

• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。此参数可在急切模式下使用，在图模式下该值将始终设置为 True。

• training (bool, optional, 默认为False) — 是否在训练模式下使用模型（某些模块如丢弃模块在训练和评估之间有不同的行为）。

• masked_lm_labels (tf.Tensor of shape (batch_size, sequence_length), optional) — 用于计算掩码语言建模损失的标签。索引应在[-100, 0, ..., config.vocab_size]内（请参阅input_ids文档字符串）。索引设置为-100的令牌将被忽略（掩码），仅对具有标签在[0, ..., config.vocab_size]中的令牌计算损失

• obj_labels (Dict[Str -- Tuple[tf.Tensor, tf.Tensor]], optional, 默认为None): 每个键都以视觉损失中的每个元素命名，元组的每个元素的形状分别为(batch_size, num_features)和(batch_size, num_features, visual_feature_dim)，用于标签 id 和标签分数

• matched_label (tf.Tensor of shape (batch_size,), optional) — 用于计算文本输入是否与图像（分类）损失匹配的标签。输入应为一个序列对（请参阅input_ids文档字符串）索引应在[0, 1]内：

  • 0 表示句子与图像不匹配，

  • 1 表示句子与图像匹配。

• ans (tf.Tensor of shape (batch_size), optional, 默认为None) — 正确答案的独热表示可选

返回

transformers.models.lxmert.modeling_tf_lxmert.TFLxmertForPreTrainingOutput 或tuple(tf.Tensor)

一个 transformers.models.lxmert.modeling_tf_lxmert.TFLxmertForPreTrainingOutput 或一个tf.Tensor元组（如果传递了return_dict=False或config.return_dict=False时）包括根据配置（LxmertConfig）和输入的不同元素。

• loss (optional, 当提供labels时返回，形状为(1,)) — 总损失，作为掩码语言建模损失和下一个序列预测（分类）损失的总和。

• prediction_logits (tf.Tensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。

• cross_relationship_score (tf.Tensor，形状为(batch_size, 2)) — 文本匹配目标（分类）头的预测分数（SoftMax 之前的 True/False 连续性分数）。

• question_answering_score (tf.Tensor，形状为(batch_size, n_qa_answers)) — 问答目标（分类）的预测分数。

• language_hidden_states (tuple(tf.Tensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于输入特征，一个用于每个跨模态层的输出）。

• vision_hidden_states (tuple(tf.Tensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于输入特征，一个用于每个跨模态层的输出）。

• language_attentions (tuple(tf.Tensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组。在自注意力头中用于计算加权平均的注意力权重 softmax 之后。

• vision_attentions (tuple(tf.Tensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组。在自注意力头中用于计算加权平均的注意力权重 softmax 之后。

• cross_encoder_attentions (tuple(tf.Tensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组。在自注意力头中用于计算加权平均的注意力权重 softmax 之后。

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

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

MatCha

原始文本：huggingface.co/docs/transformers/v4.37.2/en/model_doc/matcha

概述

MatCha 在论文MatCha: Enhancing Visual Language Pretraining with Math Reasoning and Chart Derendering中提出，作者是 Fangyu Liu、Francesco Piccinno、Syrine Krichene、Chenxi Pang、Kenton Lee、Mandar Joshi、Yasemin Altun、Nigel Collier、Julian Martin Eisenschlos。

论文摘要如下：

视觉语言数据，如图表和信息图表，在人类世界中随处可见。然而，最先进的视觉语言模型在这些数据上表现不佳。我们提出 MatCha（数学推理和图表解渲染预训练）来增强视觉语言模型在联合建模图表/图表和语言数据方面的能力。具体来说，我们提出了几个预训练任务，涵盖了图表解构和数值推理，这是视觉语言建模中的关键能力。我们从 Pix2Struct 开始执行 MatCha 预训练，Pix2Struct 是最近提出的图像到文本视觉语言模型。在 PlotQA 和 ChartQA 等标准基准测试中，MatCha 模型的表现优于最先进的方法近 20％。我们还研究了 MatCha 预训练在诸如屏幕截图、教科书图表和文档图表等领域的转移情况，并观察到整体改进，验证了 MatCha 预训练在更广泛的视觉语言任务上的有用性。

模型描述

MatCha 是使用Pix2Struct架构训练的模型。您可以在Pix2Struct 文档中找到有关Pix2Struct的更多信息。MatCha 是Pix2Struct架构的视觉问答子集。它在图像上呈现输入问题并预测答案。

用法

目前有 6 个 MatCha 的检查点可用：

• google/matcha：基础 MatCha 模型，用于在下游任务上微调 MatCha

• google/matcha-chartqa：在 ChartQA 数据集上微调的 MatCha 模型。可用于回答有关图表的问题。

• google/matcha-plotqa-v1：在 PlotQA 数据集上微调的 MatCha 模型。可用于回答有关图表的问题。

• google/matcha-plotqa-v2：在 PlotQA 数据集上微调的 MatCha 模型。可用于回答有关图表的问题。

• google/matcha-chart2text-statista：在 Statista 数据集上微调的 MatCha 模型。

• google/matcha-chart2text-pew：在 Pew 数据集上微调的 MatCha 模型。

在chart2text-pew和chart2text-statista上微调的模型更适合摘要，而在plotqa和chartqa上微调的模型更适合回答问题。

您可以按以下方式使用这些模型（在 ChatQA 数据集上的示例）：

from transformers import AutoProcessor, Pix2StructForConditionalGeneration
import requests
from PIL import Image

model = Pix2StructForConditionalGeneration.from_pretrained("google/matcha-chartqa").to(0)
processor = AutoProcessor.from_pretrained("google/matcha-chartqa")
url = "https://raw.githubusercontent.com/vis-nlp/ChartQA/main/ChartQA%20Dataset/val/png/20294671002019.png"
image = Image.open(requests.get(url, stream=True).raw)

inputs = processor(images=image, text="Is the sum of all 4 places greater than Laos?", return_tensors="pt").to(0)
predictions = model.generate(**inputs, max_new_tokens=512)
print(processor.decode(predictions[0], skip_special_tokens=True))

微调

要微调 MatCha，请参考 pix2struct 微调笔记本。对于Pix2Struct模型，我们发现使用 Adafactor 和余弦学习率调度器微调模型会导致更快的收敛：

from transformers.optimization import Adafactor, get_cosine_schedule_with_warmup

optimizer = Adafactor(self.parameters(), scale_parameter=False, relative_step=False, lr=0.01, weight_decay=1e-05)
scheduler = get_cosine_schedule_with_warmup(optimizer, num_warmup_steps=1000, num_training_steps=40000)

MatCha 是使用Pix2Struct架构训练的模型。您可以在Pix2Struct 文档中找到有关Pix2Struct的更多信息。

MGP-STR

原始文本：huggingface.co/docs/transformers/v4.37.2/en/model_doc/mgp-str

概述

MGP-STR 模型由 Peng Wang、Cheng Da 和 Cong Yao 在多粒度预测用于场景文本识别中提出。MGP-STR 是一个概念上简单但强大的视觉场景文本识别（STR）模型，它建立在视觉 Transformer（ViT）之上。为了整合语言知识，提出了多粒度预测（MGP）策略，以隐式方式将语言模态的信息注入模型中。

论文摘要如下：

场景文本识别（STR）一直是计算机视觉中的一个活跃研究课题。为了解决这一具有挑战性的问题，已经连续提出了许多创新方法，并且将语言知识整合到 STR 模型中最近成为一个突出的趋势。在这项工作中，我们首先从视觉 Transformer（ViT）的最新进展中汲取灵感，构建了一个概念上简单但强大的视觉 STR 模型，它建立在 ViT 之上，并且在场景文本识别方面优于以前的最先进模型，包括纯视觉模型和语言增强方法。为了整合语言知识，我们进一步提出了一种多粒度预测策略，以隐式方式将语言模态的信息注入模型中，即，除了传统的字符级表示外，还引入了在 NLP 中广泛使用的子词表示（BPE 和 WordPiece）到输出空间中，而不采用独立的语言模型（LM）。由此产生的算法（称为 MGP-STR）能够将 STR 的性能推向更高的水平。具体而言，在标准基准上实现了 93.35%的平均识别准确率。

MGP-STR 架构。摘自原始论文。

MGP-STR 在两个合成数据集 MJSynth)（MJ）和 SynthText(www.robots.ox.ac.uk/~vgg/data/scenetext/)（ST）上进行训练，而不在其他数据集上进行微调。它在六个标准拉丁场景文本基准上取得了最先进的结果，包括 3 个常规文本数据集（IC13、SVT、IIIT）和 3 个不规则数据集（IC15、SVTP、CUTE）。该模型由yuekun贡献。原始代码可以在这里找到。

推理示例

MgpstrModel 接受图像作为输入，并生成三种类型的预测，代表不同粒度的文本信息。这三种类型的预测被融合以给出最终的预测结果。

ViTImageProcessor 类负责预处理输入图像，MgpstrTokenizer 解码生成的字符标记为目标字符串。MgpstrProcessor 将 ViTImageProcessor 和 MgpstrTokenizer 封装成单个实例，既提取输入特征又解码预测的标记 ID。

• 逐步光学字符识别（OCR）

>>> from transformers import MgpstrProcessor, MgpstrForSceneTextRecognition
>>> import requests
>>> from PIL import Image

>>> processor = MgpstrProcessor.from_pretrained('alibaba-damo/mgp-str-base')
>>> model = MgpstrForSceneTextRecognition.from_pretrained('alibaba-damo/mgp-str-base')

>>> # load image from the IIIT-5k dataset
>>> url = "https://i.postimg.cc/ZKwLg2Gw/367-14.png"
>>> image = Image.open(requests.get(url, stream=True).raw).convert("RGB")

>>> pixel_values = processor(images=image, return_tensors="pt").pixel_values
>>> outputs = model(pixel_values)

>>> generated_text = processor.batch_decode(outputs.logits)['generated_text']

MgpstrConfig

class transformers.MgpstrConfig

< source >

( image_size = [32, 128] patch_size = 4 num_channels = 3 max_token_length = 27 num_character_labels = 38 num_bpe_labels = 50257 num_wordpiece_labels = 30522 hidden_size = 768 num_hidden_layers = 12 num_attention_heads = 12 mlp_ratio = 4.0 qkv_bias = True distilled = False layer_norm_eps = 1e-05 drop_rate = 0.0 attn_drop_rate = 0.0 drop_path_rate = 0.0 output_a3_attentions = False initializer_range = 0.02 **kwargs )

参数

• image_size (List[int], optional, defaults to [32, 128]) — 每个图像的大小（分辨率）。

• patch_size (int, optional, defaults to 4) — 每个补丁的大小（分辨率）。

• num_channels (int, optional, defaults to 3) — 输入通道数。

• max_token_length (int, optional, defaults to 27) — 输出标记的最大数量。

• num_character_labels (int, optional, defaults to 38) — 字符头的类数。

• num_bpe_labels (int, optional, defaults to 50257) — bpe 头的类数。

• num_wordpiece_labels (int, optional, defaults to 30522) — wordpiece 头的类数。

• hidden_size (int, optional, defaults to 768) — 嵌入维度。

• num_hidden_layers (int, optional, defaults to 12) — Transformer 编码器中的隐藏层数。

• num_attention_heads (int, optional, defaults to 12) — Transformer 编码器中每个注意力层的注意力头数。

• mlp_ratio (float, optional, defaults to 4.0) — mlp 隐藏维度与嵌入维度的比率。

• qkv_bias (bool, optional, defaults to True) — 是否为查询、键和值添加偏置。

• distilled (bool, optional, defaults to False) — 模型包括蒸馏令牌和头，如 DeiT 模型。

• layer_norm_eps (float, optional, defaults to 1e-05) — 层归一化层使用的 epsilon。

• drop_rate (float, optional, defaults to 0.0) — 嵌入层、编码器中所有全连接层的 dropout 概率。

• attn_drop_rate (float, optional, defaults to 0.0) — 注意力概率的 dropout 比率。

• drop_path_rate (float, optional, defaults to 0.0) — 随机深度率。

• output_a3_attentions (bool, optional, defaults to False) — 模型是否返回 A³ 模块的注意力。

• initializer_range (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。

这是一个配置类，用于存储 MgpstrModel 的配置。根据指定的参数实例化一个 MGP-STR 模型，定义模型架构。使用默认值实例化配置将产生类似于 MGP-STR alibaba-damo/mgp-str-base架构的配置。

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

示例：

>>> from transformers import MgpstrConfig, MgpstrForSceneTextRecognition

>>> # Initializing a Mgpstr mgp-str-base style configuration
>>> configuration = MgpstrConfig()

>>> # Initializing a model (with random weights) from the mgp-str-base style configuration
>>> model = MgpstrForSceneTextRecognition(configuration)

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

MgpstrTokenizer

class transformers.MgpstrTokenizer

< source >

( vocab_file unk_token = '[GO]' bos_token = '[GO]' eos_token = '[s]' pad_token = '[GO]' **kwargs )

参数

• vocab_file (str) — 词汇表文件路径。

• unk_token (str, optional, defaults to "[GO]") — 未知标记。词汇表中没有的标记无法转换为 ID，而是设置为此标记。

• bos_token (str, optional, defaults to "[GO]") — 序列开始标记。

• eos_token (str, optional, defaults to "[s]") — 序列结束标记。

• pad_token (str or tokenizers.AddedToken, optional, defaults to "[GO]") — 用于使标记数组大小相同以进行批处理的特殊标记。然后将被注意力机制或损失计算忽略。

构建一个 MGP-STR 字符分词器。

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

save_vocabulary

< source >

( save_directory: str filename_prefix: Optional = None )

MgpstrProcessor

class transformers.MgpstrProcessor

< source >

( image_processor = None tokenizer = None **kwargs )

参数

• image_processor (ViTImageProcessor, 可选) — 一个 ViTImageProcessor 实例。图像处理器是必需的输入。

• tokenizer（MgpstrTokenizer, 可选）— Tokenizer 是必需的输入。

构建一个 MGP-STR 处理器，将图像处理器和 MGP-STR 分词器封装成一个单独的

MgpstrProcessor 提供了所有 ViTImageProcessor 和 MgpstrTokenizer 的功能。查看 call() 和 batch_decode() 获取更多信息。

__call__

< source >

( text = None images = None return_tensors = None **kwargs )

在正常模式下使用时，此方法将所有参数转发给 ViTImageProcessor 的 call() 并返回其输出。如果 text 不是 None，此方法还将 text 和 kwargs 参数转发给 MgpstrTokenizer 的 call() 来编码文本。更多信息请参考上述方法的文档字符串。

batch_decode

< source >

( sequences ) → export const metadata = 'undefined';Dict[str, any]

参数

• sequences (torch.Tensor) — 分词后输入 id 的列表。

返回

Dict[str, any]

所有解码结果的字典。 generated_text (List[str]): 融合字符、bpe 和 wp 后的最终结果。 scores (List[float]): 融合字符、bpe 和 wp 后的最终分数。 char_preds (List[str]): 字符解码句子的列表。 bpe_preds (List[str]): bpe 解码句子的列表。 wp_preds (List[str]): wp 解码句子的列表。

通过调用 decode 将 token id 的列表转换为字符串列表。

此方法将所有参数转发给 PreTrainedTokenizer 的 batch_decode()。更多信息请参考该方法的文档字符串。

MgpstrModel

class transformers.MgpstrModel

< source >

( config: MgpstrConfig )

参数

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

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

forward

<来源>

( pixel_values: FloatTensor output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None )

参数

• pixel_values (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 像素值。像素值可以使用 AutoImageProcessor 获得。有关详细信息，请参阅 ViTImageProcessor.call()。

• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请查看返回张量下的attentions。

• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请查看返回张量下的hidden_states。

• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

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

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

MgpstrForSceneTextRecognition

class transformers.MgpstrForSceneTextRecognition

<来源>

( config: MgpstrConfig )

参数

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

MGP-STR 模型变压器，顶部有三个分类头（三个 A³ 模块和变压器编码器输出顶部的三个线性层），用于场景文本识别（STR）。

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

forward

<来源>

( pixel_values: FloatTensor output_attentions: Optional = None output_a3_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.mgp_str.modeling_mgp_str.MgpstrModelOutput or tuple(torch.FloatTensor)

参数

• pixel_values (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 像素值。像素值可以使用 AutoImageProcessor 获得。有关详细信息，请参阅 ViTImageProcessor.call()。

• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请查看返回张量下的attentions。

• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请查看返回张量下的hidden_states。

• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

• output_a3_attentions（bool，可选）- 是否返回 a3 模块的注意力张量。有关更多详细信息，请参阅返回张量中的a3_attentions。

返回

transformers.models.mgp_str.modeling_mgp_str.MgpstrModelOutput或tuple(torch.FloatTensor)

一个transformers.models.mgp_str.modeling_mgp_str.MgpstrModelOutput或一个torch.FloatTensor元组（如果传递了return_dict=False或当config.return_dict=False时）包括根据配置（<class 'transformers.models.mgp_str.configuration_mgp_str.MgpstrConfig'>）和输入的不同元素。

• logits（形状为(batch_size, config.num_character_labels)的tuple(torch.FloatTensor)）- torch.FloatTensor元组（一个用于字符输出的形状为(batch_size, config.max_token_length, config.num_character_labels)，+ 一个用于 bpe 输出的形状为(batch_size, config.max_token_length, config.num_bpe_labels)，+ 一个用于 wordpiece 输出的形状为(batch_size, config.max_token_length, config.num_wordpiece_labels)）。

  字符、bpe 和 wordpiece 的分类分数（SoftMax 之前）。

• hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回）- 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入的输出，如果模型有一个嵌入层，+ 一个用于每一层的输出）。

  模型在每一层输出的隐藏状态以及可选的初始嵌入输出。

• attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回）- 形状为(batch_size, config.max_token_length, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。

  注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

• a3_attentions（tuple(torch.FloatTensor)，可选，当传递output_a3_attentions=True或当config.output_a3_attentions=True时返回）- 形状为(batch_size, config.max_token_length, sequence_length)的torch.FloatTensor元组（一个用于字符的注意力，+ 一个用于 bpe 的注意力，+ 一个用于 wordpiece 的注意力）。

  注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import (
...     MgpstrProcessor,
...     MgpstrForSceneTextRecognition,
... )
>>> import requests
>>> from PIL import Image

>>> # load image from the IIIT-5k dataset
>>> url = "https://i.postimg.cc/ZKwLg2Gw/367-14.png"
>>> image = Image.open(requests.get(url, stream=True).raw).convert("RGB")

>>> processor = MgpstrProcessor.from_pretrained("alibaba-damo/mgp-str-base")
>>> pixel_values = processor(images=image, return_tensors="pt").pixel_values

>>> model = MgpstrForSceneTextRecognition.from_pretrained("alibaba-damo/mgp-str-base")

>>> # inference
>>> outputs = model(pixel_values)
>>> out_strs = processor.batch_decode(outputs.logits)
>>> out_strs["generated_text"]
'["ticket"]'

Nougat

原始文本：huggingface.co/docs/transformers/v4.37.2/en/model_doc/nougat

概述

Nougat 模型是由 Lukas Blecher、Guillem Cucurull、Thomas Scialom、Robert Stojnic 提出的Nougat: 用于学术文档的神经光学理解。Nougat 使用与 Donut 相同的架构，即图像 Transformer 编码器和自回归文本 Transformer 解码器，将科学 PDF 转换为标记，使其更易于访问。

论文摘要如下：

科学知识主要存储在书籍和科学期刊中，通常以 PDF 形式存在。然而，PDF 格式会导致语义信息的丢失，特别是对于数学表达式。我们提出了 Nougat（用于学术文档的神经光学理解），这是一个视觉 Transformer 模型，用于将科学文档进行光学字符识别（OCR）任务，转换为标记语言，并展示了我们的模型在新的科学文档数据集上的有效性。所提出的方法为增强数字时代科学知识的可访问性提供了一个有希望的解决方案，通过弥合人类可读文档和机器可读文本之间的差距。我们发布了模型和代码，以加速未来关于科学文本识别的工作。

Nougat 高层概述。摘自原始论文。

该模型由nielsr贡献。原始代码可在此处找到。

使用提示

• 开始使用 Nougat 的最快方法是查看教程笔记本，展示了如何在推理时使用模型以及在自定义数据上进行微调。

• Nougat 始终在 VisionEncoderDecoder 框架内使用。该模型在架构上与 Donut 相同。

推理

Nougat 的VisionEncoderDecoder模型接受图像作为输入，并利用 generate()来自动回归生成给定输入图像的文本。

NougatImageProcessor 类负责预处理输入图像，NougatTokenizerFast 解码生成的目标标记为目标字符串。NougatProcessor 将 NougatImageProcessor 和 NougatTokenizerFast 类封装为单个实例，用于提取输入特征和解码预测的标记 ID。

• 逐步 PDF 转录

>>> from huggingface_hub import hf_hub_download
>>> import re
>>> from PIL import Image

>>> from transformers import NougatProcessor, VisionEncoderDecoderModel
>>> from datasets import load_dataset
>>> import torch

>>> processor = NougatProcessor.from_pretrained("facebook/nougat-base")
>>> model = VisionEncoderDecoderModel.from_pretrained("facebook/nougat-base")

>>> device = "cuda" if torch.cuda.is_available() else "cpu"
>>> model.to(device)
>>> # prepare PDF image for the model
>>> filepath = hf_hub_download(repo_id="hf-internal-testing/fixtures_docvqa", filename="nougat_paper.png", repo_type="dataset")
>>> image = Image.open(filepath)
>>> pixel_values = processor(image, return_tensors="pt").pixel_values

>>> # generate transcription (here we only generate 30 tokens)
>>> outputs = model.generate(
...     pixel_values.to(device),
...     min_length=1,
...     max_new_tokens=30,
...     bad_words_ids=[[processor.tokenizer.unk_token_id]],
... )

>>> sequence = processor.batch_decode(outputs, skip_special_tokens=True)[0]
>>> sequence = processor.post_process_generation(sequence, fix_markdown=False)
>>> # note: we're using repr here such for the sake of printing the \n characters, feel free to just print the sequence
>>> print(repr(sequence))
'\n\n# Nougat: Neural Optical Understanding for Academic Documents\n\n Lukas Blecher\n\nCorrespondence to: lblecher@'

请查看模型中心以查找 Nougat 检查点。

该模型在架构上与 Donut 相同。

NougatImageProcessor

class transformers.NougatImageProcessor

<来源>

( do_crop_margin: bool = True do_resize: bool = True size: Dict = None resample: Resampling = <Resampling.BILINEAR: 2> do_thumbnail: bool = True do_align_long_axis: bool = False do_pad: bool = True do_rescale: bool = True rescale_factor: Union = 0.00392156862745098 do_normalize: bool = True image_mean: Union = None image_std: Union = None **kwargs )

参数

• do_crop_margin（bool，可选，默认为True）— 是否裁剪图像边距。

• do_resize（bool，可选，默认为True）— 是否将图像的（高度，宽度）尺寸调整为指定的size。可以在preprocess方法中通过do_resize进行覆盖。

• size (Dict[str, int] 可选, 默认为 {"height" -- 896, "width": 672}): 调整大小后的图像尺寸。可以被 preprocess 方法中的 size 覆盖。

• resample (PILImageResampling, 可选, 默认为 Resampling.BILINEAR) — 如果调整图像大小，则使用的重采样滤波器。可以被 preprocess 方法中的 resample 覆盖。

• do_thumbnail (bool, 可选, 默认为 True) — 是否使用缩略图方法调整图像大小。

• do_align_long_axis (bool, 可选, 默认为 False) — 是否通过旋转 90 度来使图像的长轴与 size 的长轴对齐。

• do_pad (bool, 可选, 默认为 True) — 是否将图像填充到批处理中最大的图像尺寸。

• do_rescale (bool, 可选, 默认为 True) — 是否按指定比例 rescale_factor 重新缩放图像。可以被 preprocess 方法中的 do_rescale 参数覆盖。

• rescale_factor (int 或 float, 可选, 默认为 1/255) — 如果重新缩放图像，则使用的缩放因子。可以被 preprocess 方法中的 rescale_factor 参数覆盖。

• do_normalize (bool, 可选, 默认为 True) — 是否对图像进行归一化。可以被 preprocess 方法中的 do_normalize 覆盖。

• image_mean (float 或 List[float], 可选, 默认为 IMAGENET_DEFAULT_MEAN) — 如果归一化图像，则使用的均值。这是一个浮点数或与图像通道数相同长度的浮点数列表。可以被 preprocess 方法中的 image_mean 参数覆盖。

• image_std (float 或 List[float], 可选, 默认为 IMAGENET_DEFAULT_STD) — 图像标准差。

构建 Nougat 图像处理器。

preprocess

< source >

( images: Union do_crop_margin: bool = None do_resize: bool = None size: Dict = None resample: Resampling = None do_thumbnail: bool = None do_align_long_axis: bool = None do_pad: bool = None do_rescale: bool = None rescale_factor: Union = None do_normalize: bool = None image_mean: Union = None image_std: Union = None return_tensors: Union = None data_format: Optional = <ChannelDimension.FIRST: 'channels_first'> input_data_format: Union = None **kwargs )

参数

• images (ImageInput) — 要预处理的图像。期望单个图像或批处理图像，像素值范围为 0 到 255。

• do_crop_margin (bool, 可选, 默认为 self.do_crop_margin) — 是否裁剪图像边缘。

• do_resize (bool, 可选, 默认为 self.do_resize) — 是否调整图像大小。

• size (Dict[str, int], 可选, 默认为 self.size) — 调整大小后的图像尺寸。图像的最短边调整为 min(size[“height”], size[“width”])，最长边调整以保持输入的长宽比。

• resample (int, 可选, 默认为 self.resample) — 如果调整图像大小，则使用的重采样滤波器。这可以是枚举 PILImageResampling 中的一个。仅当 do_resize 设置为 True 时才会生效。

• do_thumbnail (bool, 可选, 默认为 self.do_thumbnail) — 是否使用缩略图方法调整图像大小。

• do_align_long_axis (bool, 可选, 默认为 self.do_align_long_axis) — 是否通过旋转 90 度来使图像的长轴与 size 的长轴对齐。

• do_pad (bool, 可选, 默认为 self.do_pad) — 是否将图像填充到批处理中最大的图像尺寸。

• do_rescale (bool, 可选, 默认为 self.do_rescale) — 是否按指定比例 rescale_factor 重新缩放图像。

• rescale_factor (int 或 float, 可选, 默认为 self.rescale_factor) — 如果重新缩放图像，则使用的缩放因子。

• do_normalize (bool, 可选, 默认为 self.do_normalize) — 是否对图像进行归一化。

• image_mean (float 或 List[float], 可选, 默认为 self.image_mean) — 用于归一化的图像均值。

• image_std (float 或 List[float], 可选, 默认为 self.image_std) — 用于归一化的图像标准差。

• return_tensors (str 或 TensorType, 可选) — 要返回的张量类型。可以是以下之一:

  • 未设置: 返回 np.ndarray 的列表。

  • TensorType.TENSORFLOW 或 'tf': 返回类型为 tf.Tensor 的批处理。

  • TensorType.PYTORCH 或 'pt': 返回类型为 torch.Tensor 的批处理。

  • TensorType.NUMPY 或 'np': 返回类型为 np.ndarray 的批处理。

  • TensorType.JAX 或 'jax': 返回类型为 jax.numpy.ndarray 的批处理。

• data_format (ChannelDimension 或 str, optional, 默认为 ChannelDimension.FIRST) — 输出图像的通道维度格式。可以是以下之一：

  • ChannelDimension.FIRST: 图像格式为 (num_channels, height, width)。

  • ChannelDimension.LAST: 图像格式为 (height, width, num_channels)。

  • 未设置：默认为输入图像的通道维度格式。

• input_data_format (ChannelDimension 或 str, optional) — 输入图像的通道维度格式。如果未设置，将从输入图像中推断通道维度格式。可以是以下之一：

  • "channels_first" 或 ChannelDimension.FIRST: 图像格式为 (num_channels, height, width)。

  • "channels_last" 或 ChannelDimension.LAST: 图像格式为 (height, width, num_channels)。

  • "none" 或 ChannelDimension.NONE: 图像格式为 (height, width)。

预处理一张图片或一批图片。

NougatTokenizerFast

class transformers.NougatTokenizerFast

< source >

( vocab_file = None tokenizer_file = None clean_up_tokenization_spaces = False unk_token = '<unk>' bos_token = '<s>' eos_token = '</s>' pad_token = '<pad>' **kwargs )

参数

• vocab_file (str, optional) — SentencePiece 文件（通常具有 .model 扩展名），其中包含实例化分词器所需的词汇表。

• tokenizer_file (str, optional) — tokenizers 文件（通常具有 .json 扩展名），其中包含加载分词器所需的所有内容。

• clean_up_tokenization_spaces (str, optional, 默认为 False) — 解码后是否清除空格，清除包括删除额外空格等潜在瑕疵。

• unk_token (str, optional, 默认为 "<unk>") — 未知标记。词汇表中不存在的标记无法转换为 ID，而是设置为此标记。

• bos_token (str, optional, 默认为 "<s>") — 在预训练期间使用的序列开始标记。可用作序列分类器标记。

• eos_token (str, optional, 默认为 "</s>") — 序列结束标记。

• pad_token (str, optional, 默认为 "<pad>") — 用于填充的标记，例如在批处理不同长度的序列时使用。

• model_max_length (int, optional) — 转换器模型输入的最大长度（以标记数计）。当使用 from_pretrained() 加载分词器时，将设置为存储在 max_model_input_sizes 中的相关模型的值（请参见上文）。如果未提供值，将默认为 VERY_LARGE_INTEGER (int(1e30)）。

• padding_side (str, optional) — 模型应用填充的侧面。应在 ['right', 'left'] 中选择。默认值从同名的类属性中选择。

• truncation_side (str, optional) — 模型应用截断的侧面。应在 ['right', 'left'] 中选择。默认值从同名的类属性中选择。

• chat_template (str, optional) — 一个 Jinja 模板字符串，用于格式化聊天消息列表。详细描述请参见 huggingface.co/docs/transformers/chat_templating。

• model_input_names (List[string], optional) — 模型前向传递接受的输入列表（如 "token_type_ids" 或 "attention_mask"）。默认值从同名的类属性中选择。

• bos_token (str 或 tokenizers.AddedToken, optional) — 表示句子开头的特殊标记。将与 self.bos_token 和 self.bos_token_id 关联。

• eos_token（str或tokenizers.AddedToken，可选）— 代表句子结束的特殊标记。将与self.eos_token和self.eos_token_id相关联。

• unk_token（str或tokenizers.AddedToken，可选）— 代表词汇外标记的特殊标记。将与self.unk_token和self.unk_token_id相关联。

• sep_token（str或tokenizers.AddedToken，可选）— 用于在同一输入中分隔两个不同句子的特殊标记（例如 BERT 使用）。将与self.sep_token和self.sep_token_id相关联。

• pad_token（str或tokenizers.AddedToken，可选）— 用于使标记数组大小相同以进行批处理的特殊标记。然后将被注意机制或损失计算忽略。将与self.pad_token和self.pad_token_id相关联。

• cls_token（str或tokenizers.AddedToken，可选）— 代表输入类别的特殊标记（例如 BERT 使用）。将与self.cls_token和self.cls_token_id相关联。

• mask_token（str或tokenizers.AddedToken，可选）— 代表掩码标记的特殊标记（用于掩码语言建模预训练目标，如 BERT）。将与self.mask_token和self.mask_token_id相关联。

• additional_special_tokens（元组或str或tokenizers.AddedToken，可选）— 一组额外的特殊标记。在这里添加它们以确保在将skip_special_tokens设置为 True 时解码时跳过它们。如果它们不是词汇的一部分，它们将被添加到词汇的末尾。

• clean_up_tokenization_spaces（bool，可选，默认为True）— 模型是否应清除在标记化过程中拆分输入文本时添加的空格。

• split_special_tokens（bool，可选，默认为False）— 是否在标记化过程中拆分特殊标记。默认行为是不拆分特殊标记。这意味着如果<s>是bos_token，那么tokenizer.tokenize("<s>") = ['<s>]。否则，如果split_special_tokens=True，那么tokenizer.tokenize("")将给出['<', 's', '>']。此参数目前仅支持slow`分词器。

• tokenizer_object（tokenizers.Tokenizer）— 来自🤗 tokenizers 的tokenizers.Tokenizer对象，用于实例化。有关更多信息，请参阅使用🤗 tokenizers 中的分词器。

• tokenizer_file（str）— 代表以前序列化的tokenizers.Tokenizer对象的本地 JSON 文件的路径。

Nougat 的快速分词器（由 HuggingFace 分词器库支持）。

这个分词器继承自 PreTrainedTokenizerFast，其中包含大多数主要方法。用户应参考这个超类以获取有关这些方法的更多信息。这个类主要为后处理生成的文本添加了 Nougat 特定的方法。

类属性（由派生类覆盖）

• vocab_files_names（Dict[str, str]）— 一个字典，其键是模型所需的每个词汇文件的__init__关键字名称，其相关值是用于保存相关文件的文件名（字符串）。

• pretrained_vocab_files_map（Dict[str, Dict[str, str]]）— 一个字典，其中高级键是模型所需的每个词汇文件的__init__关键字名称，低级别是预训练模型的short-cut-names，作为相关值，是与相关预训练词汇文件相关联的url。

• max_model_input_sizes（Dict[str, Optional[int]]）— 一个字典，其键是预训练模型的short-cut-names，其相关值是该模型的序列输入的最大长度，如果模型没有最大输入大小，则为None。

• pretrained_init_configuration (Dict[str, Dict[str, Any]]) — 一个字典，键为预训练模型的short-cut-names，值为传递给加载预训练模型时 tokenizer 类的__init__方法的特定参数的字典。

• model_input_names (List[str]) — 模型前向传递中预期的输入列表。

• padding_side (str) — 模型应该应用填充的默认值。应为'right'或'left'。

• truncation_side (str) — 模型应该应用截断的默认值。应为'right'或'left'。

correct_tables

< source >

( generation: str ) → export const metadata = 'undefined';str

参数

• generation (str) — 要进行后处理的生成文本。

返回

str

后处理的文本。

接受一个生成的字符串，并修复表格/表格，使其符合所需的 Markdown 格式。

示例：

correct_tables("\begin{table} \begin{tabular}{l l} & \ \end{tabular} \end{table}")
"\begin{table}
abular}{l l} & \ \end{tabular}
le}"

post_process_generation

< source >

( generation: Union fix_markdown: bool = True num_workers: int = None ) → export const metadata = 'undefined';Union[str, List[str]]

参数

• generation (Union[str, List[str]]) — 生成的文本或生成的文本列表。

• fix_markdown (bool, 可选, 默认为 True) — 是否执行 Markdown 格式修复。

• num_workers (int, 可选) — 传递给利用多进程的工作人员数量（并行后处理多个文本）。

返回

Union[str, List[str]]

后处理的文本或后处理文本列表。

后处理生成的文本或生成的文本列表。

此函数可用于对生成的文本执行后处理，例如修复 Markdown 格式。

后处理速度较慢，建议使用多进程加快处理速度。

post_process_single

< source >

( generation: str fix_markdown: bool = True ) → export const metadata = 'undefined';str

参数

• generation (str) — 要进行后处理的生成文本。

• fix_markdown (bool, optional) — 是否执行 Markdown 格式修复。默认为 True。

返回

str

后处理的文本。

后处理单个生成的文本。此处使用的正则表达式直接来自 Nougat 文章作者。这些表达式已经过注释以确保清晰，并在大多数情况下进行了端到端测试。

remove_hallucinated_references

< source >

( text: str ) → export const metadata = 'undefined';str

参数

• text (str) — 包含引用的输入文本。

返回

str

删除虚构引用的文本。

从文本中删除虚构或缺失的引用。

此函数识别并删除输入文本中标记为缺失或虚构的引用。

NougatProcessor

class transformers.NougatProcessor

< source >

( image_processor tokenizer )

参数

• image_processor (NougatImageProcessor) — 一个 NougatImageProcessor 的实例。图像处理器是必需的输入。

• tokenizer (NougatTokenizerFast) — 一个 NougatTokenizerFast 的实例。分词器是必需的输入。

构建一个 Nougat 处理器，将 Nougat 图像处理器和 Nougat tokenizer 包装成一个单一处理器。

NougatProcessor 提供了 NougatImageProcessor 和 NougatTokenizerFast 的所有功能。有关更多信息，请参考 call() 和 decode()。

__call__

< source >

( images = None text = None do_crop_margin: bool = None do_resize: bool = None size: Dict = None resample: PILImageResampling = None do_thumbnail: bool = None do_align_long_axis: bool = None do_pad: bool = None do_rescale: bool = None rescale_factor: Union = None do_normalize: bool = None image_mean: Union = None image_std: Union = None data_format: Optional = 'channels_first' input_data_format: Union = None text_pair: Union = None text_target: Union = None text_pair_target: Union = None add_special_tokens: bool = True padding: Union = False truncation: Union = None max_length: Optional = None stride: int = 0 is_split_into_words: bool = False pad_to_multiple_of: Optional = None return_tensors: Union = None return_token_type_ids: Optional = None return_attention_mask: Optional = None return_overflowing_tokens: bool = False return_special_tokens_mask: bool = False return_offsets_mapping: bool = False return_length: bool = False verbose: bool = True )

from_pretrained

< source >

( pretrained_model_name_or_path: Union cache_dir: Union = None force_download: bool = False local_files_only: bool = False token: Union = None revision: str = 'main' **kwargs )

参数

• pretrained_model_name_or_path (str or os.PathLike) — 这可以是：

  • 一个字符串，预训练特征提取器的 模型 id，托管在 huggingface.co 上的模型存储库中。有效的模型 id 可以位于根级别，如 bert-base-uncased，或者在用户或组织名称下命名空间化，如 dbmdz/bert-base-german-cased。

  • 一个包含使用 save_pretrained() 方法保存的特征提取器文件的 目录 路径，例如 ./my_model_directory/。

  • 已保存的特征提取器 JSON 文件 的路径或 URL，例如 ./my_model_directory/preprocessor_config.json。**kwargs — 传递给 from_pretrained() 和 ~tokenization_utils_base.PreTrainedTokenizer.from_pretrained 的额外关键字参数。

实例化与预训练模型相关联的处理器。

这个类方法只是调用特征提取器 from_pretrained()、图像处理器 ImageProcessingMixin 和分词器 ~tokenization_utils_base.PreTrainedTokenizer.from_pretrained 方法。有关更多信息，请参考上述方法的文档字符串。

save_pretrained

< source >

( save_directory push_to_hub: bool = False **kwargs )

参数

• save_directory (str or os.PathLike) — 将保存特征提取器 JSON 文件和分词器文件的目录（如果目录不存在，则将创建）。

• push_to_hub (bool, optional, defaults to False) — 是否在保存模型后将其推送到 Hugging Face 模型中心。您可以使用 repo_id 指定要推送到的存储库（将默认为您的命名空间中的 save_directory 名称）。

• kwargs (Dict[str, Any], optional) — 传递给 push_to_hub() 方法的额外关键字参数。

将此处理器的属性（特征提取器、分词器等）保存在指定的目录中，以便可以使用 from_pretrained() 方法重新加载。

这个类方法只是调用 save_pretrained() 和 save_pretrained()。有关更多信息，请参考上述方法的文档字符串。

batch_decode

< source >

( *args **kwargs )

这个方法将所有参数转发给 NougatTokenizer 的 batch_decode()。请参考此方法的文档字符串以获取更多信息。

解码

<来源>

( *args **kwargs )

这个方法将所有参数转发给 NougatTokenizer 的 decode()。请参考此方法的文档字符串以获取更多信息。

后处理生成

<来源>

( *args **kwargs )

这个方法将所有参数转发给 NougatTokenizer 的~PreTrainedTokenizer.post_process_generation。请参考此方法的文档字符串以获取更多信息。

OneFormer

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

概述

OneFormer 模型是由 Jitesh Jain、Jiachen Li、MangTik Chiu、Ali Hassani、Nikita Orlov、Humphrey Shi 在OneFormer: One Transformer to Rule Universal Image Segmentation中提出的。OneFormer 是一个通用的图像分割框架，可以在单个全景数据集上进行训练，执行语义、实例和全景分割任务。OneFormer 使用任务标记来使模型在关注的任务上进行条件化，使架构在训练时受任务引导，在推断时动态适应任务。

该论文的摘要如下：

通用图像分割并不是一个新概念。过去几十年来统一图像分割的尝试包括场景解析、全景分割，以及最近的新全景架构。然而，这些全景架构并不能真正统一图像分割，因为它们需要分别在语义、实例或全景分割上进行训练，才能达到最佳性能。理想情况下，一个真正通用的框架应该只需要训练一次，并在所有三个图像分割任务上实现 SOTA 性能。为此，我们提出了 OneFormer，一个通用图像分割框架，通过多任务一次训练的设计统一了分割。我们首先提出了一个任务条件联合训练策略，使得可以在单个多任务训练过程中训练每个领域（语义、实例和全景分割）的地面真相。其次，我们引入了一个任务标记，使我们的模型在手头的任务上进行条件化，使我们的模型支持多任务训练和推断。第三，我们提出在训练期间使用查询文本对比损失，以建立更好的任务间和类间区别。值得注意的是，我们的单个 OneFormer 模型在 ADE20k、CityScapes 和 COCO 上的所有三个分割任务中均优于专门的 Mask2Former 模型，尽管后者在每个任务上分别使用了三倍的资源进行训练。通过新的 ConvNeXt 和 DiNAT 骨干，我们观察到更多的性能改进。我们相信 OneFormer 是使图像分割更加通用和可访问的重要一步。

下图展示了 OneFormer 的架构。摘自原始论文。

这个模型是由Jitesh Jain贡献的。原始代码可以在这里找到。

使用提示

• 在推断期间，OneFormer 需要两个输入：图像和任务标记。

• 在训练期间，OneFormer 只使用全景注释。

• 如果要在多个节点上的分布式环境中训练模型，则应该在modeling_oneformer.py的OneFormerLoss类中更新get_num_masks函数。在多节点训练时，这应该设置为所有节点上目标掩码的平均数量，可以在原始实现中看到这里。

• 可以使用 OneFormerProcessor 来准备输入图像和模型的任务输入，以及可选的模型目标。 OneformerProcessor将 OneFormerImageProcessor 和 CLIPTokenizer 封装成一个单一实例，既可以准备图像又可以编码任务输入。

• 要获得最终的分割结果，可以调用 post_process_semantic_segmentation()或 post_process_instance_segmentation()或 post_process_panoptic_segmentation()。这三个任务都可以使用 OneFormerForUniversalSegmentation 的输出来解决，全景分割接受一个可选的label_ids_to_fuse参数，用于将目标对象（例如天空）的实例融合在一起。

资源

一份官方 Hugging Face 和社区（由🌎表示）资源列表，可帮助您开始使用 OneFormer。

• 关于推断+在自定义数据上进行微调的演示笔记本可以在这里找到。

如果您有兴趣提交资源以包含在此处，请随时提交拉取请求，我们将对其进行审查。资源应该展示一些新的东西，而不是重复现有资源。

OneFormer 特定输出

class transformers.models.oneformer.modeling_oneformer.OneFormerModelOutput

<来源>

( encoder_hidden_states: Optional = None pixel_decoder_hidden_states: Optional = None transformer_decoder_hidden_states: Optional = None transformer_decoder_object_queries: FloatTensor = None transformer_decoder_contrastive_queries: Optional = None transformer_decoder_mask_predictions: FloatTensor = None transformer_decoder_class_predictions: FloatTensor = None transformer_decoder_auxiliary_predictions: Optional = None text_queries: Optional = None task_token: FloatTensor = None attentions: Optional = None )

参数

• encoder_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — torch.FloatTensor元组（一个用于嵌入的输出 + 一个用于每个阶段的输出），形状为(batch_size, num_channels, height, width)。编码器模型在每个阶段输出的隐藏状态（也称为特征图）。

• pixel_decoder_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — torch.FloatTensor元组（一个用于嵌入的输出 + 一个用于每个阶段的输出），形状为(batch_size, num_channels, height, width)。像素解码器模型在每个阶段输出的隐藏状态（也称为特征图）。

• transformer_decoder_hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — torch.FloatTensor元组（一个用于嵌入的输出 + 一个用于每个阶段的输出），形状为(batch_size, sequence_length, hidden_size)。transformer 解码器在每个阶段输出的隐藏状态（也称为特征图）。

• transformer_decoder_object_queries (torch.FloatTensor，形状为(batch_size, num_queries, hidden_dim)) — 来自 transformer 解码器最后一层的输出对象查询。

• transformer_decoder_contrastive_queries (torch.FloatTensor，形状为(batch_size, num_queries, hidden_dim)) — 来自 transformer 解码器的对比查询。

• transformer_decoder_mask_predictions (torch.FloatTensor，形状为(batch_size, num_queries, height, width)) — 来自 transformer 解码器最后一层的掩码预测。

• transformer_decoder_class_predictions (torch.FloatTensor，形状为(batch_size, num_queries, num_classes+1)) — 来自 transformer 解码器最后一层的类别预测。

• transformer_decoder_auxiliary_predictions（str, torch.FloatTensor字典的元组，可选） — 来自 transformer 解码器每一层的类别和掩码预测的元组。

• text_queries (torch.FloatTensor，可选，形状为(batch_size, num_queries, hidden_dim)) — 从用于计算对比损失的输入文本列表派生的文本查询。

• task_token（形状为(batch_size, hidden_dim)的torch.FloatTensor）—用于条件查询的一维任务令牌。

• attentions（tuple(tuple(torch.FloatTensor))，可选，当传递output_attentions=True或当config.output_attentions=True时返回）—形状为(batch_size, num_heads, sequence_length, sequence_length)的tuple(torch.FloatTensor)元组（每层一个）。transformer 解码器的自注意力和交叉注意力权重。

用于 OneFormerModel 输出的类。此类返回计算 logits 所需的所有隐藏状态。

class transformers.models.oneformer.modeling_oneformer.OneFormerForUniversalSegmentationOutput

<来源>

( loss: Optional = None class_queries_logits: FloatTensor = None masks_queries_logits: FloatTensor = None auxiliary_predictions: List = None encoder_hidden_states: Optional = None pixel_decoder_hidden_states: Optional = None transformer_decoder_hidden_states: Optional = None transformer_decoder_object_queries: FloatTensor = None transformer_decoder_contrastive_queries: Optional = None transformer_decoder_mask_predictions: FloatTensor = None transformer_decoder_class_predictions: FloatTensor = None transformer_decoder_auxiliary_predictions: Optional = None text_queries: Optional = None task_token: FloatTensor = None attentions: Optional = None )

参数

• loss（torch.Tensor，可选）—当存在标签时返回计算的损失。

• class_queries_logits（torch.FloatTensor）—形状为(batch_size, num_queries, num_labels + 1)的张量，表示每个查询的建议类别。请注意，需要+ 1，因为我们包含了空类。

• masks_queries_logits（torch.FloatTensor）—形状为(batch_size, num_queries, height, width)的张量，表示每个查询的建议掩码。

• auxiliary_predictions（str，torch.FloatTensor字典列表，可选）—来自 transformer 解码器每一层的类别和掩码预测的列表。

• encoder_hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回）—形状为(batch_size, num_channels, height, width)的torch.FloatTensor元组（一个用于嵌入的输出+一个用于每个阶段的输出）。编码器模型在每个阶段输出的隐藏状态（也称为特征图）。

• pixel_decoder_hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回）—形状为(batch_size, num_channels, height, width)的torch.FloatTensor元组（一个用于嵌入的输出+一个用于每个阶段的输出）。像素解码器模型在每个阶段输出的隐藏状态（也称为特征图）。

• transformer_decoder_hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回）—形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入的输出+一个用于每个阶段的输出）。transformer 解码器在每个阶段输出的隐藏状态（也称为特征图）。

• transformer_decoder_object_queries（形状为(batch_size, num_queries, hidden_dim)的torch.FloatTensor）—来自 transformer 解码器中最后一层的输出对象查询。

• transformer_decoder_contrastive_queries（形状为(batch_size, num_queries, hidden_dim)的torch.FloatTensor）—来自 transformer 解码器的对比查询。

• transformer_decoder_mask_predictions（形状为(batch_size, num_queries, height, width)的torch.FloatTensor）—来自 transformer 解码器中最后一层的掩码预测。

• transformer_decoder_class_predictions（形状为(batch_size, num_queries, num_classes+1)的torch.FloatTensor）—来自 transformer 解码器中最后一层的类别预测。

• transformer_decoder_auxiliary_predictions（str，torch.FloatTensor字典列表，可选）—来自 transformer 解码器每一层的类别和掩码预测的列表。

• text_queries（torch.FloatTensor，可选，形状为(batch_size, num_queries, hidden_dim)）—从用于训练期间计算对比损失的输入文本列表派生的文本查询。

• task_token（形状为(batch_size, hidden_dim)的torch.FloatTensor）—用于条件查询的一维任务令牌。

• attentions (tuple(tuple(torch.FloatTensor)), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tuple(torch.FloatTensor)元组。来自 transformer 解码器的自注意力和交叉注意力权重。

用于OneFormerForUniversalSegmentationOutput的输出类。

此输出可以直接传递给 post_process_semantic_segmentation()或 post_process_instance_segmentation()或 post_process_panoptic_segmentation()，具体取决于任务。请参阅[`~OneFormerImageProcessor]以获取有关用法的详细信息。

OneFormerConfig

class transformers.OneFormerConfig

<来源>

( backbone_config: Optional = None ignore_value: int = 255 num_queries: int = 150 no_object_weight: int = 0.1 class_weight: float = 2.0 mask_weight: float = 5.0 dice_weight: float = 5.0 contrastive_weight: float = 0.5 contrastive_temperature: float = 0.07 train_num_points: int = 12544 oversample_ratio: float = 3.0 importance_sample_ratio: float = 0.75 init_std: float = 0.02 init_xavier_std: float = 1.0 layer_norm_eps: float = 1e-05 is_training: bool = False use_auxiliary_loss: bool = True output_auxiliary_logits: bool = True strides: Optional = [4, 8, 16, 32] task_seq_len: int = 77 text_encoder_width: int = 256 text_encoder_context_length: int = 77 text_encoder_num_layers: int = 6 text_encoder_vocab_size: int = 49408 text_encoder_proj_layers: int = 2 text_encoder_n_ctx: int = 16 conv_dim: int = 256 mask_dim: int = 256 hidden_dim: int = 256 encoder_feedforward_dim: int = 1024 norm: str = 'GN' encoder_layers: int = 6 decoder_layers: int = 10 use_task_norm: bool = True num_attention_heads: int = 8 dropout: float = 0.1 dim_feedforward: int = 2048 pre_norm: bool = False enforce_input_proj: bool = False query_dec_layers: int = 2 common_stride: int = 4 **kwargs )

参数

• backbone_config (PretrainedConfig, optional, defaults to SwinConfig) — 主干模型的配置。

• ignore_value (int, optional, defaults to 255) — 在计算损失时要忽略的 GT 标签中的值。

• num_queries (int, optional, defaults to 150) — 对象查询的数量。

• no_object_weight (float, optional, defaults to 0.1) — 无对象类预测的权重。

• class_weight (float, optional, defaults to 2.0) — 分类 CE 损失的权重。

• mask_weight (float, optional, defaults to 5.0) — 二元 CE 损失的权重。

• dice_weight (float, optional, defaults to 5.0) — Dice 损失的权重。

• contrastive_weight (float, optional, defaults to 0.5) — 对比损失的权重。

• contrastive_temperature (float, optional, defaults to 0.07) — 用于缩放对比对数的初始值。

• train_num_points (int, optional, defaults to 12544) — 在计算掩码预测损失时要采样的点数。

• oversample_ratio (float, optional, defaults to 3.0) — 决定过采样多少点的比率。

• importance_sample_ratio (float, optional, defaults to 0.75) — 通过重要性采样抽样的点的比率。

• init_std (float, optional, defaults to 0.02) — 正态初始化的标准差。

• init_xavier_std (float, optional, defaults to 1.0) — 用于 xavier 均匀初始化的标准差。

• layer_norm_eps (float, optional, defaults to 1e-05) — 层归一化的 epsilon。

• is_training (bool, optional, defaults to False) — 是否在训练或推理模式下运行。

• use_auxiliary_loss (bool, optional, defaults to True) — 是否使用 transformer 解码器的中间预测计算损失。

• output_auxiliary_logits (bool, optional, defaults to True) — 是否从 transformer 解码器返回中间预测。

• strides (list, optional, defaults to [4, 8, 16, 32]) — 包含编码器中特征图的步幅的列表。

• task_seq_len (int, optional, defaults to 77) — 用于对文本列表输入进行分词的序列长度。

• text_encoder_width (int, optional, defaults to 256) — 文本编码器的隐藏大小。

• text_encoder_context_length (int, optional, defaults to 77) — 文本编码器的输入序列长度。

• text_encoder_num_layers (int, optional, defaults to 6) — 文本编码器中 transformer 的层数。

• text_encoder_vocab_size (int, optional, defaults to 49408) — 分词器的词汇量。

• text_encoder_proj_layers (int, optional, defaults to 2) — 用于项目文本查询的 MLP 中的层数。

• text_encoder_n_ctx (int, optional, 默认为 16) — 可学习文本上下文查询的数量。

• conv_dim (int, optional, 默认为 256) — 从骨干网络映射输出的特征图维度。

• mask_dim (int, optional, 默认为 256) — 像素解码器中特征图的维度。

• hidden_dim (int, optional, 默认为 256) — 变压器解码器中隐藏状态的维度。

• encoder_feedforward_dim (int, optional, 默认为 1024) — 像素解码器中 FFN 层的维度。

• norm (str, optional, 默认为 "GN") — 归一化类型。

• encoder_layers (int, optional, 默认为 6) — 像素解码器中的层数。

• decoder_layers (int, optional, 默认为 10) — 变压器解码器中的层数。

• use_task_norm (bool, optional, 默认为 True) — 是否对任务令牌进行归一化。

• num_attention_heads (int, optional, 默认为 8) — 像素和变压器解码器中的注意力头数。

• dropout (float, optional, 默认为 0.1) — 像素和变压器解码器的丢失概率。

• dim_feedforward (int, optional, 默认为 2048) — 变压器解码器中 FFN 层的维度。

• pre_norm (bool, optional, 默认为 False) — 是否在变压器解码器中的注意力层之前对隐藏状态进行归一化。

• enforce_input_proj (bool, optional, 默认为 False) — 是否在变压器解码器中投影隐藏状态。

• query_dec_layers (int, optional, 默认为 2) — 查询变压器中的层数。

• common_stride (int, optional, 默认为 4) — 用于像素解码器中特征的常用步幅。

这是用于存储 OneFormerModel 配置的配置类。它用于根据指定的参数实例化一个 OneFormer 模型，定义模型架构。使用默认值实例化配置将产生类似于在 ADE20k-150 上训练的 OneFormer shi-labs/oneformer_ade20k_swin_tiny 架构的配置。

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

示例:

>>> from transformers import OneFormerConfig, OneFormerModel

>>> # Initializing a OneFormer shi-labs/oneformer_ade20k_swin_tiny configuration
>>> configuration = OneFormerConfig()
>>> # Initializing a model (with random weights) from the shi-labs/oneformer_ade20k_swin_tiny style configuration
>>> model = OneFormerModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config

OneFormerImageProcessor

class transformers.OneFormerImageProcessor

< source >

( do_resize: bool = True size: Dict = None resample: Resampling = <Resampling.BILINEAR: 2> do_rescale: bool = True rescale_factor: float = 0.00392156862745098 do_normalize: bool = True image_mean: Union = None image_std: Union = None ignore_index: Optional = None do_reduce_labels: bool = False repo_path: Optional = 'shi-labs/oneformer_demo' class_info_file: str = None num_text: Optional = None **kwargs )

参数

• do_resize (bool, optional, 默认为 True) — 是否将输入调整大小到特定的 size。

• size (int, optional, 默认为 800) — 将输入调整大小到给定大小。仅在 do_resize 设置为 True 时有效。如果 size 是一个类似 (width, height) 的序列，则输出大小将匹配到这个。如果 size 是一个整数，图像的较小边将匹配到这个数字。即，如果 height > width，则图像将重新缩放为 (size * height / width, size)。

• resample (int, optional, 默认为 Resampling.BILINEAR) — 可选的重采样滤波器。可以是 PIL.Image.Resampling.NEAREST, PIL.Image.Resampling.BOX, PIL.Image.Resampling.BILINEAR, PIL.Image.Resampling.HAMMING, PIL.Image.Resampling.BICUBIC 或 PIL.Image.Resampling.LANCZOS 中的一个。仅在 do_resize 设置为 True 时有效。

• do_rescale (bool, optional, 默认为 True) — 是否将输入重新缩放到特定的 scale。

• rescale_factor (float, optional, 默认为 1/ 255) — 通过给定因子重新缩放输入。仅在 do_rescale 设置为 True 时有效。

• do_normalize（bool，可选，默认为True）— 是否对输入进行均值和标准差归一化。

• image_mean（int，可选，默认为[0.485, 0.456, 0.406]）— 每个通道的均值序列，在规范化图像时使用。默认为 ImageNet 均值。

• image_std（int，可选，默认为[0.229, 0.224, 0.225]）— 每个通道的标准差序列，在规范化图像时使用。默认为 ImageNet 标准差。

• ignore_index（int，可选）— 分割地图中要分配给背景像素的标签。如果提供，用 0（背景）表示的分割地图像素将被替换为ignore_index。

• do_reduce_labels（bool，可选，默认为False）— 是否将所有分割地图的标签值减 1。通常用于数据集中使用 0 表示背景，并且背景本身不包含在数据集的所有类中的情况（例如 ADE20k）。背景标签将被替换为ignore_index。

• repo_path（str，可选，默认为"shi-labs/oneformer_demo"）— 包含数据集类信息的 JSON 文件的 hub 存储库或本地目录的路径。如果未设置，将在当前工作目录中查找class_info_file。

• class_info_file（str，可选）— 包含数据集类信息的 JSON 文件。查看shi-labs/oneformer_demo/cityscapes_panoptic.json以获取示例。

• num_text（int，可选）— 文本输入列表中的文本条目数。

构建一个 OneFormer 图像处理器。该图像处理器可用于为模型准备图像、任务输入以及可选的文本输入和目标。

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

preprocess

< source >

( images: Union task_inputs: Optional = None segmentation_maps: Union = None instance_id_to_semantic_id: Optional = None do_resize: Optional = None size: Optional = None resample: Resampling = None do_rescale: Optional = None rescale_factor: Optional = None do_normalize: Optional = None image_mean: Union = None image_std: Union = None ignore_index: Optional = None do_reduce_labels: Optional = None return_tensors: Union = None data_format: Union = <ChannelDimension.FIRST: 'channels_first'> input_data_format: Union = None **kwargs )

encode_inputs

< source >

( pixel_values_list: List task_inputs: List segmentation_maps: Union = None instance_id_to_semantic_id: Union = None ignore_index: Optional = None reduce_labels: bool = False return_tensors: Union = None input_data_format: Union = None ) → export const metadata = 'undefined';BatchFeature

参数

• pixel_values_list（List[ImageInput]）— 要填充的图像（像素值）列表。每个图像应该是形状为(channels, height, width)的张量。

• task_inputs（List[str]）— 任务值列表。

• segmentation_maps（ImageInput，可选）— 具有像素级注释的相应语义分割地图。

  （bool，可选，默认为True）：是否将图像填充到批次中最大的图像并创建像素掩码。

  如果保持默认设置，将返回一个像素掩码，即：

  • 对于真实像素（即未掩码）为 1，

  • 对于填充像素（即掩码）为 0。

• instance_id_to_semantic_id（List[Dict[int, int]]或Dict[int, int]，可选）— 对象实例 ID 和类 ID 之间的映射。如果传递，segmentation_maps将被视为实例分割地图，其中每个像素表示一个实例 ID。可以提供为单个字典，其中包含全局/数据集级别的映射，或作为字典列表（每个图像一个），以分别映射每个图像中的实例 ID。

• return_tensors（str或 TensorType，可选）— 如果设置，将返回张量而不是 NumPy 数组。如果设置为'pt'，则返回 PyTorch torch.Tensor对象。

• input_data_format（str或ChannelDimension，可选）— 输入图像的通道维度格式。如果未提供，将从输入图像中推断。

返回

BatchFeature

一个具有以下字段的 BatchFeature：

• pixel_values — 要馈送给模型的像素值。

• pixel_mask — 要馈送给模型的像素掩模（当 =True 或 pixel_mask 在 self.model_input_names 中时）。

• mask_labels — 形状为 (labels, height, width) 的可选掩模标签列表，要馈送给模型（当提供 annotations 时）。

• class_labels — 形状为 (labels) 的可选类标签列表，要馈送给模型（当提供 annotations 时）。它们标识 mask_labels 的标签，例如，如果 class_labels[i][j] 的标签为 mask_labels[i][j]。

• text_inputs — 要馈送给模型的可选文本字符串条目列表（当提供 annotations 时）。它们标识图像中存在的二进制掩模。

将图像填充到批处理中最大的图像，并创建相应的 pixel_mask。

OneFormer 使用掩模分类范式来处理语义分割，因此输入分割地图将被转换为二进制掩模列表及其相应的标签。让我们看一个例子，假设 segmentation_maps = [[2,6,7,9]]，输出将包含 mask_labels = [[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1]]（四个二进制掩模）和 class_labels = [2,6,7,9]，每个掩模的标签。

post_process_semantic_segmentation

<来源>

( outputs target_sizes: Optional = None ) → export const metadata = 'undefined';List[torch.Tensor]

参数

• outputs (MaskFormerForInstanceSegmentation) — 模型的原始输出。

• target_sizes (List[Tuple[int, int]], 可选) — 长度为 (batch_size) 的列表，其中每个列表项 (Tuple[int, int]]) 对应于每个预测的请求最终大小（高度、宽度）。如果保持为 None，则不会调整预测大小。

返回

List[torch.Tensor]

一个长度为 batch_size 的列表，每个项是一个形状为 (height, width) 的语义分割地图，对应于目标大小条目（如果指定了 target_sizes）。每个 torch.Tensor 的每个条目对应于一个语义类别 id。

将 MaskFormerForInstanceSegmentation 的输出转换为语义分割地图。仅支持 PyTorch。

post_process_instance_segmentation

<来源>

( outputs task_type: str = 'instance' is_demo: bool = True threshold: float = 0.5 mask_threshold: float = 0.5 overlap_mask_area_threshold: float = 0.8 target_sizes: Optional = None return_coco_annotation: Optional = False ) → export const metadata = 'undefined';List[Dict]

参数

• outputs (OneFormerForUniversalSegmentationOutput) — 从 OneFormerForUniversalSegmentationOutput 得到的输出。

• task_type (str, 可选)，默认为“instance”) — 后处理取决于任务令牌输入。如果 task_type 是“panoptic”，我们需要忽略杂项预测。

• is_demo (bool, 可选)，默认为 True) — 模型是否处于演示模式。如果为真，则使用阈值预测最终掩模。

• threshold (float, 可选, 默认为 0.5) — 保留预测实例掩模的概率分数阈值。

• mask_threshold (float, 可选, 默认为 0.5) — 在将预测的掩模转换为二进制值时使用的阈值。

• overlap_mask_area_threshold (float, 可选, 默认为 0.8) — 合并或丢弃每个二进制实例掩模中的小断开部分的重叠掩模区域阈值。

• target_sizes (List[Tuple], 可选) — 长度为 (batch_size) 的列表，其中每个列表项 (Tuple[int, int]]) 对应于批处理中每个预测的请求最终大小（高度、宽度）。如果保持为 None，则不会调整预测大小。

• return_coco_annotation (bool, 可选)，默认为 False) — 是否以 COCO 格式返回预测。

返回

List[Dict]

一个字典列表，每个图像一个字典，每个字典包含两个键：

• segmentation — 形状为(height, width)的张量，其中每个像素代表一个segment_id，如果未找到高于threshold的掩模，则设置为None。如果指定了target_sizes，则将分割调整为相应的target_sizes条目。

• segments_info — 包含每个段的其他信息的字典。

  • id — 代表segment_id的整数。

  • label_id — 代表与segment_id对应的标签/语义类别 ID 的整数。

  • was_fused — 一个布尔值，如果label_id在label_ids_to_fuse中，则为True，否则为False。相同类别/标签的多个实例被融合并分配一个单独的segment_id。

  • score — 具有segment_id的段的预测分数。

将OneFormerForUniversalSegmentationOutput的输出转换为图像实例分割预测。仅支持 PyTorch。

post_process_panoptic_segmentation

<来源>

( outputs threshold: float = 0.5 mask_threshold: float = 0.5 overlap_mask_area_threshold: float = 0.8 label_ids_to_fuse: Optional = None target_sizes: Optional = None ) → export const metadata = 'undefined';List[Dict]

参数

• outputs（MaskFormerForInstanceSegmentationOutput）— 来自 MaskFormerForInstanceSegmentation 的输出。

• threshold（float，可选，默认为 0.5）— 保留预测实例掩模的概率分数阈值。

• mask_threshold（float，可选，默认为 0.5）— 在将预测的掩模转换为二进制值时使用的阈值。

• overlap_mask_area_threshold（float，可选，默认为 0.8）— 用于合并或丢弃每个二进制实例掩模中的小断开部分的重叠掩模区域阈值。

• label_ids_to_fuse（Set[int]，可选）— 此状态中的标签将使其所有实例被融合在一起。例如，我们可以说图像中只能有一个天空，但可以有几个人，因此天空的标签 ID 将在该集合中，但人的标签 ID 不在其中。

• target_sizes（List[Tuple]，可选）— 长度为（batch_size）的列表，其中每个列表项（Tuple[int, int]）对应于批处理中每个预测的请求的最终大小（高度，宽度）。如果保持为 None，则不会调整预测大小。

返回值

List[Dict]

一个字典列表，每个图像一个，每个字典包含两个键：

• segmentation — 形状为(height, width)的张量，其中每个像素代表一个segment_id，如果未找到高于threshold的掩模，则设置为None。如果指定了target_sizes，则将分割调整为相应的target_sizes条目。

• segments_info — 包含每个段的其他信息的字典。

  • id — 代表segment_id的整数。

  • label_id — 代表与segment_id对应的标签/语义类别 ID 的整数。

  • was_fused — 一个布尔值，如果label_id在label_ids_to_fuse中，则为True，否则为False。相同类别/标签的多个实例被融合并分配一个单独的segment_id。

  • score — 具有segment_id的段的预测分数。

将MaskFormerForInstanceSegmentationOutput的输出转换为图像全景分割预测。仅支持 PyTorch。

OneFormerProcessor

class transformers.OneFormerProcessor

<来源>

( image_processor = None tokenizer = None max_seq_length: int = 77 task_seq_length: int = 77 **kwargs )

参数

• image_processor（OneFormerImageProcessor）— 图像处理器是必需的输入。

• tokenizer（[CLIPTokenizer，CLIPTokenizerFast]）— 分词器是必需的输入。

• max_seq_len（int，可选，默认为 77）— 输入文本列表的序列长度。

• task_seq_len（int，可选，默认为 77）— 输入任务令牌的序列长度。

构建一个 OneFormer 处理器，将 OneFormerImageProcessor 和 CLIPTokenizer/CLIPTokenizerFast 包装成一个单一处理器，继承了图像处理器和标记化器的功能。

encode_inputs

<来源>

( images = None task_inputs = None segmentation_maps = None **kwargs )

此方法将其所有参数转发到 OneFormerImageProcessor.encode_inputs()，然后对任务输入进行标记化。有关更多信息，请参阅此方法的文档字符串。

post_process_instance_segmentation

<来源>

( *args **kwargs )

此方法将其所有参数转发到 OneFormerImageProcessor.post_process_instance_segmentation()。有关更多信息，请参阅此方法的文档字符串。

post_process_panoptic_segmentation

<来源>

( *args **kwargs )

此方法将其所有参数转发到 OneFormerImageProcessor.post_process_panoptic_segmentation()。有关更多信息，请参阅此方法的文档字符串。

post_process_semantic_segmentation

<来源>

( *args **kwargs )

此方法将其所有参数转发到 OneFormerImageProcessor.post_process_semantic_segmentation()。有关更多信息，请参阅此方法的文档字符串。

OneFormerModel

class transformers.OneFormerModel

<来源>

( config: OneFormerConfig )

参数

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

裸的 OneFormer 模型，在顶部没有任何特定的头部输出原始隐藏状态。此模型是 PyTorch nn.Module子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

<来源>

( pixel_values: Tensor task_inputs: Tensor text_inputs: Optional = None pixel_mask: Optional = None output_hidden_states: Optional = None output_attentions: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.oneformer.modeling_oneformer.OneFormerModelOutput or tuple(torch.FloatTensor)

参数

• pixel_values（形状为(batch_size, num_channels, height, width)的torch.FloatTensor）- 像素值。像素值可以使用 OneFormerProcessor 获得。有关详细信息，请参阅OneFormerProcessor.__call__()。

• task_inputs（形状为(batch_size, sequence_length)的torch.FloatTensor）- 任务输入。任务输入可以使用 AutoImageProcessor 获得。有关详细信息，请参阅OneFormerProcessor.__call__()。

• pixel_mask（形状为(batch_size, height, width)的torch.LongTensor，可选）- 用于避免在填充像素值上执行注意力的掩码。在[0, 1]中选择的掩码值：

  • 对于真实像素为 1（即not masked），

  • 对于填充的像素为 0（即masked）。

  什么是注意力掩码？

• output_hidden_states（bool，可选）- 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

• output_attentions（bool，可选）- 是否返回 Detr 解码器注意力层的注意力张量。

• return_dict（bool，可选）- 是否返回~OneFormerModelOutput而不是普通元组。

返回

transformers.models.oneformer.modeling_oneformer.OneFormerModelOutput 或tuple(torch.FloatTensor)

transformers.models.oneformer.modeling_oneformer.OneFormerModelOutput 或torch.FloatTensor元组（如果传递return_dict=False或当config.return_dict=False时）包括根据配置（OneFormerConfig）和输入的各种元素。

• encoder_hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回）- 形状为(batch_size, num_channels, height, width)的torch.FloatTensor元组（一个用于嵌入的输出+一个用于每个阶段的输出）。编码器模型在每个阶段输出的隐藏状态（也称为特征图）。

• pixel_decoder_hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回）- 形状为(batch_size, num_channels, height, width)的torch.FloatTensor元组（一个用于嵌入的输出+一个用于每个阶段的输出）。像素解码器模型在每个阶段输出的隐藏状态（也称为特征图）。

• transformer_decoder_hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回）- 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入的输出+一个用于每个阶段的输出）。transformer 解码器在每个阶段输出的隐藏状态（也称为特征图）。

• transformer_decoder_object_queries（形状为(batch_size, num_queries, hidden_dim)的torch.FloatTensor）- transformer 解码器中最后一层的输出对象查询。

• transformer_decoder_contrastive_queries（形状为(batch_size, num_queries, hidden_dim)的torch.FloatTensor）- 来自 transformer 解码器的对比查询。

• transformer_decoder_mask_predictions（形状为(batch_size, num_queries, height, width)的torch.FloatTensor）- transformer 解码器中最后一层的掩码预测。

• transformer_decoder_class_predictions（形状为(batch_size, num_queries, num_classes+1)的torch.FloatTensor）- transformer 解码器中最后一层的类别预测。

• transformer_decoder_auxiliary_predictions（str，torch.FloatTensor字典的元组，可选）- 来自 transformer 解码器每一层的类别和掩码预测的元组。

• text_queries（torch.FloatTensor，可选，形状为(batch_size, num_queries, hidden_dim)）- 从用于训练期间计算对比损失的输入文本列表派生的文本查询。

• task_token（形状为(batch_size, hidden_dim)的torch.FloatTensor）- 用于条件查询的一维任务令牌。

• attentions（tuple(tuple(torch.FloatTensor))，可选，当传递output_attentions=True或当config.output_attentions=True时返回）— 形状为(batch_size, num_heads, sequence_length, sequence_length)的tuple(torch.FloatTensor)元组。来自变压器解码器的自注意力和交叉注意力权重。

OneFormerModelOutput

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

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

示例：

>>> import torch
>>> from PIL import Image
>>> import requests
>>> from transformers import OneFormerProcessor, OneFormerModel

>>> # download texting image
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> # load processor for preprocessing the inputs
>>> processor = OneFormerProcessor.from_pretrained("shi-labs/oneformer_ade20k_swin_tiny")
>>> model = OneFormerModel.from_pretrained("shi-labs/oneformer_ade20k_swin_tiny")
>>> inputs = processor(image, ["semantic"], return_tensors="pt")

>>> with torch.no_grad():
...     outputs = model(**inputs)

>>> mask_predictions = outputs.transformer_decoder_mask_predictions
>>> class_predictions = outputs.transformer_decoder_class_predictions

>>> f"👉 Mask Predictions Shape: {list(mask_predictions.shape)}, Class Predictions Shape: {list(class_predictions.shape)}"
'👉 Mask Predictions Shape: [1, 150, 128, 171], Class Predictions Shape: [1, 150, 151]'

OneFormerForUniversalSegmentation

class transformers.OneFormerForUniversalSegmentation

<来源>

( config: OneFormerConfig )

参数

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

OneFormer 模型例如，语义和全景图像分割。此模型是 PyTorch nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

<来源>

( pixel_values: Tensor task_inputs: Tensor text_inputs: Optional = None mask_labels: Optional = None class_labels: Optional = None pixel_mask: Optional = None output_auxiliary_logits: Optional = None output_hidden_states: Optional = None output_attentions: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.oneformer.modeling_oneformer.OneFormerForUniversalSegmentationOutput or tuple(torch.FloatTensor)

参数

• pixel_values（形状为(batch_size, num_channels, height, width)的torch.FloatTensor）— 像素值。像素值可以使用 OneFormerProcessor 获取。有关详细信息，请参阅OneFormerProcessor.__call__()。

• task_inputs（形状为(batch_size, sequence_length)的torch.FloatTensor）— 任务输入。任务输入可以使用 AutoImageProcessor 获取。有关详细信息，请参阅OneFormerProcessor.__call__()。

• pixel_mask（形状为(batch_size, height, width)的torch.LongTensor，可选）— 用于避免在填充像素值上执行注意力的掩码。掩码值选在[0, 1]中：

  • 对于真实像素（即not masked）的像素为 1，

  • 对于填充像素（即masked）的像素为 0。

  注意力掩码是什么？

• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

• output_attentions（bool，可选）— 是否返回 Detr 解码器注意力层的注意力张量。

• return_dict（bool，可选）— 是否返回~OneFormerModelOutput而不是普通元组。

• text_inputs（List[torch.Tensor]，可选）— 形状为(num_queries, sequence_length)的张量，将被馈送到模型

• mask_labels（List[torch.Tensor]，可选）— 形状为(num_labels, height, width)的掩码标签列表，将被馈送到模型

• class_labels（List[torch.LongTensor]，可选）— 形状为(num_labels, height, width)的目标类标签列表，将被馈送到模型。它们标识mask_labels的标签，例如，如果class_labels[i][j]的标签是mask_labels[i][j]。

返回

transformers.models.oneformer.modeling_oneformer.OneFormerForUniversalSegmentationOutput 或tuple(torch.FloatTensor)

transformers.models.oneformer.modeling_oneformer.OneFormerForUniversalSegmentationOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或当config.return_dict=False时）包含根据配置（OneFormerConfig）和输入的各种元素。

• loss（torch.Tensor，可选）—计算得到的损失，在存在标签时返回。

• class_queries_logits（torch.FloatTensor）—形状为(batch_size, num_queries, num_labels + 1)的张量，表示每个查询的提议类别。请注意，需要+ 1，因为我们包含了空类。

• masks_queries_logits（torch.FloatTensor）—形状为(batch_size, num_queries, height, width)的张量，表示每个查询的提议掩码。

• auxiliary_predictions（str，torch.FloatTensor字典的列表，可选）—来自 transformer 解码器每一层的类别和掩码预测的列表。

• encoder_hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回）—形状为(batch_size, num_channels, height, width)的torch.FloatTensor元组（一个用于嵌入的输出 + 一个用于每个阶段的输出）。编码器模型在每个阶段输出的隐藏状态（也称为特征图）。

• pixel_decoder_hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回）—形状为(batch_size, num_channels, height, width)的torch.FloatTensor元组（一个用于嵌入的输出 + 一个用于每个阶段的输出）。像素解码器模型在每个阶段输出的隐藏状态（也称为特征图）。

• transformer_decoder_hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回）—形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入的输出 + 一个用于每个阶段的输出）。transformer 解码器在每个阶段输出的隐藏状态（也称为特征图）。

• transformer_decoder_object_queries（torch.FloatTensor，形状为(batch_size, num_queries, hidden_dim)）—transformer 解码器中最后一层的输出对象查询。

• transformer_decoder_contrastive_queries（torch.FloatTensor，形状为(batch_size, num_queries, hidden_dim)）—transformer 解码器中的对比查询。

• transformer_decoder_mask_predictions（torch.FloatTensor，形状为(batch_size, num_queries, height, width)）—transformer 解码器中最后一层的掩码预测。

• transformer_decoder_class_predictions（torch.FloatTensor，形状为(batch_size, num_queries, num_classes+1)）—transformer 解码器中最后一层的类别预测。

• transformer_decoder_auxiliary_predictions（str，torch.FloatTensor字典的列表，可选）—来自 transformer 解码器每一层的类别和掩码预测的列表。

• text_queries（torch.FloatTensor，可选，形状为(batch_size, num_queries, hidden_dim)）—从用于训练期间计算对比损失的输入文本列表派生的文本查询。

• task_token（torch.FloatTensor，形状为(batch_size, hidden_dim)）—用于条件查询的一维任务令牌。

• attentions (tuple(tuple(torch.FloatTensor)), 可选，当传递output_attentions=True或当config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tuple(torch.FloatTensor)元组（每层一个）。来自变压器解码器的自注意力和交叉注意力权重。

OneFormerUniversalSegmentationOutput

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

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

示例：

通用分割示例：

>>> from transformers import OneFormerProcessor, OneFormerForUniversalSegmentation
>>> from PIL import Image
>>> import requests
>>> import torch

>>> # load OneFormer fine-tuned on ADE20k for universal segmentation
>>> processor = OneFormerProcessor.from_pretrained("shi-labs/oneformer_ade20k_swin_tiny")
>>> model = OneFormerForUniversalSegmentation.from_pretrained("shi-labs/oneformer_ade20k_swin_tiny")

>>> url = (
...     "https://huggingface.co/datasets/hf-internal-testing/fixtures_ade20k/resolve/main/ADE_val_00000001.jpg"
... )
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> # Semantic Segmentation
>>> inputs = processor(image, ["semantic"], return_tensors="pt")

>>> with torch.no_grad():
...     outputs = model(**inputs)
>>> # model predicts class_queries_logits of shape `(batch_size, num_queries)`
>>> # and masks_queries_logits of shape `(batch_size, num_queries, height, width)`
>>> class_queries_logits = outputs.class_queries_logits
>>> masks_queries_logits = outputs.masks_queries_logits

>>> # you can pass them to processor for semantic postprocessing
>>> predicted_semantic_map = processor.post_process_semantic_segmentation(
...     outputs, target_sizes=[image.size[::-1]]
... )[0]
>>> f"👉 Semantic Predictions Shape: {list(predicted_semantic_map.shape)}"
'👉 Semantic Predictions Shape: [512, 683]'

>>> # Instance Segmentation
>>> inputs = processor(image, ["instance"], return_tensors="pt")

>>> with torch.no_grad():
...     outputs = model(**inputs)
>>> # model predicts class_queries_logits of shape `(batch_size, num_queries)`
>>> # and masks_queries_logits of shape `(batch_size, num_queries, height, width)`
>>> class_queries_logits = outputs.class_queries_logits
>>> masks_queries_logits = outputs.masks_queries_logits

>>> # you can pass them to processor for instance postprocessing
>>> predicted_instance_map = processor.post_process_instance_segmentation(
...     outputs, target_sizes=[image.size[::-1]]
... )[0]["segmentation"]
>>> f"👉 Instance Predictions Shape: {list(predicted_instance_map.shape)}"
'👉 Instance Predictions Shape: [512, 683]'

>>> # Panoptic Segmentation
>>> inputs = processor(image, ["panoptic"], return_tensors="pt")

>>> with torch.no_grad():
...     outputs = model(**inputs)
>>> # model predicts class_queries_logits of shape `(batch_size, num_queries)`
>>> # and masks_queries_logits of shape `(batch_size, num_queries, height, width)`
>>> class_queries_logits = outputs.class_queries_logits
>>> masks_queries_logits = outputs.masks_queries_logits

>>> # you can pass them to processor for panoptic postprocessing
>>> predicted_panoptic_map = processor.post_process_panoptic_segmentation(
...     outputs, target_sizes=[image.size[::-1]]
... )[0]["segmentation"]
>>> f"👉 Panoptic Predictions Shape: {list(predicted_panoptic_map.shape)}"
'👉 Panoptic Predictions Shape: [512, 683]'