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

Transformers 4.37 中文文档（四十三）

原文：huggingface.co/docs/transformers

GIT

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

概述

GIT 模型是由 Jianfeng Wang、Zhengyuan Yang、Xiaowei Hu、Linjie Li、Kevin Lin、Zhe Gan、Zicheng Liu、Ce Liu、Lijuan Wang 在《GIT: A Generative Image-to-text Transformer for Vision and Language》中提出的。GIT 是一种仅解码的 Transformer，利用 CLIP 的视觉编码器来除了文本外还对模型进行视觉输入的条件。该模型在图像字幕和视觉问答基准上取得了最先进的结果。

论文摘要如下：

在本文中，我们设计并训练了一个生成式图像文本 Transformer，GIT，以统一图像/视频字幕和问题回答等视觉-语言任务。虽然生成模型在预训练和微调之间提供了一致的网络架构，但现有工作通常包含复杂的结构（单/多模态编码器/解码器）并依赖于外部模块，如目标检测器/标记器和光学字符识别（OCR）。在 GIT 中，我们简化了架构，将其作为一个图像编码器和一个文本解码器在单一语言建模任务下。我们还扩大了预训练数据和模型规模以提高模型性能。没有花哨的东西，我们的 GIT 在 12 个具有挑战性的基准上建立了新的最先进技术，差距很大。例如，我们的模型首次在 TextCaps 上超越了人类表现（CIDEr 中的 138.2 vs. 125.5）。此外，我们提出了一种新的基于生成的图像分类和场景文本识别方案，在标准基准上取得了不错的表现。

GIT 架构。摘自原始论文。

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

使用提示

• GIT 的实现方式与 GPT-2 非常相似，唯一的区别在于模型还受到pixel_values的影响。

资源

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

• 关于在自定义数据上进行推理+微调 GIT 的演示笔记本可以在此处找到。

• 另请参阅：因果语言建模任务指南

如果您有兴趣提交资源以包含在此处，请随时提交拉取请求，我们将进行审查。资源应该理想地展示一些新内容，而不是重复现有资源。

GitVisionConfig

class transformers.GitVisionConfig

<来源>

( hidden_size = 768 intermediate_size = 3072 num_hidden_layers = 12 num_attention_heads = 12 num_channels = 3 image_size = 224 patch_size = 16 hidden_act = 'quick_gelu' layer_norm_eps = 1e-05 attention_dropout = 0.0 initializer_range = 0.02 **kwargs )

参数

• hidden_size（int，可选，默认为 768）— 编码器层和池化器层的维度。

• intermediate_size（int，可选，默认为 3072）— Transformer 编码器中“中间”（即前馈）层的维度。

• num_hidden_layers（int，可选，默认为 12）— Transformer 编码器中的隐藏层数。

• num_attention_heads（int，可选，默认为 12）— Transformer 编码器中每个注意力层的注意力头数。

• image_size（int，可选，默认为 224）— 每个图像的大小（分辨率）。

• patch_size（int，可选，默认为 16）— 每个补丁的大小（分辨率）。

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

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

• attention_dropout (float，可选，默认为 0.0) — 注意力概率的丢弃比率。

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

这是用于存储 GitVisionModel 配置的配置类。根据指定的参数实例化 GIT 视觉编码器，定义模型架构。使用默认值实例化配置将产生类似于 GIT microsoft/git-base架构的视觉编码器的配置。

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

示例：

>>> from transformers import GitVisionConfig, GitVisionModel

>>> # Initializing a GitVisionConfig with microsoft/git-base style configuration
>>> configuration = GitVisionConfig()

>>> # Initializing a GitVisionModel (with random weights) from the microsoft/git-base style configuration
>>> model = GitVisionModel(configuration)

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

GitVisionModel

class transformers.GitVisionModel

<来源>

( config: GitVisionConfig )

参数

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

CLIP 中使用的视觉模型，在 GIT 中没有顶部的头部或投影。

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

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

forward

<来源>

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

参数

• pixel_values (torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 像素值。默认情况下会忽略填充。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 CLIPImageProcessor.call()。

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

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

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

返回

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

一个 transformers.modeling_outputs.BaseModelOutput 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时）包含根据配置（<class 'transformers.models.git.configuration_git.GitVisionConfig'>）和输入的不同元素。

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

• hidden_states (tuple(torch.FloatTensor)，可选，当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回） — 形状为 (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 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

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

>>> processor = AutoProcessor.from_pretrained("microsoft/git-base")
>>> model = GitVisionModel.from_pretrained("microsoft/git-base")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

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

>>> outputs = model(**inputs)
>>> last_hidden_state = outputs.last_hidden_state

GitConfig

class transformers.GitConfig

< source >

( vision_config = None vocab_size = 30522 hidden_size = 768 num_hidden_layers = 6 num_attention_heads = 12 intermediate_size = 3072 hidden_act = 'gelu' hidden_dropout_prob = 0.1 attention_probs_dropout_prob = 0.1 max_position_embeddings = 1024 initializer_range = 0.02 layer_norm_eps = 1e-12 pad_token_id = 0 position_embedding_type = 'absolute' use_cache = True tie_word_embeddings = False bos_token_id = 101 eos_token_id = 102 num_image_with_embedding = None **kwargs )

参数

• vision_config (dict，可选) — 用于初始化 GitVisionConfig 的配置选项字典。

• vocab_size (int，可选，默认为 30522) — GIT 模型的词汇量大小。定义了在调用 GitModel 时可以由 inputs_ids 表示的不同标记数量。

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

• num_hidden_layers (int，可选，默认为 6) — Transformer 编码器中的隐藏层数量。

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

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

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

• hidden_dropout_prob (float，可选，默认为 0.1) — 嵌入层、编码器和池化器中所有全连接层的丢弃概率。

• attention_probs_dropout_prob (float，可选，默认为 0.1) — 注意力概率的丢弃比率。

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

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

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

• position_embedding_type (str, optional, defaults to "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 (https://arxiv.org/abs/2009.13658)。

• use_cache (bool, optional, defaults to True) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）。

• num_image_with_embedding (int, optional) — 要添加的时间嵌入数量，如果模型用于视频字幕/VQA。

这是用于存储 GitModel 配置的配置类。它用于根据指定的参数实例化 GIT 模型，定义模型架构。使用默认值实例化配置将产生类似于 GIT microsoft/git-base 架构的配置。

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

示例：

>>> from transformers import GitConfig, GitModel

>>> # Initializing a GIT microsoft/git-base style configuration
>>> configuration = GitConfig()

>>> # Initializing a model (with random weights) from the microsoft/git-base style configuration
>>> model = GitModel(configuration)

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

GitProcessor

class transformers.GitProcessor

< source >

( image_processor tokenizer )

参数

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

• tokenizer (AutoTokenizer) — Tokenizer 是必需的输入。

构建一个 GIT 处理器，将 CLIP 图像处理器和 BERT 分词器包装成单个处理器。

GitProcessor 提供了 CLIPImageProcessor 和 BertTokenizerFast 的所有功能。查看 call() 和 decode() 以获取更多信息。

__call__

< source >

( text = None images = None return_tensors = None **kwargs ) → export const metadata = 'undefined';BatchEncoding

参数

• text (str, List[str], List[List[str]]) — 要编码的序列或序列批次。每个序列可以是字符串或字符串列表（预分词字符串）。如果序列以字符串列表（预分词）的形式提供，则必须设置 is_split_into_words=True（以消除与序列批次的歧义）。

• images (PIL.Image.Image, np.ndarray, torch.Tensor, List[PIL.Image.Image], List[np.ndarray], List[torch.Tensor]) — 要准备的图像或图像批次。每个图像可以是 PIL 图像、NumPy 数组或 PyTorch 张量。如果是 NumPy 数组/PyTorch 张量，则每个图像应为形状 (C, H, W)，其中 C 是通道数，H 和 W 是图像高度和宽度。

• return_tensors (str 或 TensorType, optional) — 如果设置，将返回特定框架的张量。可接受的值为：

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

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

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

  • 'jax': 返回 JAX jnp.ndarray 对象。

返回

BatchEncoding

一个带有以下字段的 BatchEncoding：

• input_ids — 要提供给模型的标记 id 列表。当text不为None时返回。

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

• pixel_values — 要提供给模型的像素值。当images不为None时返回。

为模型准备一个或多个序列和图像的主要方法。如果text不为None，则此方法将text和kwargs参数转发给 BertTokenizerFast 的call()以对文本进行编码。为准备图像，如果images不为None，则此方法将images和kwrags参数转发给 CLIPImageProcessor 的call()。请参考上述两种方法的文档以获取更多信息。

GitModel

class transformers.GitModel

<来源>

( config )

参数

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

由 CLIP 图像编码器和文本解码器组成的基本 GIT 模型变压器，输出原始隐藏状态，没有特定的头部。

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

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

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None position_ids: Optional = None pixel_values: Optional = None head_mask: Optional = None inputs_embeds: Optional = None past_key_values: Optional = None use_cache: 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（形状为(batch_size, sequence_length)的torch.LongTensor） — 词汇表中输入序列标记的索引。

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

  什么是输入 ID？

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

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

  • 0 表示“被掩码”的标记。

  什么是注意力掩码？

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

  什么是位置 ID？

• pixel_values (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 CLIPImageProcessor.call()。

• 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 而不是普通元组。

• past_key_values (tuple(tuple(torch.FloatTensor))，长度为config.n_layers，每个元组包含 4 个形状为(batch_size, num_heads, sequence_length - 1, embed_size_per_head)的张量） — 包含注意力块的预计算的键和值隐藏状态。可用于加速解码。

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

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

返回

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

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

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

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

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

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

• attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组。

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

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

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

示例：

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

>>> processor = AutoProcessor.from_pretrained("microsoft/git-base")
>>> model = AutoModel.from_pretrained("microsoft/git-base")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> text = "this is an image of two cats"

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

>>> outputs = model(**inputs)
>>> last_hidden_state = outputs.last_hidden_state

GitForCausalLM

class transformers.GitForCausalLM

< source >

( config )

参数

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

带有语言建模头部的 GIT 模型，用于自回归语言建模。

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

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

forward

< source >

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

参数

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

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

  什么是输入 ID？

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

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

  • 0 表示被掩码的标记。

  什么是注意力掩码？

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

  什么是位置 ID？

• pixel_values (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 像素值。可以使用 AutoImageProcessor 获取像素值。查看 CLIPImageProcessor.call()获取详细信息。

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

  • 1 表示头部未被掩盖，

  • 0 表示头部被“掩盖”。

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

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

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

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

• labels（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 用于计算从左到右的语言建模损失（下一个单词预测）的标签。索引应在[-100, 0, ..., config.vocab_size]中（请参见input_ids文档字符串）。索引设置为-100的标记将被忽略（掩盖），仅对具有标签 n [0, ..., config.vocab_size]的标记计算损失

• past_key_values（长度为config.n_layers的tuple(tuple(torch.FloatTensor))，每个元组包含形状为(batch_size, num_heads, sequence_length - 1, embed_size_per_head)的 4 个张量）— 包含注意力块的预计算键和值隐藏状态。可用于加速解码。

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

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

返回

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

一个 transformers.modeling_outputs.CausalLMOutputWithPast 或一个torch.FloatTensor元组（如果传递了return_dict=False或config.return_dict=False时）包含根据配置（GitConfig）和输入的各种元素。

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

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

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

  包含预计算的隐藏状态（自注意块中的键和值）可用于加速顺序解码（请参见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 之后，用于计算自注意力头中的加权平均值。

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

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

示例：

图像字幕示例：

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

>>> processor = AutoProcessor.from_pretrained("microsoft/git-base-coco")
>>> model = AutoModelForCausalLM.from_pretrained("microsoft/git-base-coco")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> pixel_values = processor(images=image, return_tensors="pt").pixel_values

>>> generated_ids = model.generate(pixel_values=pixel_values, max_length=50)
>>> generated_caption = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
>>> print(generated_caption)
two cats sleeping on a pink blanket next to remotes.

视觉问答（VQA）示例：

>>> from transformers import AutoProcessor, AutoModelForCausalLM
>>> from huggingface_hub import hf_hub_download
>>> from PIL import Image

>>> processor = AutoProcessor.from_pretrained("microsoft/git-base-textvqa")
>>> model = AutoModelForCausalLM.from_pretrained("microsoft/git-base-textvqa")

>>> file_path = hf_hub_download(repo_id="nielsr/textvqa-sample", filename="bus.png", repo_type="dataset")
>>> image = Image.open(file_path).convert("RGB")

>>> pixel_values = processor(images=image, return_tensors="pt").pixel_values

>>> question = "what does the front of the bus say at the top?"

>>> input_ids = processor(text=question, add_special_tokens=False).input_ids
>>> input_ids = [processor.tokenizer.cls_token_id] + input_ids
>>> input_ids = torch.tensor(input_ids).unsqueeze(0)

>>> generated_ids = model.generate(pixel_values=pixel_values, input_ids=input_ids, max_length=50)
>>> print(processor.batch_decode(generated_ids, skip_special_tokens=True))
['what does the front of the bus say at the top? special']

视频字幕示例：

>>> import av
>>> import numpy as np
>>> from PIL import Image
>>> from huggingface_hub import hf_hub_download
>>> from transformers import AutoProcessor, AutoModelForCausalLM

>>> processor = AutoProcessor.from_pretrained("microsoft/git-base-vatex")
>>> model = AutoModelForCausalLM.from_pretrained("microsoft/git-base-vatex")

>>> # set seed for reproducability
>>> np.random.seed(45)

>>> def read_video_pyav(container, indices):
...     '''
...     Decode the video with PyAV decoder.
...     Args:
...         container (`av.container.input.InputContainer`): PyAV container.
...         indices (`List[int]`): List of frame indices to decode.
...     Returns:
...         result (np.ndarray): np array of decoded frames of shape (num_frames, height, width, 3).
...     '''
...     frames = []
...     container.seek(0)
...     start_index = indices[0]
...     end_index = indices[-1]
...     for i, frame in enumerate(container.decode(video=0)):
...         if i > end_index:
...             break
...         if i >= start_index and i in indices:
...             frames.append(frame)
...     return np.stack([x.to_ndarray(format="rgb24") for x in frames])

>>> def sample_frame_indices(clip_len, frame_sample_rate, seg_len):
...     '''
...     Sample a given number of frame indices from the video.
...     Args:
...         clip_len (`int`): Total number of frames to sample.
...         frame_sample_rate (`int`): Sample every n-th frame.
...         seg_len (`int`): Maximum allowed index of sample's last frame.
...     Returns:
...         indices (`List[int]`): List of sampled frame indices
...     '''
...     converted_len = int(clip_len * frame_sample_rate)
...     end_idx = np.random.randint(converted_len, seg_len)
...     start_idx = end_idx - converted_len
...     indices = np.linspace(start_idx, end_idx, num=clip_len)
...     indices = np.clip(indices, start_idx, end_idx - 1).astype(np.int64)
...     return indices

>>> # load video
>>> file_path = hf_hub_download(
...     repo_id="nielsr/video-demo", filename="eating_spaghetti.mp4", repo_type="dataset"
... )
>>> container = av.open(file_path)

>>> # sample frames
>>> num_frames = model.config.num_image_with_embedding
>>> indices = sample_frame_indices(
...     clip_len=num_frames, frame_sample_rate=4, seg_len=container.streams.video[0].frames
... )
>>> frames = read_video_pyav(container, indices)

>>> pixel_values = processor(images=list(frames), return_tensors="pt").pixel_values

>>> generated_ids = model.generate(pixel_values=pixel_values, max_length=50)

>>> print("Generated caption:", processor.batch_decode(generated_ids, skip_special_tokens=True))
Generated caption: ['a woman is sitting at a table and she is talking about the food she is holding.']

GroupViT

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

概述

GroupViT 模型是由 Jiarui Xu、Shalini De Mello、Sifei Liu、Wonmin Byeon、Thomas Breuel、Jan Kautz、Xiaolong Wang 在GroupViT: Semantic Segmentation Emerges from Text Supervision中提出的。受 CLIP 启发，GroupViT 是一种可以对任何给定词汇类别执行零调校语义分割的视觉语言模型。

论文摘要如下：

分组和识别是视觉场景理解的重要组成部分，例如目标检测和语义分割。在端到端深度学习系统中，图像区域的分组通常是通过来自像素级别识别标签的自上而下监督隐式发生的。相反，在本文中，我们提出将分组机制重新引入深度网络中，这允许语义段仅通过文本监督自动出现。我们提出了一种分层分组视觉 Transformer（GroupViT），它超越了常规的网格结构表示，并学会将图像区域分组成逐渐变大的任意形状的段。我们通过对比损失在大规模图像文本数据集上联合训练 GroupViT 和文本编码器。仅通过文本监督且没有任何像素级注释，GroupViT 学会将语义区域组合在一起，并成功地以零调校的方式转移到语义分割任务，即无需进一步微调。在 PASCAL VOC 2012 数据集上实现了 52.3%的零调校 mIoU 准确率，在 PASCAL Context 数据集上实现了 22.4%的 mIoU，并且与需要更高级别监督的最先进的迁移学习方法竞争力相当。

该模型由xvjiarui贡献。TensorFlow 版本由ariG23498与Yih-Dar SHIEH、Amy Roberts和Joao Gante的帮助下贡献。原始代码可以在这里找到。

使用提示

• 您可以在GroupViTModel的前向传递中指定output_segmentation=True以获取输入文本的分割 logits。

资源

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

• 开始使用 GroupViT 的最快方法是查看示例笔记本（展示了零调校分割推断）。

• 您也可以查看HuggingFace Spaces 演示来体验 GroupViT。

GroupViTConfig

class transformers.GroupViTConfig

<来源>

( text_config = None vision_config = None projection_dim = 256 projection_intermediate_dim = 4096 logit_scale_init_value = 2.6592 **kwargs )

参数

• text_config (dict, 可选) — 用于初始化 GroupViTTextConfig 的配置选项字典。

• vision_config (dict, 可选) — 用于初始化 GroupViTVisionConfig 的配置选项字典。

• projection_dim (int, 可选, 默认为 256) — 文本和视觉投影层的维度。

• projection_intermediate_dim (int, 可选, 默认为 4096) — 文本和视觉投影层的中间层的维度。

• logit_scale_init_value (float, 可选, 默认为 2.6592) — logit_scale参数的初始值。默认值根据原始 GroupViT 实现使用。

• kwargs (可选) — 关键字参数字典。

GroupViTConfig 是用于存储 GroupViTModel 配置的配置类。它用于根据指定的参数实例化一个 GroupViT 模型，定义文本模型和视觉模型配置。使用默认值实例化配置将产生类似于 GroupViT nvidia/groupvit-gcc-yfcc架构的配置。

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

from_text_vision_configs

<来源>

( text_config: GroupViTTextConfig vision_config: GroupViTVisionConfig **kwargs ) → export const metadata = 'undefined';GroupViTConfig

返回

GroupViTConfig

配置对象的一个实例

从 groupvit 文本模型配置和 groupvit 视觉模型配置实例化一个 GroupViTConfig（或派生类）。

GroupViTTextConfig

class transformers.GroupViTTextConfig

<来源>

( vocab_size = 49408 hidden_size = 256 intermediate_size = 1024 num_hidden_layers = 12 num_attention_heads = 4 max_position_embeddings = 77 hidden_act = 'quick_gelu' layer_norm_eps = 1e-05 dropout = 0.0 attention_dropout = 0.0 initializer_range = 0.02 initializer_factor = 1.0 pad_token_id = 1 bos_token_id = 49406 eos_token_id = 49407 **kwargs )

参数

• vocab_size (int, optional, defaults to 49408) — GroupViT 文本模型的词汇量。定义了在调用 GroupViTModel 时可以表示的不同标记数量。

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

• intermediate_size (int, optional, defaults to 1024) — Transformer 编码器中“中间”（即前馈）层的维度。

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

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

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

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

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

• attention_dropout (float, optional, defaults to 0.0) — 注意力概率的 dropout 比率。

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

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

• initializer_factor (float, optional, defaults to 1.0) — 用于初始化所有权重矩阵的因子（应保持为 1，用于内部初始化测试）。

这是用于存储 GroupViTTextModel 配置的配置类。根据指定的参数实例化一个 GroupViT 模型，定义模型架构。使用默认值实例化配置将产生类似于 GroupViT nvidia/groupvit-gcc-yfcc架构的配置。

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

示例：

>>> from transformers import GroupViTTextConfig, GroupViTTextModel

>>> # Initializing a GroupViTTextModel with nvidia/groupvit-gcc-yfcc style configuration
>>> configuration = GroupViTTextConfig()

>>> model = GroupViTTextModel(configuration)

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

GroupViTVisionConfig

class transformers.GroupViTVisionConfig

< source >

( hidden_size = 384 intermediate_size = 1536 depths = [6, 3, 3] num_hidden_layers = 12 num_group_tokens = [64, 8, 0] num_output_groups = [64, 8, 8] num_attention_heads = 6 image_size = 224 patch_size = 16 num_channels = 3 hidden_act = 'gelu' layer_norm_eps = 1e-05 dropout = 0.0 attention_dropout = 0.0 initializer_range = 0.02 initializer_factor = 1.0 assign_eps = 1.0 assign_mlp_ratio = [0.5, 4] **kwargs )

参数

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

• intermediate_size (int, optional, defaults to 1536) — Transformer 编码器中“中间”（即前馈）层的维度。

• depths (List[int], optional, defaults to [6, 3, 3]) — 每个编码器块中的层数。

• num_group_tokens (List[int], optional, defaults to [64, 8, 0]) — 每个阶段的组令牌数。

• num_output_groups (List[int], optional, defaults to [64, 8, 8]) — 每个阶段的输出组数，0 表示没有组。

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

• image_size (int, optional, defaults to 224) — 每个图像的大小（分辨率）。

• patch_size (int, optional, defaults to 16) — 每个补丁的大小（分辨率）。

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

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

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

• attention_dropout (float, optional, defaults to 0.0) — 注意力概率的 dropout 比率。

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

• initializer_factor (float, optional, defaults to 1.0) — 用于初始化所有权重矩阵的因子（应保持为 1，用于内部初始化测试）。

这是用于存储 GroupViTVisionModel 配置的配置类。根据指定的参数实例化一个 GroupViT 模型，定义模型架构。使用默认值实例化配置将产生类似于 GroupViT nvidia/groupvit-gcc-yfcc架构的配置。

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

示例：

>>> from transformers import GroupViTVisionConfig, GroupViTVisionModel

>>> # Initializing a GroupViTVisionModel with nvidia/groupvit-gcc-yfcc style configuration
>>> configuration = GroupViTVisionConfig()

>>> model = GroupViTVisionModel(configuration)

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

PytorchHide Pytorch content

GroupViTModel

class transformers.GroupViTModel

< source >

( config: GroupViTConfig )

参数

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

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

forward

<来源>

( input_ids: Optional = None pixel_values: Optional = None attention_mask: Optional = None position_ids: Optional = None return_loss: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None output_segmentation: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.groupvit.modeling_groupvit.GroupViTModelOutput or tuple(torch.FloatTensor)

参数

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

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

  什么是输入 ID？

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

  • 1 代表未被掩盖的标记，

  • 0 代表被掩盖的标记。

  什么是注意力掩码？

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

  什么是位置 ID？

• pixel_values (torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参见 CLIPImageProcessor.call()。

• return_loss (bool，optional) — 是否返回对比损失。

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

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

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

返回

transformers.models.groupvit.modeling_groupvit.GroupViTModelOutput 或 tuple(torch.FloatTensor)

一个transformers.models.groupvit.modeling_groupvit.GroupViTModelOutput或一个torch.FloatTensor元组（如果传递了return_dict=False或config.return_dict=False）包含根据配置(<class 'transformers.models.groupvit.configuration_groupvit.GroupViTConfig'>)和输入的各种元素。

• loss (torch.FloatTensor，形状为(1,)，optional，当return_loss为True时返回） — 图像-文本相似性的对比损失。

• logits_per_image (torch.FloatTensor，形状为(image_batch_size, text_batch_size)) — image_embeds和text_embeds之间的缩放点积分数。这代表图像-文本相似性分数。

• logits_per_text (torch.FloatTensor of shape (text_batch_size, image_batch_size)) — text_embeds 和 image_embeds 之间的缩放点积分数。这代表文本-图像相似性分数。

• segmentation_logits (torch.FloatTensor of shape (batch_size, config.num_labels, logits_height, logits_width)) — 每个像素的分类分数。

  返回的对数不一定与传入的 pixel_values 具有相同的大小。这是为了避免进行两次插值并在用户需要将对数调整为原始图像大小时丢失一些质量。您应该始终检查您的对数形状并根据需要调整大小。

• text_embeds (torch.FloatTensor of shape (batch_size, output_dim) — 通过将 GroupViTTextModel 的池化输出应用到投影层获得的文本嵌入。

• image_embeds (torch.FloatTensor of shape (batch_size, output_dim) — 通过将 GroupViTVisionModel 的池化输出应用到投影层获得的图像嵌入。

• text_model_output (BaseModelOutputWithPooling) — GroupViTTextModel 的输出。

• vision_model_output (BaseModelOutputWithPooling) — GroupViTVisionModel 的输出。

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

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

示例：

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

>>> model = GroupViTModel.from_pretrained("nvidia/groupvit-gcc-yfcc")
>>> processor = AutoProcessor.from_pretrained("nvidia/groupvit-gcc-yfcc")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> inputs = processor(
...     text=["a photo of a cat", "a photo of a dog"], images=image, return_tensors="pt", padding=True
... )

>>> outputs = model(**inputs)
>>> logits_per_image = outputs.logits_per_image  # this is the image-text similarity score
>>> probs = logits_per_image.softmax(dim=1)  # we can take the softmax to get the label probabilities

get_text_features

< source >

( input_ids: Optional = None attention_mask: Optional = None position_ids: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';text_features (torch.FloatTensor of shape (batch_size, output_dim)

参数

• input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。默认情况下将忽略填充。

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

  什么是输入 ID？

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

  • 1 代表未被掩盖的标记，

  • 0 代表被掩盖的标记。

  什么是注意力掩码？

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

  什么是位置 ID？

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

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

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

返回

text_features (torch.FloatTensor，形状为(batch_size, output_dim))

通过将投影层应用于 GroupViTTextModel 的池化输出获得的文本嵌入。

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

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

示例：

>>> from transformers import CLIPTokenizer, GroupViTModel

>>> model = GroupViTModel.from_pretrained("nvidia/groupvit-gcc-yfcc")
>>> tokenizer = CLIPTokenizer.from_pretrained("nvidia/groupvit-gcc-yfcc")

>>> inputs = tokenizer(["a photo of a cat", "a photo of a dog"], padding=True, return_tensors="pt")
>>> text_features = model.get_text_features(**inputs)

get_image_features

<来源>

( pixel_values: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';image_features (torch.FloatTensor of shape (batch_size, output_dim)

参数

• pixel_values (torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 像素值。默认情况下会忽略填充。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 CLIPImageProcessor.call()。

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

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

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

返回

image_features (torch.FloatTensor，形状为(batch_size, output_dim))

通过将投影层应用于 GroupViTVisionModel 的池化输出获得的图像嵌入。

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

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

示例：

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

>>> model = GroupViTModel.from_pretrained("nvidia/groupvit-gcc-yfcc")
>>> processor = AutoProcessor.from_pretrained("nvidia/groupvit-gcc-yfcc")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

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

>>> image_features = model.get_image_features(**inputs)

GroupViTTextModel

class transformers.GroupViTTextModel

<来源>

( config: GroupViTTextConfig )

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None position_ids: 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，形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。默认情况下会忽略填充。

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

  什么是输入 ID？

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

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

  • 对于被masked的标记，值为 0。

  什么是注意力掩码？

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

  什么是位置 ID？

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

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

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

返回

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

一个 transformers.modeling_outputs.BaseModelOutputWithPooling 或一个torch.FloatTensor元组（如果传递了return_dict=False或当config.return_dict=False时），包括根据配置（<class 'transformers.models.groupvit.configuration_groupvit.GroupViTTextConfig'>）和输入的不同元素。

• 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)，optional，当传递output_hidden_states=True或当config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入的输出+每层的输出）。

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

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

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

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

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

示例：

>>> from transformers import CLIPTokenizer, GroupViTTextModel

>>> tokenizer = CLIPTokenizer.from_pretrained("nvidia/groupvit-gcc-yfcc")
>>> model = GroupViTTextModel.from_pretrained("nvidia/groupvit-gcc-yfcc")

>>> inputs = tokenizer(["a photo of a cat", "a photo of a dog"], padding=True, return_tensors="pt")

>>> outputs = model(**inputs)
>>> last_hidden_state = outputs.last_hidden_state
>>> pooled_output = outputs.pooler_output  # pooled (EOS token) states

GroupViTVisionModel

class transformers.GroupViTVisionModel

<来源>

( config: GroupViTVisionConfig )

forward

<来源>

( pixel_values: 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)

参数

• pixel_values（形状为(batch_size, num_channels, height, width)的torch.FloatTensor）- 像素值。默认情况下会忽略填充。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 CLIPImageProcessor.call()。

• 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时）包含根据配置（<class 'transformers.models.groupvit.configuration_groupvit.GroupViTVisionConfig'>）和输入的不同元素。

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

• pooler_output（形状为(batch_size, hidden_size)的torch.FloatTensor）- 序列的第一个标记（分类标记）的最后一层隐藏状态，在通过用于辅助预训练任务的层进一步处理后。例如，对于 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 之后，用于计算自注意力头中的加权平均值。

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

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

示例：

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

>>> processor = AutoProcessor.from_pretrained("nvidia/groupvit-gcc-yfcc")
>>> model = GroupViTVisionModel.from_pretrained("nvidia/groupvit-gcc-yfcc")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

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

>>> outputs = model(**inputs)
>>> last_hidden_state = outputs.last_hidden_state
>>> pooled_output = outputs.pooler_output  # pooled CLS states

TensorFlowHide TensorFlow 内容

TFGroupViTModel

class transformers.TFGroupViTModel

<来源>

( config: GroupViTConfig *inputs **kwargs )

参数

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

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

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

TF 2.0 模型接受两种格式的输入：

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

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

这第二个选项在使用tf.keras.Model.fit方法时很有用，该方法目前要求在模型调用函数的第一个参数中具有所有张量：model(inputs)。

如果选择第二个选项，则有三种可能性可用于收集第一个位置参数中的所有输入张量：

• 一个仅包含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})

call

<来源>

( input_ids: TFModelInputType | None = None pixel_values: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None return_loss: Optional[bool] = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None output_segmentation: Optional[bool] = None return_dict: Optional[bool] = None training: bool = False ) → export const metadata = 'undefined';transformers.models.groupvit.modeling_tf_groupvit.TFGroupViTModelOutput or tuple(tf.Tensor)

参数

• input_ids（np.ndarray，tf.Tensor，List[tf.Tensor] ``Dict[str, tf.Tensor]或Dict[str, np.ndarray]，每个示例的形状必须为(batch_size, sequence_length)`）-词汇表中输入序列标记的索引。

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

  什么是输入 ID？

• pixel_values（形状为(batch_size, num_channels, height, width)的np.ndarray，tf.Tensor，List[tf.Tensor] Dict[str, tf.Tensor]或Dict[str, np.ndarray]，每个示例的形状必须为）-像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息，请参阅 CLIPImageProcessor.call()。

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

  • 对于未被屏蔽的标记为 1，

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

  什么是注意力掩码？

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

  什么是位置 ID？

• return_loss（bool，可选）-是否返回对比损失。

• output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的 attentions。此参数仅在急切模式下使用，在图模式下将使用配置中的值。

• output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的 hidden_states。此参数仅在急切模式下使用，在图模式下将使用配置中的值。

• return_dict (bool，可选) — 是否返回一个 ModelOutput 而不是一个普通元组。此参数可在急切模式下使用，在图模式下该值将始终设置为 True。

• training (bool，可选，默认为 `False“) — 是否在训练模式下使用模型（一些模块如 dropout 模块在训练和评估之间有不同的行为）。

返回

transformers.models.groupvit.modeling_tf_groupvit.TFGroupViTModelOutput 或者 tuple(tf.Tensor)

transformers.models.groupvit.modeling_tf_groupvit.TFGroupViTModelOutput 或者一个 tf.Tensor 元组（如果传入 return_dict=False 或者 config.return_dict=False）包含不同元素，取决于配置（<class 'transformers.models.groupvit.configuration_groupvit.GroupViTConfig'>）和输入。

• loss (tf.Tensor，形状为 (1,)，可选，当 return_loss 为 True 时返回） — 图像-文本相似性的对比损失。

• logits_per_image (tf.Tensor，形状为 (image_batch_size, text_batch_size)) — image_embeds 和 text_embeds 之间的缩放点积分数。这代表了图像-文本相似性分数。

• logits_per_text (tf.Tensor，形状为 (text_batch_size, image_batch_size)) — text_embeds 和 image_embeds 之间的缩放点积分数。这代表了文本-图像相似性分数。

• segmentation_logits (tf.Tensor，形状为 (batch_size, config.num_labels, logits_height, logits_width)) — 每个像素的分类分数。

  返回的对数不一定与作为输入传递的 pixel_values 大小相同。这是为了避免进行两次插值并在用户需要将对数调整为原始图像大小时丢失一些质量。您应该始终检查您的对数形状并根据需要调整大小。

• text_embeds (tf.Tensor，形状为 (batch_size, output_dim) — 通过将投影层应用于 TFGroupViTTextModel 的汇聚输出获得的文本嵌入。

• image_embeds (tf.Tensor，形状为 (batch_size, output_dim) — 通过将投影层应用于 TFGroupViTVisionModel 的汇聚输出获得的图像嵌入。

• text_model_output (TFBaseModelOutputWithPooling) — TFGroupViTTextModel 的输出。

• vision_model_output (TFBaseModelOutputWithPooling) — TFGroupViTVisionModel 的输出。

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

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

示例：

>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, TFGroupViTModel
>>> import tensorflow as tf

>>> model = TFGroupViTModel.from_pretrained("nvidia/groupvit-gcc-yfcc")
>>> processor = AutoProcessor.from_pretrained("nvidia/groupvit-gcc-yfcc")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> inputs = processor(
...     text=["a photo of a cat", "a photo of a dog"], images=image, return_tensors="tf", padding=True
... )

>>> outputs = model(**inputs)
>>> logits_per_image = outputs.logits_per_image  # this is the image-text similarity score
>>> probs = tf.math.softmax(logits_per_image, axis=1)  # we can take the softmax to get the label probabilities

get_text_features

< source >

( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None position_ids: 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';text_features (tf.Tensor of shape (batch_size, output_dim)

参数

• input_ids（np.ndarray、tf.Tensor、List[tf.Tensor]、Dict[str, tf.Tensor]或Dict[str, np.ndarray]，每个示例的形状必须为(batch_size, sequence_length)）— 词汇表中输入序列标记的索引。

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

  输入 ID 是什么？

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

  • 1 表示未被masked的标记，

  • 0 表示被masked的标记。

  注意力掩码是什么？

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

  位置 ID 是什么？

• output_attentions（可选，bool）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的attentions。此参数仅在急切模式下使用，在图模式下将使用配置中的值。

• output_hidden_states（可选，bool）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。此参数仅在急切模式下使用，在图模式下将使用配置中的值。

• return_dict（可选，bool）— 是否返回 ModelOutput 而不是普通元组。此参数可以在急切模式下使用，在图模式下该值将始终设置为 True。

• training（可选，默认为False）— 是否在训练模式下使用模型（一些模块如 dropout 模块在训练和评估之间有不同的行为）。

返回

text_features（形状为(batch_size, output_dim)的tf.Tensor）

通过将投影层应用于 TFGroupViTTextModel 的汇聚输出获得的文本嵌入。

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

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

示例：

>>> from transformers import CLIPTokenizer, TFGroupViTModel

>>> model = TFGroupViTModel.from_pretrained("nvidia/groupvit-gcc-yfcc")
>>> tokenizer = CLIPTokenizer.from_pretrained("nvidia/groupvit-gcc-yfcc")

>>> inputs = tokenizer(["a photo of a cat", "a photo of a dog"], padding=True, return_tensors="tf")
>>> text_features = model.get_text_features(**inputs)

get_image_features

<来源>

( pixel_values: TFModelInputType | 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';image_features (tf.Tensor of shape (batch_size, output_dim)

参数

• pixel_values（np.ndarray、tf.Tensor、List[tf.Tensor]、Dict[str, tf.Tensor]或Dict[str, np.ndarray]，每个示例的形状必须为(batch_size, num_channels, height, width)）— 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 CLIPImageProcessor.call()。

• output_attentions（可选，bool）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的attentions。此参数仅在急切模式下使用，在图模式下将使用配置中的值。

• output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的 hidden_states。此参数仅在急切模式下使用，在图模式下将使用配置中的值。

• return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。此参数可在急切模式下使用，在图模式下该值将始终设置为 True。

• training (bool, 可选，默认为 `False“) — 是否在训练模式下使用模型（一些模块如 dropout 模块在训练和评估之间有不同的行为）。

返回值

image_features (tf.Tensor，形状为 (batch_size, output_dim)

通过将投影层应用于 TFGroupViTVisionModel 的汇聚输出获得的图像嵌入。

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

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

示例:

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

>>> model = TFGroupViTModel.from_pretrained("nvidia/groupvit-gcc-yfcc")
>>> processor = AutoProcessor.from_pretrained("nvidia/groupvit-gcc-yfcc")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> inputs = processor(images=image, return_tensors="tf")

>>> image_features = model.get_image_features(**inputs)

TFGroupViTTextModel

class transformers.TFGroupViTTextModel

< source >

( config: GroupViTTextConfig *inputs **kwargs )

call

< source >

( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None position_ids: 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.modeling_tf_outputs.TFBaseModelOutputWithPooling or tuple(tf.Tensor)

参数

• input_ids (np.ndarray, tf.Tensor, List[tf.Tensor] ``Dict[str, tf.Tensor]或Dict[str, np.ndarray]，每个示例的形状必须为 (batch_size, sequence_length)`) — 词汇表中输入序列标记的索引。

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

  什么是输入 ID？

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

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

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

  什么是注意力掩码？

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

  什么是位置 ID？

• output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的 attentions。此参数仅在急切模式下使用，在图模式下将使用配置中的值。

• output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的 hidden_states。此参数仅在急切模式下使用，在图模式下将使用配置中的值。

• return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。此参数可在急切模式下使用，在图模式下该值将始终设置为 True。

• training（bool，可选，默认为False）— 是否在训练模式下使用模型（一些模块如 dropout 模块在训练和评估之间有不同的行为）。

返回

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

一个 transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling 或一个tf.Tensor元组（如果传递了return_dict=False或config.return_dict=False时）包含根据配置（<class 'transformers.models.groupvit.configuration_groupvit.GroupViTTextConfig'>）和输入的不同元素。

• last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的tf.Tensor）— 模型最后一层的隐藏状态序列。

• pooler_output（形状为(batch_size, hidden_size)的tf.Tensor）— 序列的第一个令牌（分类令牌）的最后一层隐藏状态，进一步由线性层和 Tanh 激活函数处理。线性层的权重是在预训练期间从下一个句子预测（分类）目标中训练的。

  这个输出通常不是输入的语义内容的好摘要，通常最好对整个输入序列的隐藏状态进行平均或池化。

• 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 之后的注意力权重，用于计算自注意力头中的加权平均值。

TFGroupViTTextModel 的 forward 方法，覆盖了__call__特殊方法。

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

示例：

>>> from transformers import CLIPTokenizer, TFGroupViTTextModel

>>> tokenizer = CLIPTokenizer.from_pretrained("nvidia/groupvit-gcc-yfcc")
>>> model = TFGroupViTTextModel.from_pretrained("nvidia/groupvit-gcc-yfcc")

>>> inputs = tokenizer(["a photo of a cat", "a photo of a dog"], padding=True, return_tensors="tf")

>>> outputs = model(**inputs)
>>> last_hidden_state = outputs.last_hidden_state
>>> pooled_output = outputs.pooler_output  # pooled (EOS token) states

TFGroupViTVisionModel

class transformers.TFGroupViTVisionModel

<来源>

( config: GroupViTVisionConfig *inputs **kwargs )

call

<来源>

( pixel_values: TFModelInputType | 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.TFBaseModelOutputWithPooling or tuple(tf.Tensor)

参数

• pixel_values（np.ndarray，tf.Tensor，List[tf.Tensor]，Dict[str, tf.Tensor]或Dict[str, np.ndarray]，每个示例必须具有形状(batch_size, num_channels, height, width)）— 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息，请参见 CLIPImageProcessor.call()。

• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。此参数只能在急切模式下使用，在图模式下将使用配置中的值。

• output_hidden_states（bool，可选）- 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。此参数仅在急切模式下使用，在图模式中将使用配置中的值。

• return_dict（bool，可选）- 是否返回一个 ModelOutput 而不是一个普通元组。此参数可以在急切模式下使用，在图模式中该值将始终设置为 True。

• training（bool，可选，默认为False）- 是否在训练模式下使用模型（一些模块如 dropout 模块在训练和评估之间有不同的行为）。

返回

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

transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling 或一个tf.Tensor元组（如果传递了return_dict=False或config.return_dict=False时）包含根据配置（<class 'transformers.models.groupvit.configuration_groupvit.GroupViTVisionConfig'>）和输入的不同元素。

• last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的tf.Tensor）- 模型最后一层的隐藏状态序列。

• pooler_output（形状为(batch_size, hidden_size)的tf.Tensor）- 序列第一个标记（分类标记）的最后一层隐藏状态，经过线性层和 Tanh 激活函数进一步处理。线性层的权重是在预训练期间从下一个句子预测（分类）目标中训练的。

  这个输出通常不是输入语义内容的好摘要，通常最好对整个输入序列的隐藏状态序列进行平均或池化。

• 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 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

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

>>> processor = AutoProcessor.from_pretrained("nvidia/groupvit-gcc-yfcc")
>>> model = TFGroupViTVisionModel.from_pretrained("nvidia/groupvit-gcc-yfcc")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> inputs = processor(images=image, return_tensors="tf")

>>> outputs = model(**inputs)
>>> last_hidden_state = outputs.last_hidden_state
>>> pooled_output = outputs.pooler_output  # pooled CLS states

IDEFICS

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

概述

IDEFICS 模型是由 Hugo Laurençon、Lucile Saulnier、Léo Tronchon、Stas Bekman、Amanpreet Singh、Anton Lozhkov、Thomas Wang、Siddharth Karamcheti、Alexander M. Rush、Douwe Kiela、Matthieu Cord、Victor Sanh 提出的。

论文摘要如下：

在自然文档上训练的大型多模型，交替显示图像和文本，比在各种多模基准上训练的图像-文本对模型表现更好，这些基准需要对一个或多个图像进行推理以生成文本。然而，用于训练这些模型的数据集尚未发布，并且收集过程尚未完全指定。我们介绍了 OBELICS 数据集，这是一个包含来自 Common Crawl 的 141 亿个网页、3.53 亿个相关图像和 1150 亿个文本标记的开放式网络规模过滤数据集。我们描述了数据集创建过程，提出了全面的过滤规则，并对数据集内容进行了分析。为了展示 OBELISC 的可行性，我们在数据集上训练了一个拥有 800 亿参数的视觉和语言模型，并在各种多模基准上获得了竞争性能。我们发布了用于重现数据集的代码以及数据集本身。

此模型由HuggingFaceM4贡献。原始代码可以在这里找到。（TODO：目前没有公开链接）。

Transformers 中的 IDEFICS 建模代码用于微调和推理预训练的 IDEFICS 模型。

要从头开始训练一个新的 IDEFICS 模型，请使用 m4 代码库（一旦公开，将提供链接）

IdeficsConfig

class transformers.IdeficsConfig

<来源>

( vocab_size = 32000 additional_vocab_size = 0 hidden_size = 4096 intermediate_size = 11008 num_hidden_layers = 32 num_attention_heads = 32 dropout = 0.0 hidden_act = 'silu' initializer_range = 0.02 alpha_initializer = 'zeros' alphas_initializer_range = 0.0 alpha_type = 'float' rms_norm_eps = 1e-06 use_cache = True pad_token_id = 0 bos_token_id = 1 eos_token_id = 2 tie_word_embeddings = False cross_layer_interval = 1 qk_layer_norms = False freeze_text_layers = True freeze_text_module_exceptions = [] freeze_lm_head = False freeze_vision_layers = True freeze_vision_module_exceptions = [] use_resampler = False vision_config = None perceiver_config = None **kwargs )

参数

• additional_vocab_size (int, *optional`, defaults to 0) — 模型的额外词汇量，通常用于特殊的“”标记。额外的词汇标记始终是可训练的，而常规词汇标记可以冻结或不冻结。

• vocab_size (int, optional, defaults to 32000) — Idefics 模型的词汇量。定义了在调用~IdeficsModel 时可以表示的不同标记的数量。

• hidden_size (int, optional, defaults to 4096) — 隐藏表示的维度。

• intermediate_size (int, optional, defaults to 11008) — MLP 表示的维度。

• num_hidden_layers (int, optional, defaults to 32) — Transformer 编码器中隐藏层的数量。

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

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

• hidden_act (str or function, optional, defaults to "silu") — 解码器中的非线性激活函数（函数或字符串）。

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

• alpha_initializer (str, optional, defaults to "zeros") — alphas 的初始化类型。

• alphas_initializer_range (float, optional, defaults to 0.0) — 初始化 Gated Cross Attention 中 alphas 的 truncated_normal_initializer 的标准差。

• alpha_type (str, optional, defaults to "float") — 门控 alphas 应该是向量还是单个浮点数。

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

• use_cache (bool, optional, defaults to True) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）。仅在config.is_decoder=True时相关。

• pad_token_id (int, optional, defaults to 0) — 填充标记 id。

• bos_token_id (int, optional, defaults to 1) — 流的开始标记 id。

• eos_token_id (int, optional, defaults to 2) — 流的结束标记 id。

• tie_word_embeddings(bool, optional, defaults to False) — 是否绑定权重嵌入

• cross_layer_interval (int, optional, default to 1) — 交叉注意力（从文本到图像）层的间隔。

• qk_layer_norms (bool, optional, defaults to False) — 是否在 q 和 k 之后添加层归一化

• freeze_text_layers (bool, optional, defaults to True) — 是否冻结文本层

• freeze_text_module_exceptions (bool, optional, defaults to []) — 当freeze_text_layers为True时，冻结文本层的异常

• freeze_lm_head (bool, optional, defaults to False) — 是否冻结 lm 头

• freeze_vision_layers (bool, optional, defaults to True) — 是否冻结视觉层

• freeze_vision_module_exceptions (bool, optional, defaults to []) — 当freeze_vision_layers为True时，冻结视觉层的异常

• use_resampler (bool, optional, defaults to False) — 是否使用重采样器

• vision_config (IdeficsVisionConfig, optional) — 自定义视觉配置或字典

• perceiver_config (IdeficsPerceiverConfig, optional) — 自定义感知器配置或字典

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

例如HuggingFaceM4/idefics-9b

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

示例：

>>> from transformers import IdeficsModel, IdeficsConfig

>>> # Initializing a Idefics idefics-9b style configuration
>>> configuration = IdeficsConfig()

>>> # Initializing a model from the idefics-9b style configuration
>>> model = IdeficsModel(configuration)

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

IdeficsModel

class transformers.IdeficsModel

< source >

( config: IdeficsConfig )

参数

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

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

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

由config.num_hidden_layers层组成的 Transformer 解码器。每一层都是一个IdeficsDecoderLayer

forward

<来源>

( input_ids: LongTensor = None attention_mask: Optional = None position_ids: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None pixel_values: Optional = None image_encoder_embeddings: Optional = None perceiver_embeddings: Optional = None image_attention_mask: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None interpolate_pos_encoding: Optional = False return_dict: Optional = None )

参数

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

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

  什么是输入 ID？

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

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

  • 对于被masked的标记，为 0。

  什么是注意力掩码？

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

  如果使用past_key_values，可以选择仅输入最后的decoder_input_ids（请参阅past_key_values）。

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

  • 1 表示头部未被masked，

  • 0 表示头部被masked。

• position_ids（torch.LongTensor，形状为(batch_size, sequence_length)，可选）— 每个输入序列标记在位置嵌入中的位置索引。在范围[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，用户可以选择仅输入形状为(batch_size, 1)的最后一个decoder_input_ids（那些没有将它们的过去键值状态提供给此模型的）而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。

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

• use_cache（bool，可选）— 如果设置为True，将返回past_key_values键值状态，并可用于加速解码（请参阅past_key_values）。

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

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

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

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

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

IdeficsForVisionText2Text

class transformers.IdeficsForVisionText2Text

<来源>

( config vision_model = None )

forward

<来源>

( input_ids: LongTensor = None attention_mask: Optional = None position_ids: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None pixel_values: Optional = None image_encoder_embeddings: Optional = None perceiver_embeddings: Optional = None image_attention_mask: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None interpolate_pos_encoding: Optional = False return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.idefics.modeling_idefics.IdeficsCausalLMOutputWithPast or tuple(torch.FloatTensor)

参数

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

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

  什么是输入 ID？

• attention_mask（torch.Tensor，形状为(batch_size, sequence_length)，可选）— 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在[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（torch.LongTensor，形状为(batch_size, sequence_length)，可选）— 每个输入序列标记在位置嵌入中的位置索引。选择范围为[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 of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，您可以选择直接传递嵌入表示，而不是传递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, optional) — 是否返回一个 ModelOutput 而不是一个普通的元组。

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

返回值

transformers.models.idefics.modeling_idefics.IdeficsCausalLMOutputWithPast或tuple(torch.FloatTensor)

一个transformers.models.idefics.modeling_idefics.IdeficsCausalLMOutputWithPast或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False），包含根据配置（IdeficsConfig）和输入的不同元素。

• loss (torch.FloatTensor of shape (1,), optional, 当提供labels时返回) — 语言建模损失（用于下一个标记预测）。

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

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

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

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

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

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

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

• image_hidden_states (tuple(torch.FloatTensor), optional) — 一个元组，包含形状为(batch_size, num_images, sequence_length, hidden_size)的torch.FloatTensor（用于图像嵌入的输出）。

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

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

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

示例:

>>> from transformers import AutoTokenizer, IdeficsForVisionText2Text

>>> model = IdeficsForVisionText2Text.from_pretrained("HuggingFaceM4/idefics-9b")
>>> tokenizer = AutoTokenizer.from_pretrained("HuggingFaceM4/idefics-9b")

>>> prompt = "Hey, are you consciours? Can you talk to me?"
>>> inputs = tokenizer(prompt, return_tensors="pt")

>>> # Generate
>>> generate_ids = model.generate(inputs.input_ids, max_length=30)
>>> tokenizer.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
"Hey, are you consciours? Can you talk to me?\nI'm not consciours, but I can talk to you."

IdeficsImageProcessor

class transformers.IdeficsImageProcessor

<来源>

( image_size: int = 224 image_mean: Union = None image_std: Union = None image_num_channels: Optional = 3 **kwargs )

参数

• image_size (int, 可选, 默认为 224) — 调整到图像大小

• image_mean (float 或 List[float], 可选, 默认为 IDEFICS_STANDARD_MEAN) — 用于归一化图像的均值。这是一个浮点数或与图像中通道数相同长度的浮点数列表。可以通过preprocess方法中的image_mean参数覆盖。可以通过preprocess方法中的image_mean参数覆盖。

• image_std (float 或 List[float], 可选, 默认为 IDEFICS_STANDARD_STD) — 用于归一化图像的标准差。这是一个浮点数或与图像中通道数相同长度的浮点数列表。可以通过preprocess方法中的image_std参数覆盖。可以通过preprocess方法中的image_std参数覆盖。

• image_num_channels (int, 可选, 默认为 3) — 图像通道数。

构建一个 Idefics 图像处理器。

preprocess

<来源>

( images: Union image_num_channels: Optional = 3 image_size: Optional = None image_mean: Union = None image_std: Union = None transform: Callable = None **kwargs )

参数

• images (ImageInput) — 要预处理的图像列表。

• image_size (int, 可选, 默认为 self.image_size) — 调整到图像大小

• image_num_channels (int, 可选, 默认为 self.image_num_channels) — 图像通道数。

• image_mean (float 或 List[float], 可选, 默认为 IDEFICS_STANDARD_MEAN) — 用于归一化图像的均值。这是一个浮点数或与图像中通道数相同长度的浮点数列表。可以通过preprocess方法中的image_mean参数覆盖。可以通过preprocess方法中的image_mean参数覆盖。

• image_std (float 或 List[float], 可选, 默认为 IDEFICS_STANDARD_STD) — 用于归一化图像的标准差。这是一个浮点数或与图像中通道数相同长度的浮点数列表。可以通过preprocess方法中的image_std参数覆盖。可以通过preprocess方法中的image_std参数覆盖。

• transform (Callable, 可选, 默认为 None) — 可以传递一个接受单个图像的自定义转换函数进行训练。例如，可以使用torchvision.Compose来组合多个转换。如果为None - 则假定为推断模式 - 然后将应用一组预设的推断特定转换到图像。

预处理一批图像。

IdeficsProcessor

class transformers.IdeficsProcessor

<来源>

( image_processor tokenizer = None image_size = 224 add_end_of_utterance_token = None **kwargs )

参数

• image_processor (IdeficsImageProcessor) — IdeficsImageProcessor 的一个实例。图像处理器是一个必需的输入。

• tokenizer (LlamaTokenizerFast) — LlamaTokenizerFast 的一个实例。分词器是一个必需的输入。

• image_size (int, 可选, 默认为 224) — 图像大小（假设为正方形图像）

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

IdeficsProcessor 提供了 IdeficsImageProcessor 和 LlamaTokenizerFast 的所有功能。查看 call() 和 decode() 的文档字符串以获取更多信息。

__call__

< source >

( prompts: Union padding: Union = False truncation: Union = None max_length: Optional = None transform: Callable = None add_eos_token = False add_end_of_utterance_token = None debug = False return_tensors: Union = <TensorType.PYTORCH: 'pt'> ) → export const metadata = 'undefined';a dict with entries

参数

• prompts（Union[List[TextInput], [List[List[TextInput]]]]）— 单个提示或批处理提示的列表 - 请查看参数文档部分结束后的详细描述。

• padding（bool，str 或 PaddingStrategy，可选，默认为 False）— 选择一种策略来填充返回的序列（根据模型的填充方向和填充索引）：

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

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

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

• max_length（int，可选）— 返回列表的最大长度和可选填充长度（见上文）。

• truncation（bool，可选）— 激活截断，将输入序列截断为比 max_length 更长的序列至 max_length。

• transform（Callable，可选）— 可以传递一个接受单个图像的自定义转换函数进行训练。例如，可以使用 torchvision.Compose 来组合多个函数。如果为 None，则将应用预设的推理特定转换集合到图像上。

• add_eos_token（bool，可选，默认为 False）— 如果为 True，则在最终提示的末尾添加 eos_token

• add_end_of_utterance_token（bool，可选）— 是否在每个提示的文本输入后自动添加 <end_of_utterance>（除非后面跟着一个图像）。如果为 None，则将检查分词器，如果在 additional_special_tokens 中找到该标记，则值将为 True。

• debug（bool，可选，默认为 False）— True 值将通过转储有用信息来帮助调试提示生成

• return_tensors（str 或 TensorType，可选，默认为 TensorType.PYTORCH）— 要返回的张量类型。可以是以下之一：

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

返回

一个包含条目的字典

input_ids、attention_mask、pixel_values、image_attention_mask 可以直接传递给 model.generate

这个方法接受由文本和图像组成的批处理或非批处理提示，并将它们转换为模型训练的提示，并准备图像像素值供模型处理。

详细说明：

prompts 中的每个条目都是要原样传递的文本或将被处理的图像。

图像可以是图像对象（PIL.Image）或可以检索图像的 url。

当处理器遇到图像时，它将在提示中注入 <fake_token_around_image><image><fake_token_around_image> 条目。

例子：

checkpoint = "HuggingFaceM4/idefics-9b"
processor = AutoProcessor.from_pretrained(checkpoint)
url = "https://hips.hearstapps.com/hmg-prod/images/cute-photos-of-cats-in-grass-1593184777.jpg"
img = processor.image_processor.fetch_images([url])[0]

prompts = [
    "User:",
    img,
    "Describe this image.
t: An image of two kittens in grass.

    "User:",
    "https://hips.hearstapps.com/hmg-prod/images/dog-puns-1581708208.jpg",
    "Describe this image.
t:",
]

inputs = processor(prompts, return_tensors="pt")
generated_ids = model.generate(**inputs, max_length=100)
generated_text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]

在这个例子中，prompts 将被转换为：

<s>User:<fake_token_around_image><image><fake_token_around_image>Describe this image.
Assistant: An image of two kittens in grass.
User:<fake_token_around_image><image><fake_token_around_image>Describe this image.
Assistant:'

两个图像将使用 IdeficsImageProcessor.call() 方法进行处理，并放置在返回值的 pixel_values 字典条目中。

这个例子还说明了图像可以作为对象或文本 url 传递。可以看到第一个图像作为对象传递，第二个图像作为 url 传递。

进行训练时：

image_transform = transforms.Compose(
    [
        transforms.RandomResizedCrop(
            (w, h), scale=(0.9, 1.0), interpolation=transforms.InterpolationMode.BICUBIC
        ),
        transforms.ToTensor(),
        transforms.Normalize(mean=self.image_mean, std=self.image_std),
    ]
)
inputs = processor(prompts, transform=image_transform, return_tensors="pt")

为了帮助调试提示生成，启用debug=True，这将向您展示发生了什么。

InstructBLIP

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

概述

InstructBLIP 模型是由 Wenliang Dai，Junnan Li，Dongxu Li，Anthony Meng Huat Tiong，Junqi Zhao，Weisheng Wang，Boyang Li，Pascale Fung，Steven Hoi 在InstructBLIP: Towards General-purpose Vision-Language Models with Instruction Tuning中提出的。InstructBLIP 利用了 BLIP-2 架构进行视觉指令调整。

论文摘要如下：

由于预训练和指令调整流程的推动，出现了可以解决各种语言领域任务的通用语言模型。然而，构建通用的视觉语言模型具有挑战性，因为额外的视觉输入引入了增加的任务差异。尽管视觉语言预训练已经得到广泛研究，但视觉语言指令调整仍然相对较少探索。在本文中，我们对基于预训练的 BLIP-2 模型的视觉语言指令调整进行了系统和全面的研究。我们收集了 26 个公开可用数据集的各种数据，将它们转换为指令调整格式，并将它们分类为两个集群，用于保留指令调整和保留零样本评估。此外，我们引入了指令感知的视觉特征提取，这是一种关键方法，使模型能够提取针对给定指令的信息特征。由此产生的 InstructBLIP 模型在所有 13 个保留数据集上实现了最先进的零样本性能，明显优于 BLIP-2 和更大的 Flamingo。我们的模型在个别下游任务（例如 ScienceQA IMG 上的 90.7%准确率）上也实现了最先进的性能。此外，我们定性地展示了 InstructBLIP 相对于同时进行的多模态模型的优势。

InstructBLIP 架构。取自原始论文。

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

使用提示

InstructBLIP 使用与 BLIP-2 相同的架构，但有一个微小但重要的区别：它还将文本提示（指令）提供给 Q-Former。

InstructBlipConfig

class transformers.InstructBlipConfig

<来源>

( vision_config = None qformer_config = None text_config = None num_query_tokens = 32 **kwargs )

参数

• vision_config（dict，可选）—用于初始化 InstructBlipVisionConfig 的配置选项字典。

• qformer_config（dict，可选）—用于初始化 InstructBlipQFormerConfig 的配置选项字典。

• text_config（dict，可选）—用于初始化任何 PretrainedConfig 的配置选项字典。

• num_query_tokens（int，可选，默认为 32）—通过 Transformer 传递的查询标记数。

• kwargs（可选）—关键字参数的字典。

InstructBlipConfig 是用于存储 InstructBlipForConditionalGeneration 配置的配置类。它用于根据指定的参数实例化一个 InstructBLIP 模型，定义视觉模型、Q-Former 模型和语言模型配置。使用默认实例化配置将产生类似于 InstructBLIP Salesforce/instruct-blip-flan-t5 架构的配置。

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

示例：

>>> from transformers import (
...     InstructBlipVisionConfig,
...     InstructBlipQFormerConfig,
...     OPTConfig,
...     InstructBlipConfig,
...     InstructBlipForConditionalGeneration,
... )

>>> # Initializing a InstructBlipConfig with Salesforce/instruct-blip-flan-t5 style configuration
>>> configuration = InstructBlipConfig()

>>> # Initializing a InstructBlipForConditionalGeneration (with random weights) from the Salesforce/instruct-blip-flan-t5 style configuration
>>> model = InstructBlipForConditionalGeneration(configuration)

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

>>> # We can also initialize a InstructBlipConfig from a InstructBlipVisionConfig, InstructBlipQFormerConfig and any PretrainedConfig

>>> # Initializing InstructBLIP vision, InstructBLIP Q-Former and language model configurations
>>> vision_config = InstructBlipVisionConfig()
>>> qformer_config = InstructBlipQFormerConfig()
>>> text_config = OPTConfig()

>>> config = InstructBlipConfig.from_text_vision_configs(vision_config, qformer_config, text_config)

from_vision_qformer_text_configs

< source >

( vision_config: InstructBlipVisionConfig qformer_config: InstructBlipQFormerConfig text_config: PretrainedConfig **kwargs ) → export const metadata = 'undefined';InstructBlipConfig

返回

InstructBlipConfig

配置对象的实例

从 InstructBLIP 视觉模型、Q-Former 和语言模型配置实例化一个 InstructBlipConfig（或派生类）。

InstructBlipVisionConfig

class transformers.InstructBlipVisionConfig

< source >

( hidden_size = 1408 intermediate_size = 6144 num_hidden_layers = 39 num_attention_heads = 16 image_size = 224 patch_size = 14 hidden_act = 'gelu' layer_norm_eps = 1e-06 attention_dropout = 0.0 initializer_range = 1e-10 qkv_bias = True **kwargs )

参数

• hidden_size (int, 可选，默认为 1408) — 编码器层和池化层的维度。

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

• num_hidden_layers (int, 可选，默认为 39) — Transformer 编码器中的隐藏层数量。

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

• image_size (int, 可选，默认为 224) — 每个图像的大小（分辨率）。

• patch_size (int, 可选，默认为 14) — 每个补丁的大小（分辨率）。

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

• layer_norm_eps (float, 可选，默认为 1e-06) — 层归一化层使用的 epsilon。

• attention_dropout (float, 可选，默认为 0.0) — 注意力概率的 dropout 比率。

• initializer_range (float, 可选，默认为 1e-10) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。

• qkv_bias (bool, 可选，默认为True) — 是否在自注意力层中为查询和值添加偏置。

这是用于存储 InstructBlipVisionModel 配置的配置类。它用于根据指定的参数实例化一个 InstructBLIP 视觉编码器，定义模型架构。使用默认实例化配置将产生类似于 InstructBLIP Salesforce/instruct-blip-flan-t5 架构的配置。

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

示例：

>>> from transformers import InstructBlipVisionConfig, InstructBlipVisionModel

>>> # Initializing a InstructBlipVisionConfig with Salesforce/instruct-blip-flan-t5 style configuration
>>> configuration = InstructBlipVisionConfig()

>>> # Initializing a InstructBlipVisionModel (with random weights) from the Salesforce/instruct-blip-flan-t5 style configuration
>>> model = InstructBlipVisionModel(configuration)

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

InstructBlipQFormerConfig

class transformers.InstructBlipQFormerConfig

<来源>

( 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 initializer_range = 0.02 layer_norm_eps = 1e-12 pad_token_id = 0 position_embedding_type = 'absolute' cross_attention_frequency = 2 encoder_hidden_size = 1408 **kwargs )

参数

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

• 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或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）。

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

• cross_attention_frequency (int, optional, 默认为 2) — 向 Transformer 层添加交叉注意力的频率。

• encoder_hidden_size (int, optional, 默认为 1408) — 用于交叉注意力的隐藏状态的隐藏大小。

这是一个配置类，用于存储 InstructBlipQFormerModel 的配置。它用于根据指定的参数实例化一个 InstructBLIP Querying Transformer (Q-Former)模型，定义模型架构。使用默认值实例化配置将产生类似于 InstructBLIP Salesforce/instruct-blip-flan-t5架构的配置。配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。

请注意，InstructBlipQFormerModel 与 BertLMHeadModel 非常相似，具有交错的交叉注意力。

示例：

>>> from transformers import InstructBlipQFormerConfig, InstructBlipQFormerModel

>>> # Initializing a InstructBLIP Salesforce/instruct-blip-flan-t5 style configuration
>>> configuration = InstructBlipQFormerConfig()

>>> # Initializing a model (with random weights) from the Salesforce/instruct-blip-flan-t5 style configuration
>>> model = InstructBlipQFormerModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config

InstructBlipProcessor

class transformers.InstructBlipProcessor

< source >

( image_processor tokenizer qformer_tokenizer )

参数

• image_processor (BlipImageProcessor) — BlipImageProcessor 的一个实例。图像处理器是必需的输入。

• tokenizer (AutoTokenizer) — [‘PreTrainedTokenizer`]的一个实例。分词器是必需的输入。

• qformer_tokenizer (AutoTokenizer) — [‘PreTrainedTokenizer`]的一个实例。Q-Former tokenizer 是必需的输入。

构建一个 InstructBLIP 处理器，将 BLIP 图像处理器和 LLaMa/T5 分词器包装成一个单一处理器。

InstructBlipProcessor 提供了 BlipImageProcessor 和 AutoTokenizer 的所有功能。查看__call__()和 decode()的文档字符串以获取更多信息。

batch_decode

< source >

( *args **kwargs )

此方法将其所有参数转发给 PreTrainedTokenizer 的 batch_decode()。有关更多信息，请参阅此方法的文档字符串。

decode

< source >

( *args **kwargs )

此方法将其所有参数转发给 PreTrainedTokenizer 的 decode()。有关更多信息，请参阅此方法的文档字符串。

InstructBlipVisionModel

class transformers.InstructBlipVisionModel

< source >

( config: InstructBlipVisionConfig )

forward

< source >

( pixel_values: 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)

参数

• pixel_values (torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 像素值。像素值可以使用 InstructBlipProcessor 获取。有关详细信息，请参阅InstructBlipProcessor.__call__()。

• 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时）包含各种元素，这取决于配置（<class 'transformers.models.instructblip.configuration_instructblip.InstructBlipVisionConfig'>）和输入。

• 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 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

InstructBlipQFormerModel

class transformers.InstructBlipQFormerModel

<来源>

( config: InstructBlipQFormerConfig )

查询变换器（Q-Former），用于 InstructBLIP。与 BLIP-2 略有修改，因为它还将指令作为输入。

forward

<来源>

( input_ids: LongTensor attention_mask: Optional = None position_ids: Optional = None query_embeds: Optional = None head_mask: Optional = None encoder_hidden_states: Optional = None encoder_attention_mask: Optional = None past_key_values: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None )

encoder_hidden_states（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）：编码器最后一层的隐藏状态序列。如果模型配置为解码器，则在交叉注意力中使用。encoder_attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）：避免对编码器输入的填充标记索引执行注意力的掩码。如果模型配置为解码器，则在交叉注意力中使用。选择的掩码值为[0, 1]：

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

• 对于被masked的标记，值为 0。past_key_values（长度为config.n_layers的tuple(tuple(torch.FloatTensor))，每个元组有 4 个张量，形状为(batch_size, num_heads, sequence_length - 1, embed_size_per_head)）：包含注意力块的预计算键和值隐藏状态。可用于加速解码。如果使用past_key_values，用户可以选择仅输入最后的decoder_input_ids（那些没有将其过去的键值状态提供给此模型的）的形状为(batch_size, 1)，而不是所有形状为(batch_size, sequence_length)的decoder_input_ids。use_cache（bool，可选）：如果设置为True，将返回past_key_values键值状态，并可用于加速解码（参见past_key_values）。

InstructBlipForConditionalGeneration

class transformers.InstructBlipForConditionalGeneration

<来源>

( config: InstructBlipConfig )

参数

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

InstructBLIP 模型用于根据图像和可选文本提示生成文本。该模型由视觉编码器、查询变换器（Q-Former）和语言模型组成。

可以选择向模型传递input_ids，作为文本提示，以使语言模型继续提示。否则，语言模型将从[BOS]（序列开始）标记开始生成文本。

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

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

forward

<来源>

( pixel_values: FloatTensor qformer_input_ids: FloatTensor qformer_attention_mask: Optional = None input_ids: Optional = None attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None labels: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.instructblip.modeling_instructblip.InstructBlipForConditionalGenerationModelOutput or tuple(torch.FloatTensor)

参数

• pixel_values（形状为(batch_size, num_channels, height, width)的torch.FloatTensor）—像素值。像素值可以使用 InstructBlipProcessor 获取。有关详细信息，请参阅InstructBlipProcessor.__call__()。

• qformer_input_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）—Q-Former 词汇表中输入序列标记的索引。可以选择提供输入标记作为文本提示，Q-Former 模型将对其进行编码。

  可以使用 InstructBlipProcessor 获取索引。有关详细信息，请参阅InstructBlipProcessor.__call__()。

  什么是输入 ID？

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

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

  • 对于被masked的标记为 0。

  什么是注意力掩码？

• input_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 输入序列标记在语言模型词汇中的索引。输入标记可以选择作为文本提示提供，语言模型可以继续。

  可以使用 InstructBlipProcessor 获取索引。有关详细信息，请参阅InstructBlipProcessor.__call__()。

  什么是输入 ID？

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

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

  • 对于被masked的标记为 0。

  什么是注意力掩码？

• decoder_input_ids (torch.LongTensor of shape (batch_size, target_sequence_length), optional) — 解码器输入序列标记在语言模型词汇中的索引。仅在使用编码器-解码器语言模型（如 T5）时相关。

  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。什么是解码器输入 ID？

• decoder_attention_mask (torch.BoolTensor of shape (batch_size, target_sequence_length), optional) — 默认行为：生成一个忽略decoder_input_ids中填充标记的张量。因果掩码也将默认使用。

  仅在使用编码器-解码器语言模型（如 T5）时相关。

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

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

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

• labels (torch.LongTensor of shape (batch_size,), optional) — 用于计算语言建模损失的标签。索引应在[-100, 0, ..., config.vocab_size - 1]中。所有设置为-100的标签将被忽略（被masked），损失仅计算标签在[0, ..., config.vocab_size]中的标签

返回

transformers.models.instructblip.modeling_instructblip.InstructBlipForConditionalGenerationModelOutput 或 tuple(torch.FloatTensor)

transformers.models.instructblip.modeling_instructblip.InstructBlipForConditionalGenerationModelOutput 或 torch.FloatTensor 元组（如果传递了return_dict=False或config.return_dict=False时）包含根据配置（<class 'transformers.models.instructblip.configuration_instructblip.InstructBlipVisionConfig'>）和输入的各种元素。

• loss (torch.FloatTensor, optional, 当提供labels时返回，形状为(1,)) — 语言建模损失来自语言模型。

• logits (torch.FloatTensor of shape (batch_size, sequence_length, config.vocab_size)) — 语言模型的语言建模头的预测分数。

• vision_outputs (BaseModelOutputWithPooling) — 视觉编码器的输出。

• qformer_outputs (BaseModelOutputWithPoolingAndCrossAttentions) — Q-Former（查询变换器）的输出。

• language_model_outputs (CausalLMOutputWithPast或Seq2SeqLMOutput) — 语言模型的输出。

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

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

示例：

>>> from transformers import InstructBlipProcessor, InstructBlipForConditionalGeneration
>>> import torch
>>> from PIL import Image
>>> import requests

>>> model = InstructBlipForConditionalGeneration.from_pretrained("Salesforce/instructblip-vicuna-7b")
>>> processor = InstructBlipProcessor.from_pretrained("Salesforce/instructblip-vicuna-7b")

>>> device = "cuda" if torch.cuda.is_available() else "cpu"
>>> model.to(device)
>>> url = "https://raw.githubusercontent.com/salesforce/LAVIS/main/docs/_static/Confusing-Pictures.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw).convert("RGB")
>>> prompt = "What is unusual about this image?"
>>> inputs = processor(images=image, text=prompt, return_tensors="pt").to(device)

>>> outputs = model.generate(
...     **inputs,
...     do_sample=False,
...     num_beams=5,
...     max_length=256,
...     min_length=1,
...     top_p=0.9,
...     repetition_penalty=1.5,
...     length_penalty=1.0,
...     temperature=1,
... )
>>> generated_text = processor.batch_decode(outputs, skip_special_tokens=True)[0].strip()
>>> print(generated_text)
The unusual aspect of this image is that a man is ironing clothes on the back of a yellow SUV, which is parked in the middle of a busy city street. This is an unconventional approach to ironing clothes, as it requires the man to balance himself and his ironing equipment on top of the vehicle while navigating through traffic. Additionally, the presence of taxis and other vehicles in the scene further emphasizes the unusual nature of this situation.

generate

<来源>

( pixel_values: FloatTensor qformer_input_ids: Optional = None qformer_attention_mask: Optional = None input_ids: Optional = None attention_mask: Optional = None **generate_kwargs ) → export const metadata = 'undefined';captions (list)

参数

• pixel_values (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 要处理的输入图像。

• qformer_input_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 用作输入到 Q-Former 模块的提示序列。

• qformer_attention_mask (torch.LongTensor of shape (batch_size, sequence_length), optional) — 用于避免在填充标记索引上执行注意力的掩码。

• input_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 用作生成提示的序列。

• attention_mask (torch.LongTensor of shape (batch_size, sequence_length), optional) — 用于避免在填充标记索引上执行注意力的掩码。

返回

字幕（列表）

一个长度为 batch_size * num_captions 的字符串列表。

覆盖generate函数以能够将模型用作有条件生成器。

KOSMOS-2

原始文本：huggingface.co/docs/transformers/v4.37.2/en/model_doc/kosmos-2

概述

KOSMOS-2 模型是由 Zhiliang Peng、Wenhui Wang、Li Dong、Yaru Hao、Shaohan Huang、Shuming Ma、Furu Wei 在Kosmos-2: Grounding Multimodal Large Language Models to the World中提出的。

KOSMOS-2 是基于 Transformer 的因果语言模型，通过在基于网络规模的图像文本对数据集GRIT上进行下一个单词预测任务进行训练。数据集中边界框的空间坐标被转换为位置标记序列，这些标记被附加到它们各自的实体文本跨度上（例如，a snowman后跟<patch_index_0044><patch_index_0863>）。数据格式类似于将图像中的对象区域与相应标题中的文本跨度连接起来的“超链接”。

论文摘要如下：

我们介绍了 Kosmos-2，一个多模态大型语言模型（MLLM），使其能够感知对象描述（例如，边界框）并将文本与视觉世界联系起来。具体来说，我们将引用表达式表示为 Markdown 中的链接，即“文本跨度”，其中对象描述是位置标记序列。与多模态语料库一起，我们构建了大规模的基于图像文本对的数据（称为 GrIT）来训练模型。除了 MLLM 的现有功能（例如，感知一般模态，遵循指令以及执行上下文学习）之外，Kosmos-2 还将接地能力整合到下游应用中。我们在广泛的任务上评估了 Kosmos-2，包括（i）多模态接地，例如引用表达理解和短语接地，（ii）多模态引用，例如引用表达生成，（iii）感知语言任务，以及（iv）语言理解和生成。这项工作为实体 AI 的发展奠定了基础，并为语言、多模态感知、行动和世界建模的大融合提供了启示，这是通往人工通用智能的关键一步。代码和预训练模型可在aka.ms/kosmos-2上获得。

KOSMOS-2 可以处理的任务概述。摘自原始论文。

示例

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

>>> model = Kosmos2ForConditionalGeneration.from_pretrained("microsoft/kosmos-2-patch14-224")
>>> processor = AutoProcessor.from_pretrained("microsoft/kosmos-2-patch14-224")

>>> url = "https://huggingface.co/microsoft/kosmos-2-patch14-224/resolve/main/snowman.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> prompt = "<grounding> An image of"

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

>>> generated_ids = model.generate(
...     pixel_values=inputs["pixel_values"],
...     input_ids=inputs["input_ids"],
...     attention_mask=inputs["attention_mask"],
...     image_embeds=None,
...     image_embeds_position_mask=inputs["image_embeds_position_mask"],
...     use_cache=True,
...     max_new_tokens=64,
... )
>>> generated_text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
>>> processed_text = processor.post_process_generation(generated_text, cleanup_and_extract=False)
>>> processed_text
'<grounding> An image of<phrase> a snowman</phrase><object><patch_index_0044><patch_index_0863></object> warming himself by<phrase> a fire</phrase><object><patch_index_0005><patch_index_0911></object>.'

>>> caption, entities = processor.post_process_generation(generated_text)
>>> caption
'An image of a snowman warming himself by a fire.'

>>> entities
[('a snowman', (12, 21), [(0.390625, 0.046875, 0.984375, 0.828125)]), ('a fire', (41, 47), [(0.171875, 0.015625, 0.484375, 0.890625)])]

这个模型是由Yih-Dar SHIEH贡献的。原始代码可以在这里找到。

Kosmos2Config

class transformers.Kosmos2Config

<来源>

( text_config = None vision_config = None latent_query_num = 64 **kwargs )

参数

• text_config (dict, optional) — 用于初始化Kosmos2TextConfig的配置选项字典。

• vision_config (dict, optional) — 用于初始化Kosmos2VisionConfig的配置选项字典。

• latent_query_num (int, optional, 默认为 64) — 代表文本解码器组件中使用的图像特征的潜在查询标记数量。

• kwargs (optional) — 关键字参数字典。

这是一个配置类，用于存储 Kosmos2Model 的配置。根据指定的参数实例化 KOSMOS-2 模型，定义模型架构。使用默认值实例化配置将产生类似于 KOSMOS-2 microsoft/kosmos-2-patch14-224 架构的配置。

示例：

>>> from transformers import Kosmos2Config, Kosmos2Model

>>> # Initializing a Kosmos-2 kosmos-2-patch14-224 style configuration
>>> configuration = Kosmos2Config()

>>> # Initializing a model (with random weights) from the kosmos-2-patch14-224 style configuration
>>> model = Kosmos2Model(configuration)

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

Kosmos2ImageProcessor

Kosmos2Processor

class transformers.Kosmos2Processor

< source >

( image_processor tokenizer num_patch_index_tokens = 1024 )

参数

• image_processor (CLIPImageProcessor) — CLIPImageProcessor 的一个实例。图像处理器是必需的输入。

• tokenizer (XLMRobertaTokenizerFast) — [‘XLMRobertaTokenizerFast`]的一个实例。分词器是必需的输入。

• num_patch_index_tokens (int, 可选, 默认为 1024) — 代表补丁索引的标记数量。

构建一个 KOSMOS-2 处理器，将 KOSMOS-2 图像处理器和 KOSMOS-2 分词器包装成一个单一处理器。

Kosmos2Processor 提供了 CLIPImageProcessor 的所有功能，以及 XLMRobertaTokenizerFast 的一些功能。查看call()和decode()的文档字符串以获取更多信息。

__call__

< source >

( images: Union = None text: Union = None bboxes: Union = None num_image_tokens: Optional = 64 first_image_token_id: Optional = None add_special_tokens: bool = True add_eos_token: bool = False padding: Union = False truncation: Union = None max_length: Optional = None pad_to_multiple_of: Optional = None return_attention_mask: Optional = None return_length: bool = False verbose: bool = True return_tensors: Union = None **kwargs )

参数

• bboxes (Union[List[Tuple[int]], List[Tuple[float]], List[List[Tuple[int]]], List[List[Tuple[float]]], 可选) — 与texts相关联的边界框。

• num_image_tokens (int, 默认为 64) — 用于标记存储图像信息的占位符的(连续)位置数量。这应该与您正在使用的Kosmos2Config实例中的latent_query_num`相同。

• first_image_token_id (int, 可选) — 用于保留存储图像信息的子序列的第一个位置的标记 id。如果未设置，将默认为self.tokenizer.unk_token_id + 1。

• add_eos_token (bool, 默认为False) — 当add_special_tokens=True时，是否包含EOS标记 id 在编码中。

此方法使用 CLIPImageProcessor.call()方法为模型准备图像，并使用 XLMRobertaTokenizerFast.call()为模型准备文本。

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

本文档的其余部分显示了特定于Kosmos2Processor的参数。

Kosmos2Model

class transformers.Kosmos2Model

< source >

( config: Kosmos2Config )

参数

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

KOSMOS-2 模型用于生成文本和图像特征。该模型由一个视觉编码器和一个语言模型组成。

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

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

forward

什么是注意力掩码？

( pixel_values: Optional = None input_ids: Optional = None image_embeds_position_mask: Optional = None attention_mask: Optional = None head_mask: Optional = None past_key_values: Optional = None image_embeds: Optional = None inputs_embeds: Optional = None position_ids: 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.kosmos2.modeling_kosmos2.Kosmos2ModelOutput or tuple(torch.FloatTensor)

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

• pixel_values (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息，请参阅 CLIPImageProcessor.call()。

• input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。默认情况下会忽略填充。

  0 表示头部被掩盖。

  1 表示头部未被掩盖，

• image_embeds — (torch.FloatTensor of shape (batch_size, latent_query_num, hidden_size), optional): 在 Kosmos2ImageToTextProjection 输出的隐藏状态序列。

  • 1 表示放置图像特征的位置，

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

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

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

  • 0 表示被掩盖的标记。

  什么是位置 ID？

• 什么是输入 ID？

  • image_embeds_position_mask (torch.Tensor of shape (batch_size, sequence_length), optional) — 用于指示在序列中插入图像特征的位置的掩码。掩码值选在 [0, 1] 之间：

  • past_key_values (tuple(tuple(torch.FloatTensor))，长度为 config.n_layers，每个元组包含 4 个形状为 (batch_size, num_heads, sequence_length - 1, embed_size_per_head) 的张量） — 包含注意力块的预计算键和值隐藏状态。可用于加速解码。

• <来源>

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

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

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

  0 表示不适用于图像特征的位置（即文本标记）。

• 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 而不是一个普通元组。

返回

transformers.models.kosmos2.modeling_kosmos2.Kosmos2ModelOutput或tuple(torch.FloatTensor)

一个transformers.models.kosmos2.modeling_kosmos2.Kosmos2ModelOutput或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False时）包含根据配置（<class 'transformers.models.kosmos2.configuration_kosmos2.Kosmos2Config'>）和输入不同元素。

• 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 之后的注意力权重，用于计算自注意力头中的加权平均值。

• image_embeds（形状为(batch_size, latent_query_num, hidden_size)的torch.FloatTensor，可选） — Kosmos2ImageToTextProjection输出处的隐藏状态序列。

• projection_attentions（tuple(torch.FloatTensor)，可选） — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。

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

• vision_model_output(BaseModelOutputWithPooling, 可选) — Kosmos2VisionModel的输出。

• 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)的张量，如果config.is_encoder_decoder=True，还有 2 个形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。

  包含预先计算的隐藏状态（自注意力块中的键和值，以及在交叉注意力块中，如果config.is_encoder_decoder=True，还可以使用）可用于加速顺序解码。

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

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

示例：

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

>>> model = Kosmos2Model.from_pretrained("microsoft/kosmos-2-patch14-224")
>>> processor = AutoProcessor.from_pretrained("microsoft/kosmos-2-patch14-224")

>>> url = "https://huggingface.co/microsoft/kosmos-2-patch14-224/resolve/main/snowman.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> text = (
...     "<grounding> An image of<phrase> a snowman</phrase><object><patch_index_0044><patch_index_0863>"
...     "</object> warming himself by<phrase> a fire</phrase><object><patch_index_0005><patch_index_0911>"
...     "</object>"
... )

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

>>> last_hidden_state = model(
...     pixel_values=inputs["pixel_values"],
...     input_ids=inputs["input_ids"],
...     attention_mask=inputs["attention_mask"],
...     image_embeds_position_mask=inputs["image_embeds_position_mask"],
... ).last_hidden_state
>>> list(last_hidden_state.shape)
[1, 91, 2048]

Kosmos2ForConditionalGeneration

class transformers.Kosmos2ForConditionalGeneration

<来源>

( config: Kosmos2Config )

参数

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

KOSMOS-2 模型用于生成文本和边界框，给定一张图片。该模型由视觉编码器和语言模型组成。

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

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

forward

<来源>

( pixel_values: Optional = None input_ids: Optional = None image_embeds_position_mask: Optional = None attention_mask: Optional = None head_mask: Optional = None past_key_values: Optional = None image_embeds: Optional = None inputs_embeds: Optional = None position_ids: 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.kosmos2.modeling_kosmos2.Kosmos2ForConditionalGenerationModelOutput or tuple(torch.FloatTensor)

参数

• pixel_values (torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 像素值。像素值可以使用 AutoImageProcessor 获取。详细信息请参阅 CLIPImageProcessor.call()。

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

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

  什么是输入 ID？

• image_embeds_position_mask (torch.Tensor，形状为(batch_size, sequence_length)，可选) — 用于指示在序列中插入图像特征的位置的蒙版。蒙版值选择在[0, 1]之间：

  • 1 表示放置图像特征的位置，

  • 0 表示不用于图像特征的位置（即文本标记）。

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

  • 1 表示未被蒙版的标记，

  • 0 表示被蒙版的标记。

  什么是注意力蒙版？

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

  • 1 表示头部未被蒙版，

  • 0 表示头部被蒙版。

• past_key_values (tuple(tuple(torch.FloatTensor))，长度为config.n_layers，每个元组包含形状为(batch_size, num_heads, sequence_length - 1, embed_size_per_head)的 4 个张量） — 包含注意力块的预计算键和值隐藏状态。可用于加速解码。

  如果使用past_key_values，用户可以选择仅输入最后一个decoder_input_ids（这些没有将其过去的键值状态提供给该模型）的形状为(batch_size, 1)，而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。image_embeds — (torch.FloatTensor，形状为(batch_size, latent_query_num, hidden_size)，可选）：Kosmos2ImageToTextProjection输出的隐藏状态序列。

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

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

  什么是位置 ID？

• 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, optional) — 是否返回一个 ModelOutput 而不是一个普通元组。

• labels (torch.LongTensor of shape (batch_size, sequence_length), optional) — 用于计算从左到右的语言建模损失（下一个词预测）的标签。索引应在[-100, 0, ..., config.vocab_size]范围内（参见input_ids文档字符串）。索引设置为-100的标记将被忽略（掩码），损失仅计算具有标签在[0, ..., config.vocab_size]范围内的标记。

返回

transformers.models.kosmos2.modeling_kosmos2.Kosmos2ForConditionalGenerationModelOutput或tuple(torch.FloatTensor)

一个transformers.models.kosmos2.modeling_kosmos2.Kosmos2ForConditionalGenerationModelOutput或一个torch.FloatTensor元组（如果传入return_dict=False或config.return_dict=False）包含根据配置（<class 'transformers.models.kosmos2.configuration_kosmos2.Kosmos2Config'>）和输入的不同元素。

• loss (torch.FloatTensor of shape (1,), optional, 当提供labels时返回) — 语言建模损失（用于下一个标记预测）。

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

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

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

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

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

• image_embeds (torch.FloatTensor of shape (batch_size, latent_query_num, hidden_size), optional) — 在Kosmos2ImageToTextProjection输出的隐藏状态序列。

• projection_attentions (tuple(torch.FloatTensor), optional) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。

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

• vision_model_output(BaseModelOutputWithPooling, 可选) - Kosmos2VisionModel的输出。

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

  包含预先计算的隐藏状态（自注意力块中的键和值，如果config.is_encoder_decoder=True还包括交叉注意力块中的键和值），可以用来加速顺序解码（参见past_key_values输入）。

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

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

示例：

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

>>> model = Kosmos2ForConditionalGeneration.from_pretrained("microsoft/kosmos-2-patch14-224")
>>> processor = AutoProcessor.from_pretrained("microsoft/kosmos-2-patch14-224")

>>> url = "https://huggingface.co/microsoft/kosmos-2-patch14-224/resolve/main/snowman.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> prompt = "<grounding> An image of"

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

>>> generated_ids = model.generate(
...     pixel_values=inputs["pixel_values"],
...     input_ids=inputs["input_ids"],
...     attention_mask=inputs["attention_mask"],
...     image_embeds=None,
...     image_embeds_position_mask=inputs["image_embeds_position_mask"],
...     use_cache=True,
...     max_new_tokens=64,
... )
>>> generated_text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
>>> processed_text = processor.post_process_generation(generated_text, cleanup_and_extract=False)
>>> processed_text
'<grounding> An image of<phrase> a snowman</phrase><object><patch_index_0044><patch_index_0863></object> warming himself by<phrase> a fire</phrase><object><patch_index_0005><patch_index_0911></object>.'

>>> caption, entities = processor.post_process_generation(generated_text)
>>> caption
'An image of a snowman warming himself by a fire.'

>>> entities
[('a snowman', (12, 21), [(0.390625, 0.046875, 0.984375, 0.828125)]), ('a fire', (41, 47), [(0.171875, 0.015625, 0.484375, 0.890625)])]

LayoutLM

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

概述

LayoutLM 模型是由 Yiheng Xu，Minghao Li，Lei Cui，Shaohan Huang，Furu Wei 和 Ming Zhou 在论文LayoutLM: Pre-training of Text and Layout for Document Image Understanding中提出的。这是一种简单但有效的文本和布局预训练方法，用于文档图像理解和信息提取任务，如表单理解和收据理解。它在几个下游任务上取得了最先进的结果：

• 表单理解：FUNSD数据集（包含 199 个带有超过 30,000 个单词的注释表单）。

• 收据理解：SROIE数据集（包含 626 张收据用于训练和 347 张收据用于测试）。

• 文档图像分类：RVL-CDIP数据集（包含 400,000 张图像，属于 16 个类别之一）。

论文摘要如下：

近年来，预训练技术在各种 NLP 任务中取得了成功。尽管预训练模型在 NLP 应用中被广泛使用，但它们几乎完全专注于文本级别的操作，而忽略了对于文档图像理解至关重要的布局和样式信息。在本文中，我们提出了 LayoutLM，以共同建模扫描文档图像中文本和布局信息之间的交互，这对于许多真实世界的文档图像理解任务（如从扫描文档中提取信息）是有益的。此外，我们还利用图像特征将单词的视觉信息整合到 LayoutLM 中。据我们所知，这是文本和布局首次在单个框架中共同学习以进行文档级预训练。它在几个下游任务中取得了最新的最先进结果，包括表单理解（从 70.72 到 79.27）、收据理解（从 94.02 到 95.24）和文档图像分类（从 93.07 到 94.42）。

使用提示

• 除了input_ids之外，forward()还需要输入bbox，这是输入标记的边界框（即 2D 位置）。这些可以使用外部 OCR 引擎（如 Google 的Tesseract）获取（有一个Python 包装器可用）。每个边界框应该采用（x0，y0，x1，y1）格式，其中（x0，y0）对应于边界框左上角的位置，（x1，y1）表示右下角的位置。请注意，首先需要将边界框归一化为 0-1000 的比例。要进行归一化，可以使用以下函数：

def normalize_bbox(bbox, width, height):
    return [
        int(1000 * (bbox[0] / width)),
        int(1000 * (bbox[1] / height)),
        int(1000 * (bbox[2] / width)),
        int(1000 * (bbox[3] / height)),
    ]

这里，width和height对应于标记出现的原始文档的宽度和高度。可以使用 Python Image Library（PIL）库来获取这些，例如：

from PIL import Image

# Document can be a png, jpg, etc. PDFs must be converted to images.
image = Image.open(name_of_your_document).convert("RGB")

width, height = image.size

资源

官方 Hugging Face 和社区（由🌎表示）资源列表，可帮助您开始使用 LayoutLM。如果您有兴趣提交资源以包含在此处，请随时打开 Pull Request，我们将进行审查！资源应该理想地展示一些新东西，而不是重复现有资源。

文档问答

• 一篇关于使用 Keras 和 Hugging Face Transformers 对 LayoutLM 进行文档理解微调的博文。

• 一篇关于如何仅使用 Hugging Face Transformers 对 LayoutLM 进行文档理解微调的博文。

• 关于如何在 FUNSD 数据集上使用图像嵌入来微调 LayoutLM 模型的笔记本。

• 另请参阅：文档问答任务指南

文本分类

• 关于如何在 RVL-CDIP 数据集上微调 LayoutLM 用于序列分类的笔记本。

• 文本分类任务指南

标记分类

• 关于如何在 FUNSD 数据集上微调 LayoutLM 用于标记分类的笔记本。

• 标记分类任务指南

其他资源

• 掩码语言建模任务指南

🚀 部署

• 关于如何使用 Hugging Face 推理端点部署 LayoutLM的博客文章。

LayoutLMConfig

class transformers.LayoutLMConfig

<来源>

( 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' use_cache = True max_2d_position_embeddings = 1024 **kwargs )

参数

• vocab_size (int, optional, defaults to 30522) — LayoutLM 模型的词汇表大小。定义了可以由传递给 LayoutLMModel 的inputs_ids表示的不同标记。

• 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 编码器中每个注意力层的注意力头数。

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

• hidden_act (str or function, 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) — 传递给 LayoutLMModel 的token_type_ids的词汇表大小。

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

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

• pad_token_id (int, optional, defaults to 0) — 用于填充input_ids的值。

• position_embedding_type (str, optional, defaults to "absolute") — 位置嵌入的类型。选择"absolute"、"relative_key"、"relative_key_query"中的一个。对于位置嵌入，请使用"absolute"。有关"relative_key"的更多信息，请参考具有相对位置表示的自注意力（Shaw 等人）。有关"relative_key_query"的更多信息，请参考[使用更好的相对位置嵌入改进 Transformer 模型（Huang 等人）]中的方法 4（https://arxiv.org/abs/2009.13658）。

• use_cache (bool, optional, defaults to True) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）。仅在config.is_decoder=True时相关。

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

这是配置类，用于存储 LayoutLMModel 的配置。它用于根据指定的参数实例化 LayoutLM 模型，定义模型架构。使用默认值实例化配置将产生类似于 LayoutLM microsoft/layoutlm-base-uncased架构的配置。

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

示例：

>>> from transformers import LayoutLMConfig, LayoutLMModel

>>> # Initializing a LayoutLM configuration
>>> configuration = LayoutLMConfig()

>>> # Initializing a model (with random weights) from the configuration
>>> model = LayoutLMModel(configuration)

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

LayoutLMTokenizer

class transformers.LayoutLMTokenizer

<来源>

( 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的值确定（与原始 LayoutLM 中的情况相同）。

构建一个基于 WordPiece 的 LayoutLM 分词器。

此分词器继承自 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]

带有适当特殊标记的 input IDs 列表。

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

• 单个序列：[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]

根据给定序列的 token type IDs 列表。

从传递的两个序列创建一个用于序列对分类任务的掩码。一个 LayoutLM 序列

序列掩码的格式如下：

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方法添加特殊标记时，将调用此方法。

LayoutLMTokenizerFast

class transformers.LayoutLMTokenizerFast

<来源>

( 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, optional, defaults to "[MASK]") — 用于屏蔽值的标记。这是在使用掩码语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。

• clean_text (bool, optional, defaults to True) — 是否在标记化之前清理文本，通过删除任何控制字符并将所有空格替换为经典空格。

• tokenize_chinese_chars (bool, optional, defaults to True) — 是否对中文字符进行分词。对于日语，这可能应该被禁用（参见此问题）。

• strip_accents (bool, optional) — 是否去除所有重音符号。如果未指定此选项，则将由lowercase的值确定（与原始 LayoutLM 中相同）。

• wordpieces_prefix (str, optional, defaults to "##") — 子词的前缀。

构建一个“快速”LayoutLM 标记器（由 HuggingFace 的tokenizers库支持）。基于 WordPiece。

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

build_inputs_with_special_tokens

<来源>

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

参数

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

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

返回

List[int]

具有适当特殊标记的 input IDs 列表。

从序列或序列对构建用于序列分类任务的模型输入，通过连接和添加特殊标记。一个 LayoutLM 序列具有以下格式：

• 单个序列：[CLS] X [SEP]

• 序列对：[CLS] A [SEP] B [SEP]

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]

根据给定序列的 token type IDs 列表。

从传递的两个序列创建用于序列对分类任务的掩码。一个 LayoutLM 序列

序列掩码具有以下格式：

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，则此方法仅返回掩码的第一部分（0s）。

PytorchHide Pytorch 内容

LayoutLMModel

class transformers.LayoutLMModel

<来源>

( config )

参数

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

裸的 LayoutLM 模型变压器输出原始隐藏状态，没有特定的头部。LayoutLM 模型由 Yiheng Xu、Minghao Li、Lei Cui、Shaohan Huang、Furu Wei 和 Ming Zhou 在LayoutLM: Pre-training of Text and Layout for Document Image Understanding中提出。

此模型是 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 encoder_hidden_states: Optional = None encoder_attention_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions 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]范围内的掩码值：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) — 如果设置为True，则返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。

• output_hidden_states (bool, optional) — 如果设置为True，则返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

• return_dict (bool, optional) — 如果设置为True，模型将返回一个 ModelOutput 而不是一个普通的元组。

返回

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

一个 transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions 或者一个torch.FloatTensor的元组（如果传递了return_dict=False或者当config.return_dict=False时），包括根据配置（LayoutLMConfig）和输入而定的各种元素。

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

• pooler_output（形状为(batch_size, hidden_size)的torch.FloatTensor） — 序列中第一个标记（分类标记）的最后一层隐藏状态（经过用于辅助预训练任务的层进一步处理后）。例如，对于 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 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

  解码器的交叉注意力层的注意力权重，在注意力 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)的张量，如果config.is_encoder_decoder=True还有额外的 2 个形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。

  包含预先计算的隐藏状态（自注意力块中的键和值以及在交叉注意力块中可选地如果config.is_encoder_decoder=True）可以用来加速顺序解码的（见past_key_values输入）。

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

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

示例：

>>> from transformers import AutoTokenizer, LayoutLMModel
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/layoutlm-base-uncased")
>>> model = LayoutLMModel.from_pretrained("microsoft/layoutlm-base-uncased")

>>> words = ["Hello", "world"]
>>> normalized_word_boxes = [637, 773, 693, 782], [698, 773, 733, 782]

>>> token_boxes = []
>>> for word, box in zip(words, normalized_word_boxes):
...     word_tokens = tokenizer.tokenize(word)
...     token_boxes.extend([box] * len(word_tokens))
>>> # add bounding boxes of cls + sep tokens
>>> token_boxes = [[0, 0, 0, 0]] + token_boxes + [[1000, 1000, 1000, 1000]]

>>> encoding = tokenizer(" ".join(words), return_tensors="pt")
>>> input_ids = encoding["input_ids"]
>>> attention_mask = encoding["attention_mask"]
>>> token_type_ids = encoding["token_type_ids"]
>>> bbox = torch.tensor([token_boxes])

>>> outputs = model(
...     input_ids=input_ids, bbox=bbox, attention_mask=attention_mask, token_type_ids=token_type_ids
... )

>>> last_hidden_states = outputs.last_hidden_state

LayoutLMForMaskedLM

class transformers.LayoutLMForMaskedLM

< source >

( config )

参数

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

在顶部带有语言建模头的 LayoutLM 模型。LayoutLM 模型是由 Yiheng Xu、Minghao Li、Lei Cui、Shaohan Huang、Furu Wei 和 Ming Zhou 在LayoutLM: Pre-training of Text and Layout for Document Image Understanding中提出的。

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

参数

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

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

  什么是输入 ID？

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

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

  什么是注意力掩码？

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

  什么是 token type IDs？

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

  什么是位置 ID？

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

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

• output_attentions（bool，可选）— 如果设置为True，则返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回的张量下的attentions。

• output_hidden_states（bool，可选）— 如果设置为True，则返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。

• return_dict（bool，可选）— 如果设置为True，模型将返回一个 ModelOutput 而不是一个普通元组。

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

返回

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

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

• loss（形状为(1,)的torch.FloatTensor，可选，当提供labels时返回）— 掩码语言建模（MLM）损失。

• logits（形状为(batch_size, sequence_length, config.vocab_size)的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 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoTokenizer, LayoutLMForMaskedLM
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/layoutlm-base-uncased")
>>> model = LayoutLMForMaskedLM.from_pretrained("microsoft/layoutlm-base-uncased")

>>> words = ["Hello", "[MASK]"]
>>> normalized_word_boxes = [637, 773, 693, 782], [698, 773, 733, 782]

>>> token_boxes = []
>>> for word, box in zip(words, normalized_word_boxes):
...     word_tokens = tokenizer.tokenize(word)
...     token_boxes.extend([box] * len(word_tokens))
>>> # add bounding boxes of cls + sep tokens
>>> token_boxes = [[0, 0, 0, 0]] + token_boxes + [[1000, 1000, 1000, 1000]]

>>> encoding = tokenizer(" ".join(words), return_tensors="pt")
>>> input_ids = encoding["input_ids"]
>>> attention_mask = encoding["attention_mask"]
>>> token_type_ids = encoding["token_type_ids"]
>>> bbox = torch.tensor([token_boxes])

>>> labels = tokenizer("Hello world", return_tensors="pt")["input_ids"]

>>> outputs = model(
...     input_ids=input_ids,
...     bbox=bbox,
...     attention_mask=attention_mask,
...     token_type_ids=token_type_ids,
...     labels=labels,
... )

>>> loss = outputs.loss

LayoutLMForSequenceClassification

class transformers.LayoutLMForSequenceClassification

<来源>

( config )

参数

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

LayoutLM 模型在顶部使用序列分类头部（池化输出的顶部线性层），例如用于文档图像分类任务的RVL-CDIP数据集。

LayoutLM 模型由 Yiheng Xu、Minghao Li、Lei Cui、Shaohan Huang、Furu Wei 和 Ming Zhou 在LayoutLM: Pre-training of Text and Layout for Document Image Understanding中提出。

该模型是 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，形状为(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]中选择：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，可选）— 如果设置为True，则返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。

• output_hidden_states（bool，可选）— 如果设置为True，则返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。

• return_dict（bool，可选）— 如果设置为True，模型将返回一个 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时）包含各种元素，取决于配置（LayoutLMConfig）和输入。

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

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

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

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

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

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

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

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

示例：

>>> from transformers import AutoTokenizer, LayoutLMForSequenceClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/layoutlm-base-uncased")
>>> model = LayoutLMForSequenceClassification.from_pretrained("microsoft/layoutlm-base-uncased")

>>> words = ["Hello", "world"]
>>> normalized_word_boxes = [637, 773, 693, 782], [698, 773, 733, 782]

>>> token_boxes = []
>>> for word, box in zip(words, normalized_word_boxes):
...     word_tokens = tokenizer.tokenize(word)
...     token_boxes.extend([box] * len(word_tokens))
>>> # add bounding boxes of cls + sep tokens
>>> token_boxes = [[0, 0, 0, 0]] + token_boxes + [[1000, 1000, 1000, 1000]]

>>> encoding = tokenizer(" ".join(words), return_tensors="pt")
>>> input_ids = encoding["input_ids"]
>>> attention_mask = encoding["attention_mask"]
>>> token_type_ids = encoding["token_type_ids"]
>>> bbox = torch.tensor([token_boxes])
>>> sequence_label = torch.tensor([1])

>>> outputs = model(
...     input_ids=input_ids,
...     bbox=bbox,
...     attention_mask=attention_mask,
...     token_type_ids=token_type_ids,
...     labels=sequence_label,
... )

>>> loss = outputs.loss
>>> logits = outputs.logits

LayoutLMForTokenClassification

class transformers.LayoutLMForTokenClassification

<来源>

( config )

参数

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

LayoutLM 模型在顶部带有一个标记分类头（隐藏状态输出的顶部是一个线性层），例如用于序列标记（信息提取）任务，如FUNSD数据集和SROIE数据集。

LayoutLM 模型由 Yiheng Xu、Minghao Li、Lei Cui、Shaohan Huang、Furu Wei 和 Ming Zhou 在LayoutLM: Pre-training of Text and Layout for Document Image Understanding中提出。

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

forward

< source >

( input_ids: Optional = None bbox: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.TokenClassifierOutput 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] 中选择：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) — 如果设置为 True，将返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的 attentions。

• output_hidden_states (bool, optional) — 如果设置为 True，将返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的 hidden_states。

• return_dict (bool, optional) — 如果设置为 True，模型将返回一个 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）包含各种元素，取决于配置(LayoutLMConfig)和输入。

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

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

• hidden_states (tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(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 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoTokenizer, LayoutLMForTokenClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/layoutlm-base-uncased")
>>> model = LayoutLMForTokenClassification.from_pretrained("microsoft/layoutlm-base-uncased")

>>> words = ["Hello", "world"]
>>> normalized_word_boxes = [637, 773, 693, 782], [698, 773, 733, 782]

>>> token_boxes = []
>>> for word, box in zip(words, normalized_word_boxes):
...     word_tokens = tokenizer.tokenize(word)
...     token_boxes.extend([box] * len(word_tokens))
>>> # add bounding boxes of cls + sep tokens
>>> token_boxes = [[0, 0, 0, 0]] + token_boxes + [[1000, 1000, 1000, 1000]]

>>> encoding = tokenizer(" ".join(words), return_tensors="pt")
>>> input_ids = encoding["input_ids"]
>>> attention_mask = encoding["attention_mask"]
>>> token_type_ids = encoding["token_type_ids"]
>>> bbox = torch.tensor([token_boxes])
>>> token_labels = torch.tensor([1, 1, 0, 0]).unsqueeze(0)  # batch size of 1

>>> outputs = model(
...     input_ids=input_ids,
...     bbox=bbox,
...     attention_mask=attention_mask,
...     token_type_ids=token_type_ids,
...     labels=token_labels,
... )

>>> loss = outputs.loss
>>> logits = outputs.logits

LayoutLMForQuestionAnswering

class transformers.LayoutLMForQuestionAnswering

< source >

( config has_visual_segment_embedding = True )

参数

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

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

LayoutLM 模型由 Yiheng Xu、Minghao Li、Lei Cui、Shaohan Huang、Furu Wei 和 Ming Zhou 在LayoutLM: Pre-training of Text and Layout for Document Image Understanding中提出。

这个模型是 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)

返回

transformers.modeling_outputs.QuestionAnsweringModelOutput 或torch.FloatTensor元组

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

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

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

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

• hidden_states (tuple(torch.FloatTensor)，可选，当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回） — 形状为 (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 后的注意力权重，用于计算自注意力头中的加权平均值。

start_positions (torch.LongTensor，形状为 (batch_size,)，可选）：用于计算标记跨度的起始位置（索引）的标签。位置被夹紧到序列的长度（sequence_length）。超出序列范围的位置不会计入损失计算。end_positions (torch.LongTensor，形状为 (batch_size,)，可选）：用于计算标记跨度的结束位置（索引）的标签。位置被夹紧到序列的长度（sequence_length）。超出序列范围的位置不会计入损失计算。

示例：

在下面的示例中，我们为 LayoutLM 模型准备了一个问题 + 上下文对。它将给我们一个预测，告诉我们它认为答案是什么（从图像解析的文本中提取的答案跨度）。

>>> from transformers import AutoTokenizer, LayoutLMForQuestionAnswering
>>> from datasets import load_dataset
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("impira/layoutlm-document-qa", add_prefix_space=True)
>>> model = LayoutLMForQuestionAnswering.from_pretrained("impira/layoutlm-document-qa", revision="1e3ebac")

>>> dataset = load_dataset("nielsr/funsd", split="train")
>>> example = dataset[0]
>>> question = "what's his name?"
>>> words = example["words"]
>>> boxes = example["bboxes"]

>>> encoding = tokenizer(
...     question.split(), words, is_split_into_words=True, return_token_type_ids=True, return_tensors="pt"
... )
>>> bbox = []
>>> for i, s, w in zip(encoding.input_ids[0], encoding.sequence_ids(0), encoding.word_ids(0)):
...     if s == 1:
...         bbox.append(boxes[w])
...     elif i == tokenizer.sep_token_id:
...         bbox.append([1000] * 4)
...     else:
...         bbox.append([0] * 4)
>>> encoding["bbox"] = torch.tensor([bbox])

>>> word_ids = encoding.word_ids(0)
>>> outputs = model(**encoding)
>>> loss = outputs.loss
>>> start_scores = outputs.start_logits
>>> end_scores = outputs.end_logits
>>> start, end = word_ids[start_scores.argmax(-1)], word_ids[end_scores.argmax(-1)]
>>> print(" ".join(words[start : end + 1]))
M. Hamann P. Harper, P. Martinez

TensorFlow 隐藏 TensorFlow 内容

TFLayoutLMModel

class transformers.TFLayoutLMModel

< source >

( config: LayoutLMConfig *inputs **kwargs )

参数

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

裸的 LayoutLM 模型变压器输出原始隐藏状态，没有特定的头部。

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

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

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

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

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

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

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

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

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

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

call

<来源>

( input_ids: TFModelInputType | None = None bbox: np.ndarray | tf.Tensor | None = None attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None encoder_hidden_states: np.ndarray | tf.Tensor | None = None encoder_attention_mask: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: Optional[bool] = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingAndCrossAttentions or tuple(tf.Tensor)

参数

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

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

  什么是输入 ID？

• bbox（形状为(batch_size, sequence_length, 4)的Numpy数组或tf.Tensor，可选）— 每个输入序列标记的边界框。在范围 [0, config.max_2d_position_embeddings- 1] 中选择。

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

  • 1 表示未被 masked 的标记，

  • 0 表示被 masked 的标记。

  什么是注意力掩码？

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

  • 0 对应于一个 句子 A 的标记，

  • 1 对应于一个 句子 B 的标记。

  什么是标记类型 ID？

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

  什么是位置 ID？

• head_mask（形状为(num_heads,)或(num_layers, num_heads)的Numpy数组或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 而不是普通元组。

• training (bool，可选，默认为False) — 是否在训练模式下使用模型（一些模块如 dropout 模块在训练和评估之间有不同的行为）。

返回

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

transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingAndCrossAttentions 或一个tf.Tensor元组（如果传递return_dict=False或config.return_dict=False时），包括根据配置（LayoutLMConfig）和输入的不同元素。

• last_hidden_state (tf.Tensor of shape (batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列的输出。

• pooler_output (tf.Tensor of shape (batch_size, hidden_size)) — 第一个标记的最后一层隐藏状态（分类标记），经过线性层和 Tanh 激活函数进一步处理。线性层的权重是在预训练期间从下一个句子预测（分类）目标中训练的。

  这个输出通常不是输入的语义内容的好摘要，通常最好对整个输入序列的隐藏状态进行平均或池化。

• past_key_values (List[tf.Tensor]，可选，当传递use_cache=True或config.use_cache=True时返回）— 长度为config.n_layers的tf.Tensor列表，每个张量的形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head)）。

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

• 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 后的注意力权重，用于计算自注意力头中的加权平均值。

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

  解码器的交叉注意力层的注意力权重，经过注意力 softmax 后，用于计算交叉注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoTokenizer, TFLayoutLMModel
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/layoutlm-base-uncased")
>>> model = TFLayoutLMModel.from_pretrained("microsoft/layoutlm-base-uncased")

>>> words = ["Hello", "world"]
>>> normalized_word_boxes = [637, 773, 693, 782], [698, 773, 733, 782]

>>> token_boxes = []
>>> for word, box in zip(words, normalized_word_boxes):
...     word_tokens = tokenizer.tokenize(word)
...     token_boxes.extend([box] * len(word_tokens))
>>> # add bounding boxes of cls + sep tokens
>>> token_boxes = [[0, 0, 0, 0]] + token_boxes + [[1000, 1000, 1000, 1000]]

>>> encoding = tokenizer(" ".join(words), return_tensors="tf")
>>> input_ids = encoding["input_ids"]
>>> attention_mask = encoding["attention_mask"]
>>> token_type_ids = encoding["token_type_ids"]
>>> bbox = tf.convert_to_tensor([token_boxes])

>>> outputs = model(
...     input_ids=input_ids, bbox=bbox, attention_mask=attention_mask, token_type_ids=token_type_ids
... )

>>> last_hidden_states = outputs.last_hidden_state

TFLayoutLMForMaskedLM

class transformers.TFLayoutLMForMaskedLM

<来源>

( config: LayoutLMConfig *inputs **kwargs )

参数

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

在顶部带有语言建模头的 LayoutLM 模型。

此模型继承自 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: TFModelInputType | None = None bbox: np.ndarray | tf.Tensor | None = None attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None head_mask: 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 labels: np.ndarray | tf.Tensor | None = None training: Optional[bool] = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFMaskedLMOutput or tuple(tf.Tensor)

参数

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

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

  什么是输入 ID？

• bbox（形状为(batch_size, sequence_length, 4)的Numpy数组或tf.Tensor，可选）- 每个输入序列标记的边界框。选择范围为[0, config.max_2d_position_embeddings- 1]。

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

  • 对于未被遮蔽的标记，

  • 0 表示头部被遮蔽。

  什么是注意力掩码？

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

  • 0 对应于句子 A标记，

  • 1 对应于句子 B标记。

  什么是标记类型 ID？

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

  什么是位置 ID？

• head_mask (Numpy 数组或形状为(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 而不是一个普通元组。

• training (bool，可选，默认为False) — 是否在训练模式下使用模型（一些模块，如 dropout 模块，在训练和评估之间具有不同的行为）。

• labels (tf.Tensor或形状为(batch_size, sequence_length)的np.ndarray，可选) — 用于计算遮蔽语言建模损失的标签。索引应在[-100, 0, ..., config.vocab_size]内（参见input_ids文档字符串）。索引设置为-100的标记将被忽略（遮蔽），损失仅计算具有标签在[0, ..., config.vocab_size]内的标记。

返回

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

一个 transformers.modeling_tf_outputs.TFMaskedLMOutput 或一个tf.Tensor元组（如果传递了return_dict=False或当config.return_dict=False时）包含各种元素，具体取决于配置（LayoutLMConfig）和输入。

• loss (形状为(n,)的tf.Tensor，*可选*，当提供labels`时返回，其中 n 是非遮蔽标签的数量) — 遮蔽语言建模（MLM）损失。

• logits (形状为(batch_size, sequence_length, config.vocab_size)的tf.Tensor`) — 语言建模头的预测分数（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 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoTokenizer, TFLayoutLMForMaskedLM
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/layoutlm-base-uncased")
>>> model = TFLayoutLMForMaskedLM.from_pretrained("microsoft/layoutlm-base-uncased")

>>> words = ["Hello", "[MASK]"]
>>> normalized_word_boxes = [637, 773, 693, 782], [698, 773, 733, 782]

>>> token_boxes = []
>>> for word, box in zip(words, normalized_word_boxes):
...     word_tokens = tokenizer.tokenize(word)
...     token_boxes.extend([box] * len(word_tokens))
>>> # add bounding boxes of cls + sep tokens
>>> token_boxes = [[0, 0, 0, 0]] + token_boxes + [[1000, 1000, 1000, 1000]]

>>> encoding = tokenizer(" ".join(words), return_tensors="tf")
>>> input_ids = encoding["input_ids"]
>>> attention_mask = encoding["attention_mask"]
>>> token_type_ids = encoding["token_type_ids"]
>>> bbox = tf.convert_to_tensor([token_boxes])

>>> labels = tokenizer("Hello world", return_tensors="tf")["input_ids"]

>>> outputs = model(
...     input_ids=input_ids,
...     bbox=bbox,
...     attention_mask=attention_mask,
...     token_type_ids=token_type_ids,
...     labels=labels,
... )

>>> loss = outputs.loss

TFLayoutLMForSequenceClassification

class transformers.TFLayoutLMForSequenceClassification

<来源>

( config: LayoutLMConfig *inputs **kwargs )

参数

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

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

这个模型继承自 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: TFModelInputType | None = None bbox: np.ndarray | tf.Tensor | None = None attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None head_mask: 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 labels: np.ndarray | tf.Tensor | None = None training: Optional[bool] = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFSequenceClassifierOutput or tuple(tf.Tensor)

参数

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

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

  什么是输入 ID？

• bbox (Numpy array 或 tf.Tensor，形状为 (batch_size, sequence_length, 4)，可选) — 每个输入序列标记的边界框。选择范围为 [0, config.max_2d_position_embeddings- 1]。

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

  • 1 表示未被 masked 的标记，

  • 0 表示被 masked 的标记。

  什么是注意力掩码？

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

  • 0 对应于 句子 A 标记，

  • 1 对应于 句子 B 标记。

  什么是标记类型 ID？

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

  什么是位置 ID？

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

  • 1 表示头部未被 masked，

  • 0 表示头部被 masked。

• 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 而不是普通元组。

• training (bool，可选，默认为 False) — 是否在训练模式下使用模型（一些模块如 dropout 模块在训练和评估之间有不同的行为）。

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

返回

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

一个 transformers.modeling_tf_outputs.TFSequenceClassifierOutput 或一个tf.Tensor元组（如果传递了return_dict=False或config.return_dict=False时）包含各种元素，取决于配置（LayoutLMConfig）和输入。

• 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 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoTokenizer, TFLayoutLMForSequenceClassification
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/layoutlm-base-uncased")
>>> model = TFLayoutLMForSequenceClassification.from_pretrained("microsoft/layoutlm-base-uncased")

>>> words = ["Hello", "world"]
>>> normalized_word_boxes = [637, 773, 693, 782], [698, 773, 733, 782]

>>> token_boxes = []
>>> for word, box in zip(words, normalized_word_boxes):
...     word_tokens = tokenizer.tokenize(word)
...     token_boxes.extend([box] * len(word_tokens))
>>> # add bounding boxes of cls + sep tokens
>>> token_boxes = [[0, 0, 0, 0]] + token_boxes + [[1000, 1000, 1000, 1000]]

>>> encoding = tokenizer(" ".join(words), return_tensors="tf")
>>> input_ids = encoding["input_ids"]
>>> attention_mask = encoding["attention_mask"]
>>> token_type_ids = encoding["token_type_ids"]
>>> bbox = tf.convert_to_tensor([token_boxes])
>>> sequence_label = tf.convert_to_tensor([1])

>>> outputs = model(
...     input_ids=input_ids,
...     bbox=bbox,
...     attention_mask=attention_mask,
...     token_type_ids=token_type_ids,
...     labels=sequence_label,
... )

>>> loss = outputs.loss
>>> logits = outputs.logits

TFLayoutLMForTokenClassification

class transformers.TFLayoutLMForTokenClassification

<来源>

( config: LayoutLMConfig *inputs **kwargs )

参数

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

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

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

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

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

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

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

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

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

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

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

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

call

<来源>

( input_ids: TFModelInputType | None = None bbox: np.ndarray | tf.Tensor | None = None attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None head_mask: 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 labels: np.ndarray | 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）- 词汇表中输入序列令牌的索引。

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

  什么是输入 ID？

• bbox（形状为(batch_size, sequence_length, 4)的Numpy数组或tf.Tensor，可选）- 每个输入序列令牌的边界框。在范围[0, config.max_2d_position_embeddings- 1]中选择。

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

  • 1 表示未被masked的令牌，

  • 0 表示被masked的令牌。

  什么是注意力掩码？

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

  • 0 对应于句子 A令牌，

  • 1 对应于句子 B令牌。

  什么是令牌类型 ID？

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

  什么是位置 ID？

• head_mask（形状为(num_heads,)或(num_layers, num_heads)的Numpy数组或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，optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。

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

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

• training (bool，optional，默认为False) — 是否在训练模式下使用模型（一些模块，如 dropout 模块，在训练和评估之间有不同的行为）。

• labels (tf.Tensor或形状为(batch_size, sequence_length)的np.ndarray，optional) — 用于计算标记分类损失的标签。索引应在[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）包含根据配置（LayoutLMConfig）和输入的不同元素。

• loss (tf.Tensor，形状为(n,)，optional，当提供labels时返回，其中 n 是未屏蔽标签的数量) — 分类损失。

• logits (tf.Tensor，形状为(batch_size, sequence_length, config.num_labels)) — 分类分数（SoftMax 之前）。

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

  每个层的模型的隐藏状态加上初始嵌入输出。

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

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

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

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

示例：

>>> import tensorflow as tf
>>> from transformers import AutoTokenizer, TFLayoutLMForTokenClassification

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/layoutlm-base-uncased")
>>> model = TFLayoutLMForTokenClassification.from_pretrained("microsoft/layoutlm-base-uncased")

>>> words = ["Hello", "world"]
>>> normalized_word_boxes = [637, 773, 693, 782], [698, 773, 733, 782]

>>> token_boxes = []
>>> for word, box in zip(words, normalized_word_boxes):
...     word_tokens = tokenizer.tokenize(word)
...     token_boxes.extend([box] * len(word_tokens))
>>> # add bounding boxes of cls + sep tokens
>>> token_boxes = [[0, 0, 0, 0]] + token_boxes + [[1000, 1000, 1000, 1000]]

>>> encoding = tokenizer(" ".join(words), return_tensors="tf")
>>> input_ids = encoding["input_ids"]
>>> attention_mask = encoding["attention_mask"]
>>> token_type_ids = encoding["token_type_ids"]
>>> bbox = tf.convert_to_tensor([token_boxes])
>>> token_labels = tf.convert_to_tensor([1, 1, 0, 0])

>>> outputs = model(
...     input_ids=input_ids,
...     bbox=bbox,
...     attention_mask=attention_mask,
...     token_type_ids=token_type_ids,
...     labels=token_labels,
... )

>>> loss = outputs.loss
>>> logits = outputs.logits

TFLayoutLMForQuestionAnswering

class transformers.TFLayoutLMForQuestionAnswering

<来源>

( config: LayoutLMConfig *inputs **kwargs )

参数

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

LayoutLM 模型，顶部带有用于提取式问答任务（如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 方法之外使用第二种格式，比如在使用 Keras Functional API 创建自己的层或模型时，有三种可能性可以用来收集第一个位置参数中的所有输入张量：

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

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

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

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

call

<来源>

( input_ids: TFModelInputType | None = None bbox: np.ndarray | tf.Tensor | None = None attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None head_mask: 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 start_positions: np.ndarray | tf.Tensor | None = None end_positions: np.ndarray | tf.Tensor | None = None training: Optional[bool] = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFQuestionAnsweringModelOutput or tuple(tf.Tensor)

参数

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

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

  什么是输入 ID？

• bbox（形状为(batch_size, sequence_length, 4)的Numpy数组或tf.Tensor，可选） - 每个输入序列标记的边界框。在范围[0, config.max_2d_position_embeddings- 1]中选择。

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

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

  • 0 表示被掩码的标记。

  什么是注意力掩码？

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

  • 0 对应于句子 A的标记，

  • 1 对应于句子 B的标记。

  什么是标记类型 ID？

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

  什么是位置 ID？

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

  • 1 表示头部未被屏蔽，

  • 0 表示头部被屏蔽。

• 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 而不是一个普通的元组。

• training (bool, optional, 默认为False) — 是否在训练模式下使用模型（一些模块，如 dropout 模块，在训练和评估之间有不同的行为）。

• start_positions (tf.Tensor or np.ndarray of shape (batch_size,), optional) — 用于计算标记跨度开始位置的标签（索引）的位置。位置被夹紧到序列的长度(sequence_length)。序列外的位置不会被考虑在内计算损失。

• end_positions (tf.Tensor or np.ndarray of shape (batch_size,), optional) — 用于计算标记跨度结束位置的标签（索引）的位置。位置被夹紧到序列的长度(sequence_length)。序列外的位置不会被考虑在内计算损失。

返回

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

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

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

• start_logits (tf.Tensor of shape (batch_size, sequence_length)) — 跨度开始分数（在 SoftMax 之前）。

• end_logits (tf.Tensor of shape (batch_size, sequence_length)) — Span-end scores (before SoftMax).

• hidden_states (tuple(tf.Tensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — 元组的tf.Tensor（一个用于嵌入的输出 + 一个用于每一层的输出）的形状为(batch_size, sequence_length, hidden_size)。

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

• attentions (tuple(tf.Tensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — Tuple of tf.Tensor (one for each layer) of shape (batch_size, num_heads, sequence_length, sequence_length).

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

TFLayoutLMForQuestionAnswering 的前向方法重写了__call__特殊方法。

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

示例：

>>> import tensorflow as tf
>>> from transformers import AutoTokenizer, TFLayoutLMForQuestionAnswering
>>> from datasets import load_dataset

>>> tokenizer = AutoTokenizer.from_pretrained("impira/layoutlm-document-qa", add_prefix_space=True)
>>> model = TFLayoutLMForQuestionAnswering.from_pretrained("impira/layoutlm-document-qa", revision="1e3ebac")

>>> dataset = load_dataset("nielsr/funsd", split="train")
>>> example = dataset[0]
>>> question = "what's his name?"
>>> words = example["words"]
>>> boxes = example["bboxes"]

>>> encoding = tokenizer(
...     question.split(), words, is_split_into_words=True, return_token_type_ids=True, return_tensors="tf"
... )
>>> bbox = []
>>> for i, s, w in zip(encoding.input_ids[0], encoding.sequence_ids(0), encoding.word_ids(0)):
...     if s == 1:
...         bbox.append(boxes[w])
...     elif i == tokenizer.sep_token_id:
...         bbox.append([1000] * 4)
...     else:
...         bbox.append([0] * 4)
>>> encoding["bbox"] = tf.convert_to_tensor([bbox])

>>> word_ids = encoding.word_ids(0)
>>> outputs = model(**encoding)
>>> loss = outputs.loss
>>> start_scores = outputs.start_logits
>>> end_scores = outputs.end_logits
>>> start, end = word_ids[tf.math.argmax(start_scores, -1)[0]], word_ids[tf.math.argmax(end_scores, -1)[0]]
>>> print(" ".join(words[start : end + 1]))
M. Hamann P. Harper, P. Martinez

LayoutLMV2

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

概述

LayoutLMV2 模型是由 Yang Xu、Yiheng Xu、Tengchao Lv、Lei Cui、Furu Wei、Guoxin Wang、Yijuan Lu、Dinei Florencio、Cha Zhang、Wanxiang Che、Min Zhang、Lidong Zhou 提出的LayoutLMv2: Multi-modal Pre-training for Visually-Rich Document Understanding。LayoutLMV2 改进了 LayoutLM 以获得跨多个文档图像理解基准的最新结果：

• 从扫描文档中提取信息：FUNSD数据集（包含超过 30,000 个单词的 199 个带注释表格）、CORD数据集（包含 800 张用于训练的收据、100 张用于验证和 100 张用于测试）、SROIE数据集（包含 626 张用于训练和 347 张用于测试的收据）以及Kleister-NDA数据集（包含来自 EDGAR 数据库的非披露协议，包括 254 份用于训练、83 份用于验证和 203 份用于测试的文件）。

• 文档图像分类：RVL-CDIP数据集（包含 40 万张属于 16 个类别的图像）。

• 文档视觉问答：DocVQA数据集（包含在 12,000 多个文档图像上定义的 5 万个问题）。

该论文的摘要如下：

文本和布局的预训练在各种视觉丰富的文档理解任务中已被证明是有效的，这是由于其有效的模型架构和大规模未标记的扫描/数字化文档的优势。在本文中，我们提出了 LayoutLMv2，通过在多模态框架中预训练文本、布局和图像，利用了新的模型架构和预训练任务。具体来说，LayoutLMv2 不仅使用现有的遮蔽视觉语言建模任务，还使用新的文本-图像对齐和文本-图像匹配任务在预训练阶段，从而更好地学习跨模态交互。同时，它还将空间感知自注意机制集成到 Transformer 架构中，使模型能够充分理解不同文本块之间的相对位置关系。实验结果表明，LayoutLMv2 优于强基线，并在各种下游视觉丰富的文档理解任务中取得了新的最先进结果，包括 FUNSD（0.7895 -> 0.8420）、CORD（0.9493 -> 0.9601）、SROIE（0.9524 -> 0.9781）、Kleister-NDA（0.834 -> 0.852）、RVL-CDIP（0.9443 -> 0.9564）和 DocVQA（0.7295 -> 0.8672）。预训练的 LayoutLMv2 模型可以在此 https URL 上公开获取。

LayoutLMv2 依赖于detectron2、torchvision和tesseract。运行以下命令进行安装：

python -m pip install 'git+https://github.com/facebookresearch/detectron2.git'
python -m pip install torchvision tesseract

（如果您正在开发 LayoutLMv2，请注意通过 doctests 还需要安装这些包。）

使用提示

• LayoutLMv1 和 LayoutLMv2 之间的主要区别在于后者在预训练期间包含了视觉嵌入（而 LayoutLMv1 仅在微调期间添加了视觉嵌入）。

• LayoutLMv2 在自注意力层中添加了相对 1D 注意力偏置和空间 2D 注意力偏置到注意力分数中。详细信息可在论文的第 5 页找到。

• 可以在此处找到如何在 RVL-CDIP、FUNSD、DocVQA、CORD 上使用 LayoutLMv2 模型的演示笔记本。

• LayoutLMv2 使用 Facebook AI 的Detectron2包作为其视觉骨干。查看此链接获取安装说明。

• 除了input_ids，forward()还需要 2 个额外的输入，即image和bbox。image输入对应于文本标记出现的原始文档图像。模型期望每个文档图像的大小为 224x224。这意味着如果您有一批文档图像，image应该是形状为(batch_size, 3, 224, 224)的张量。这可以是torch.Tensor或Detectron2.structures.ImageList。您不需要对通道进行归一化，因为模型会自行处理。需要注意的是，视觉主干期望 BGR 通道而不是 RGB，因为 Detectron2 中的所有模型都是使用 BGR 格式进行预训练的。bbox输入是输入文本标记的边界框（即 2D 位置）。这与 LayoutLMModel 相同。可以使用外部 OCR 引擎（例如 Google 的Tesseract）（有一个Python 包装器可用）来获取这些信息。每个边界框应采用(x0, y0, x1, y1)格式，其中(x0, y0)对应于边界框左上角的位置，(x1, y1)表示右下角的位置。请注意，首先需要将边界框归一化为 0-1000 的比例。要进行归一化，可以使用以下函数：

def normalize_bbox(bbox, width, height):
    return [
        int(1000 * (bbox[0] / width)),
        int(1000 * (bbox[1] / height)),
        int(1000 * (bbox[2] / width)),
        int(1000 * (bbox[3] / height)),
    ]

这里，width和height对应于标记出现的原始文档的宽度和高度（在调整图像大小之前）。可以使用 Python Image Library（PIL）库来获取这些信息，例如：

from PIL import Image

image = Image.open(
    "name_of_your_document - can be a png, jpg, etc. of your documents (PDFs must be converted to images)."
)

width, height = image.size

然而，该模型包含一个全新的 LayoutLMv2Processor，可用于直接为模型准备数据（包括在底层应用 OCR）。更多信息可以在下面的“使用”部分找到。

• 在内部，LayoutLMv2Model 将通过其视觉主干发送image输入，以获得一个分辨率较低的特征图，其形状等于 LayoutLMv2Config 的image_feature_pool_shape属性。然后将该特征图展平以获得一系列图像标记。由于特征图的大小默认为 7x7，因此获得 49 个图像标记。然后将这些标记与文本标记连接，并通过 Transformer 编码器发送。这意味着模型的最后隐藏状态将具有长度为 512 + 49 = 561，如果您将文本标记填充到最大长度。更一般地，最后的隐藏状态将具有形状seq_length + image_feature_pool_shape[0] * config.image_feature_pool_shape[1]。

• 在调用 from_pretrained()时，将打印一个警告，其中包含一长串未初始化的参数名称。这不是问题，因为这些参数是批量归一化统计数据，在自定义数据集上微调时将具有值。

• 如果要在分布式环境中训练模型，请确保在模型上调用synchronize_batch_norm，以便正确同步视觉主干的批量归一化层。

此外，还有 LayoutXLM，这是 LayoutLMv2 的多语言版本。更多信息可以在 LayoutXLM 的文档页面找到。

资源

官方 Hugging Face 和社区（由🌎表示）资源列表，可帮助您开始使用 LayoutLMv2。如果您有兴趣提交资源以包含在此处，请随时提出拉取请求，我们将对其进行审查！资源应该展示一些新内容，而不是重复现有资源。

文本分类

• 关于如何在 RVL-CDIP 数据集上对 LayoutLMv2 进行微调以进行文本分类的笔记。

• 另请参阅：文本分类任务指南

问答

• 关于如何在 DocVQA 数据集上对 LayoutLMv2 进行问答微调的笔记。

• 另请参阅：问答任务指南

• 另请参阅：文档问答任务指南

标记分类

• 关于如何在 CORD 数据集上对 LayoutLMv2 进行微调以进行标记分类的笔记。

• 关于如何在 FUNSD 数据集上对 LayoutLMv2 进行微调以进行标记分类的笔记。

• 另请参阅：标记分类任务指南

用法：LayoutLMv2Processor

为模型准备数据的最简单方法是使用 LayoutLMv2Processor，它在内部结合了图像处理器（LayoutLMv2ImageProcessor）和标记器（LayoutLMv2Tokenizer 或 LayoutLMv2TokenizerFast）。图像处理器处理图像模态，而标记器处理文本模态。处理器结合了两者，这对于像 LayoutLMv2 这样的多模态模型是理想的。请注意，如果您只想处理一个模态，仍然可以分别使用两者。

from transformers import LayoutLMv2ImageProcessor, LayoutLMv2TokenizerFast, LayoutLMv2Processor

image_processor = LayoutLMv2ImageProcessor()  # apply_ocr is set to True by default
tokenizer = LayoutLMv2TokenizerFast.from_pretrained("microsoft/layoutlmv2-base-uncased")
processor = LayoutLMv2Processor(image_processor, tokenizer)

简而言之，可以将文档图像（以及可能的其他数据）提供给 LayoutLMv2Processor，它将创建模型期望的输入。在内部，处理器首先使用 LayoutLMv2ImageProcessor 在图像上应用 OCR，以获取单词列表和标准化边界框，并将图像调整大小以获得image输入。然后，单词和标准化边界框提供给 LayoutLMv2Tokenizer 或 LayoutLMv2TokenizerFast，将它们转换为标记级别的input_ids、attention_mask、token_type_ids、bbox。可选地，可以向处理器提供单词标签，这些标签将转换为标记级别的labels。

LayoutLMv2Processor 使用PyTesseract，这是 Google 的 Tesseract OCR 引擎的 Python 封装。请注意，您仍然可以使用自己选择的 OCR 引擎，并自己提供单词和标准化框。这需要使用apply_ocr设置为False来初始化 LayoutLMv2ImageProcessor。

总共有 5 个处理器支持的使用案例。下面我们列出它们。请注意，这些使用案例对批处理和非批处理输入都适用（我们为非批处理输入进行说明）。

使用案例 1：文档图像分类（训练、推理）+标记分类（推理），apply_ocr=True

这是最简单的情况，处理器（实际上是图像处理器）将对图像执行 OCR，以获取单词和标准化边界框。

from transformers import LayoutLMv2Processor
from PIL import Image

processor = LayoutLMv2Processor.from_pretrained("microsoft/layoutlmv2-base-uncased")

image = Image.open(
    "name_of_your_document - can be a png, jpg, etc. of your documents (PDFs must be converted to images)."
).convert("RGB")
encoding = processor(
    image, return_tensors="pt"
)  # you can also add all tokenizer parameters here such as padding, truncation
print(encoding.keys())
# dict_keys(['input_ids', 'token_type_ids', 'attention_mask', 'bbox', 'image'])

使用案例 2：文档图像分类（训练、推理）+标记分类（推理），apply_ocr=False

如果想要自己执行 OCR，可以将图像处理器初始化为apply_ocr设置为False。在这种情况下，应该自己向处理器提供单词和相应的（标准化的）边界框。

from transformers import LayoutLMv2Processor
from PIL import Image

processor = LayoutLMv2Processor.from_pretrained("microsoft/layoutlmv2-base-uncased", revision="no_ocr")

image = Image.open(
    "name_of_your_document - can be a png, jpg, etc. of your documents (PDFs must be converted to images)."
).convert("RGB")
words = ["hello", "world"]
boxes = [[1, 2, 3, 4], [5, 6, 7, 8]]  # make sure to normalize your bounding boxes
encoding = processor(image, words, boxes=boxes, return_tensors="pt")
print(encoding.keys())
# dict_keys(['input_ids', 'token_type_ids', 'attention_mask', 'bbox', 'image'])

使用案例 3：标记分类（训练），apply_ocr=False

对于标记分类任务（如 FUNSD、CORD、SROIE、Kleister-NDA），还可以提供相应的单词标签以训练模型。处理器将把这些转换为标记级别的labels。默认情况下，它只会标记单词的第一个词片，并用-100 标记剩余的词片，这是 PyTorch 的 CrossEntropyLoss 的ignore_index。如果希望标记单词的所有词片，可以将分词器初始化为only_label_first_subword设置为False。

from transformers import LayoutLMv2Processor
from PIL import Image

processor = LayoutLMv2Processor.from_pretrained("microsoft/layoutlmv2-base-uncased", revision="no_ocr")

image = Image.open(
    "name_of_your_document - can be a png, jpg, etc. of your documents (PDFs must be converted to images)."
).convert("RGB")
words = ["hello", "world"]
boxes = [[1, 2, 3, 4], [5, 6, 7, 8]]  # make sure to normalize your bounding boxes
word_labels = [1, 2]
encoding = processor(image, words, boxes=boxes, word_labels=word_labels, return_tensors="pt")
print(encoding.keys())
# dict_keys(['input_ids', 'token_type_ids', 'attention_mask', 'bbox', 'labels', 'image'])

使用案例 4：视觉问答（推理），apply_ocr=True

对于视觉问答任务（如 DocVQA），您可以向处理器提供问题。默认情况下，处理器将在图像上应用 OCR，并创建[CLS]问题标记[SEP]单词标记[SEP]。

from transformers import LayoutLMv2Processor
from PIL import Image

processor = LayoutLMv2Processor.from_pretrained("microsoft/layoutlmv2-base-uncased")

image = Image.open(
    "name_of_your_document - can be a png, jpg, etc. of your documents (PDFs must be converted to images)."
).convert("RGB")
question = "What's his name?"
encoding = processor(image, question, return_tensors="pt")
print(encoding.keys())
# dict_keys(['input_ids', 'token_type_ids', 'attention_mask', 'bbox', 'image'])

使用案例 5：视觉问答（推理），apply_ocr=False

对于视觉问答任务（如 DocVQA），您可以向处理器提供问题。如果您想自己执行 OCR，可以向处理器提供自己的单词和（标准化的）边界框。

from transformers import LayoutLMv2Processor
from PIL import Image

processor = LayoutLMv2Processor.from_pretrained("microsoft/layoutlmv2-base-uncased", revision="no_ocr")

image = Image.open(
    "name_of_your_document - can be a png, jpg, etc. of your documents (PDFs must be converted to images)."
).convert("RGB")
question = "What's his name?"
words = ["hello", "world"]
boxes = [[1, 2, 3, 4], [5, 6, 7, 8]]  # make sure to normalize your bounding boxes
encoding = processor(image, question, words, boxes=boxes, return_tensors="pt")
print(encoding.keys())
# dict_keys(['input_ids', 'token_type_ids', 'attention_mask', 'bbox', 'image'])

LayoutLMv2Config

class transformers.LayoutLMv2Config

<来源>

( vocab_size = 30522 hidden_size = 768 num_hidden_layers = 12 num_attention_heads = 12 intermediate_size = 3072 hidden_act = 'gelu' hidden_dropout_prob = 0.1 attention_probs_dropout_prob = 0.1 max_position_embeddings = 512 type_vocab_size = 2 initializer_range = 0.02 layer_norm_eps = 1e-12 pad_token_id = 0 max_2d_position_embeddings = 1024 max_rel_pos = 128 rel_pos_bins = 32 fast_qkv = True max_rel_2d_pos = 256 rel_2d_pos_bins = 64 convert_sync_batchnorm = True image_feature_pool_shape = [7, 7, 256] coordinate_size = 128 shape_size = 128 has_relative_attention_bias = True has_spatial_attention_bias = True has_visual_segment_embedding = False detectron2_config_args = None **kwargs )

参数

• vocab_size（int，可选，默认为 30522）—LayoutLMv2 模型的词汇量。定义了在调用 LayoutLMv2Model 或TFLayoutLMv2Model时可以表示的不同标记数量。

• hidden_size（int，可选，默认为 768）—编码器层和池化器层的维度。

• num_hidden_layers（int，可选，默认为 12）—变换器编码器中的隐藏层数量。

• num_attention_heads（int，可选，默认为 12）—变换器编码器中每个注意力层的注意力头数量。

• intermediate_size（int，可选，默认为 3072）—变换器编码器中“中间”（即前馈）层的维度。

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

• hidden_dropout_prob（float，可选，默认为 0.1）—嵌入层、编码器和池化器中所有全连接层的 dropout 概率。

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

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

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

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

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

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

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

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

• fast_qkv (bool, optional, 默认为True) — 是否在自注意力层中使用单个矩阵作为查询、键、值。

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

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

• image_feature_pool_shape (List[int], optional, 默认为[7, 7, 256]) — 平均池化特征图的形状。

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

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

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

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

• has_visual_segment_embedding (bool, optional, 默认为False) — 是否添加视觉段嵌入。

• detectron2_config_args (dict, optional) — 包含 Detectron2 视觉骨干配置参数的字典。有关默认值的详细信息，请参阅此文件。

这是用于存储 LayoutLMv2Model 配置的配置类。它用于根据指定的参数实例化一个 LayoutLMv2 模型，定义模型架构。使用默认值实例化配置将产生类似于 LayoutLMv2 microsoft/layoutlmv2-base-uncased架构的配置。

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

示例:

>>> from transformers import LayoutLMv2Config, LayoutLMv2Model

>>> # Initializing a LayoutLMv2 microsoft/layoutlmv2-base-uncased style configuration
>>> configuration = LayoutLMv2Config()

>>> # Initializing a model (with random weights) from the microsoft/layoutlmv2-base-uncased style configuration
>>> model = LayoutLMv2Model(configuration)

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

LayoutLMv2FeatureExtractor

class transformers.LayoutLMv2FeatureExtractor

<来源>

( *args **kwargs )

__call__

<来源>

( images **kwargs )

预处理图像或一批图像。

LayoutLMv2ImageProcessor

class transformers.LayoutLMv2ImageProcessor

<来源>

( do_resize: bool = True size: Dict = None resample: Resampling = <Resampling.BILINEAR: 2> apply_ocr: bool = True ocr_lang: Optional = None tesseract_config: Optional = '' **kwargs )

参数

• do_resize (bool, 可选, 默认为 True) — 是否将图像的 (height, width) 尺寸调整为 (size["height"], size["width"])。可以被 preprocess 中的 do_resize 覆盖。

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

• resample (PILImageResampling, 可选, 默认为 Resampling.BILINEAR) — 用于调整图像大小时使用的重采样滤波器。可以被 preprocess 方法中的 resample 参数覆盖。

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

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

• tesseract_config (str, 可选, 默认为 "") — 转发到调用 Tesseract 时 config 参数的任何额外自定义配置标志。例如: ‘—psm 6’。可以被 preprocess 中的 tesseract_config 覆盖。

构建一个 LayoutLMv2 图像处理器。

preprocess

<来源>

( images: Union do_resize: bool = None size: Dict = None resample: Resampling = None apply_ocr: bool = None ocr_lang: Optional = None tesseract_config: Optional = None return_tensors: Union = None data_format: ChannelDimension = <ChannelDimension.FIRST: 'channels_first'> input_data_format: Union = None **kwargs )

参数

• images (ImageInput) — 要预处理的图像。

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

• size (Dict[str, int], 可选, 默认为 self.size) — 调整大小后输出图像的期望尺寸。

• resample (PILImageResampling, 可选, 默认为 self.resample) — 用于调整图像大小时使用的重采样滤波器。可以是枚举 PIL.Image 重采样滤波器之一。仅在 do_resize 设置为 True 时有效。

• apply_ocr (bool, 可选, 默认为 self.apply_ocr) — 是否应用 Tesseract OCR 引擎以获取单词 + 规范化边界框。

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

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

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

  • 未设置: 返回一个 np.ndarray 列表。

  • TensorType.TENSORFLOW 或 'tf': 返回类型为 tf.Tensor 的批处理。

  • TensorType.PYTORCH 或 'pt': 返回类型为 torch.Tensor 的批处理。

  • TensorType.NUMPY 或 'np': 返回类型为 np.ndarray 的批处理。

  • TensorType.JAX 或 'jax': 返回类型为 jax.numpy.ndarray 的批处理。

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

  • ChannelDimension.FIRST: 图像格式为 (num_channels, height, width)。

  • ChannelDimension.LAST: 图像格式为 (height, width, num_channels)。

预处理图像或一批图像。

LayoutLMv2Tokenizer

class transformers.LayoutLMv2Tokenizer

<来源>

( vocab_file do_lower_case = True do_basic_tokenize = True never_split = None unk_token = '[UNK]' sep_token = '[SEP]' pad_token = '[PAD]' cls_token = '[CLS]' mask_token = '[MASK]' cls_token_box = [0, 0, 0, 0] sep_token_box = [1000, 1000, 1000, 1000] pad_token_box = [0, 0, 0, 0] pad_token_label = -100 only_label_first_subword = True tokenize_chinese_chars = True strip_accents = None model_max_length: int = 512 additional_special_tokens: Optional = None **kwargs )

构建一个 LayoutLMv2 分词器。基于 WordPiece。LayoutLMv2Tokenizer 可用于将单词、单词级边界框和可选单词标签转换为标记级的 input_ids、attention_mask、token_type_ids、bbox 和可选的 labels（用于标记分类）。

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

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

__call__

< source >

( text: Union text_pair: Union = None boxes: Union = None word_labels: Union = None add_special_tokens: bool = True padding: Union = False truncation: Union = None max_length: Optional = None stride: int = 0 pad_to_multiple_of: Optional = None 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，可选，默认为 0）— 如果与max_length一起设置为一个数字，则当return_overflowing_tokens=True时返回的溢出令牌将包含截断序列末尾的一些令牌，以提供截断和溢出序列之间的一些重叠。此参数的值定义重叠令牌的数量。

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

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

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

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

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

• return_token_type_ids（bool，可选）— 是否返回令牌类型 ID。如果保持默认设置，将根据特定分词器的默认值返回令牌类型 ID，由return_outputs属性定义。

  令牌类型 ID 是什么？

• return_attention_mask（bool，可选）— 是否返回注意力蒙版。如果保持默认设置，将根据特定分词器的默认值返回注意力蒙版，由return_outputs属性定义。

  注意力蒙版是什么？

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

• return_special_tokens_mask（bool，可选，默认为False）— 是否返回特殊令牌蒙版信息。

• return_offsets_mapping（bool，可选，默认为False）— 是否返回每个令牌的(char_start, char_end)。

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

• return_length（bool，可选，默认为False）— 是否返回编码输入的长度。

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

返回

BatchEncoding

具有以下字段的 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时）。

对一个或多个序列或一个或多个序列对进行标记化和为模型准备，具有单词级别标准化边界框和可选标签。

save_vocabulary

<来源>

( save_directory: str filename_prefix: Optional = None )

LayoutLMv2TokenizerFast

class transformers.LayoutLMv2TokenizerFast

<来源>

( vocab_file = None tokenizer_file = None do_lower_case = True unk_token = '[UNK]' sep_token = '[SEP]' pad_token = '[PAD]' cls_token = '[CLS]' mask_token = '[MASK]' cls_token_box = [0, 0, 0, 0] sep_token_box = [1000, 1000, 1000, 1000] pad_token_box = [0, 0, 0, 0] pad_token_label = -100 only_label_first_subword = True tokenize_chinese_chars = True strip_accents = None **kwargs )

参数

• vocab_file (str) — 包含词汇表的文件。

• do_lower_case (bool, optional, defaults to 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]") — 用于屏蔽值的标记。在使用掩码语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。

• 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) — 是否仅标记第一个子词，如果提供了单词标签。

• tokenize_chinese_chars (bool, optional, defaults to True) — 是否标记化中文字符。这可能应该在日语中停用（参见此问题）。

• strip_accents (bool, optional) — 是否去除所有重音符号。如果未指定此选项，则将由lowercase的值确定（与原始 LayoutLMv2 中的情况相同）。

构建一个“快速”LayoutLMv2 分词器（由 HuggingFace 的tokenizers库支持）。基于 WordPiece。

此分词器继承自 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]], optional) — 单词级别的整数标签（用于诸如 FUNSD、CORD 等标记分类任务）。

• add_special_tokens (bool, optional, 默认为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指定的最大长度，或者如果未提供该参数，则截断到模型的最大可接受输入长度。这将逐标记截断，如果提供了一对序列（或一批序列），则从较长序列中删除一个标记。

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

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

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

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

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

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

• return_token_type_ids（bool，可选）— 是否返回令牌类型 ID。如果保持默认设置，将根据特定分词器的默认设置返回令牌类型 ID，由return_outputs属性定义。

  什么是令牌类型 ID？

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

  什么是注意力掩码？

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

• return_special_tokens_mask（bool，可选，默认为False）— 是否返回特殊令牌掩码信息。

• return_offsets_mapping（bool，可选，默认为False）— 是否返回每个令牌的(char_start, char_end)。

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

• return_length（bool，可选，默认为False）— 是否返回编码输入的长度。

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

返回

BatchEncoding

一个带有以下字段的 BatchEncoding：

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

  什么是输入 ID？

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

• token_type_ids — 要提供给模型的令牌类型 id 列表（当return_token_type_ids=True或者self.model_input_names中包含token_type_ids时）。

  什么是令牌类型 ID？

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

  什么是注意力掩码？

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

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

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

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

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

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

LayoutLMv2Processor

class transformers.LayoutLMv2Processor

<来源>

( image_processor = None tokenizer = None **kwargs )

参数

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

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

构建一个 LayoutLMv2 处理器，将 LayoutLMv2 图像处理器和 LayoutLMv2 标记器合并为一个单一处理器。

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

它首先使用 LayoutLMv2ImageProcessor 将文档图像调整为固定大小，并可选择应用 OCR 以获取单词和归一化边界框。然后将它们提供给 LayoutLMv2Tokenizer 或 LayoutLMv2TokenizerFast，将单词和边界框转换为标记级别的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 = False max_length: Optional = None stride: int = 0 pad_to_multiple_of: Optional = None return_token_type_ids: Optional = None return_attention_mask: Optional = None return_overflowing_tokens: bool = False return_special_tokens_mask: bool = False return_offsets_mapping: bool = False return_length: bool = False verbose: bool = True return_tensors: Union = None **kwargs )

此方法首先将images参数转发到call()。如果 LayoutLMv2ImageProcessor 初始化时apply_ocr设置为True，它将获取的单词和边界框连同其他参数传递给call()并返回输出，以及调整大小后的images。如果 LayoutLMv2ImageProcessor 初始化时apply_ocr设置为False，它将用户指定的单词（text/text_pair）和boxes连同其他参数传递给 call()并返回输出，以及调整大小后的images。

请参考上述两个方法的文档字符串以获取更多信息。

LayoutLMv2Model

class transformers.LayoutLMv2Model

<来源>

( config )

参数

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

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

forward

< source >

( input_ids: Optional = None bbox: Optional = None image: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None 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, 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)表示右下角的位置。

• image (torch.FloatTensor of shape (batch_size, num_channels, height, width) 或 detectron.structures.ImageList，其tensors的形状为(batch_size, num_channels, height, width)) — 文档图像的批处理。

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

  • 1 对于未被masked的标记，

  • 对于被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 而不是普通元组。

返回

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

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

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

• hidden_states (tuple(torch.FloatTensor), 可选的, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(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 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoProcessor, LayoutLMv2Model, set_seed
>>> from PIL import Image
>>> import torch
>>> from datasets import load_dataset

>>> set_seed(88)

>>> processor = AutoProcessor.from_pretrained("microsoft/layoutlmv2-base-uncased")
>>> model = LayoutLMv2Model.from_pretrained("microsoft/layoutlmv2-base-uncased")

>>> dataset = load_dataset("hf-internal-testing/fixtures_docvqa")
>>> image_path = dataset["test"][0]["file"]
>>> image = Image.open(image_path).convert("RGB")

>>> encoding = processor(image, return_tensors="pt")

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

>>> last_hidden_states.shape
torch.Size([1, 342, 768])

LayoutLMv2ForSequenceClassification

class transformers.LayoutLMv2ForSequenceClassification

<来源>

( config )

参数

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

LayoutLMv2 模型，顶部带有一个序列分类头（在[CLS]标记的最终隐藏状态、平均池化的初始视觉嵌入和平均池化的最终视觉嵌入的串联之上的线性层，例如用于文档图像分类任务，如RVL-CDIP数据集。

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

forward

<来源>

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

参数

• input_ids (torch.LongTensor，形状为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) 表示右下角的位置。

• image (torch.FloatTensor of shape (batch_size, num_channels, height, width) 或 detectron.structures.ImageList，其 tensors 的形状为 (batch_size, num_channels, height, width)) — 文档图像的批处理。

• 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 而不是普通元组。

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

返回

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

一个 transformers.modeling_outputs.SequenceClassifierOutput 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时）包含根据配置（LayoutLMv2Config）和输入而异的各种元素。

• loss (torch.FloatTensor of shape (1,), optional, 当提供 labels 时返回) — 分类（或如果 config.num_labels==1 则为回归）损失。

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

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

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

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

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

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

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

示例：

>>> from transformers import AutoProcessor, LayoutLMv2ForSequenceClassification, set_seed
>>> from PIL import Image
>>> import torch
>>> from datasets import load_dataset

>>> set_seed(88)

>>> dataset = load_dataset("rvl_cdip", split="train", streaming=True)
>>> data = next(iter(dataset))
>>> image = data["image"].convert("RGB")

>>> processor = AutoProcessor.from_pretrained("microsoft/layoutlmv2-base-uncased")
>>> model = LayoutLMv2ForSequenceClassification.from_pretrained(
...     "microsoft/layoutlmv2-base-uncased", num_labels=dataset.info.features["label"].num_classes
... )

>>> encoding = processor(image, return_tensors="pt")
>>> sequence_label = torch.tensor([data["label"]])

>>> outputs = model(**encoding, labels=sequence_label)

>>> loss, logits = outputs.loss, outputs.logits
>>> predicted_idx = logits.argmax(dim=-1).item()
>>> predicted_answer = dataset.info.features["label"].names[4]
>>> predicted_idx, predicted_answer
(4, 'advertisement')

LayoutLMv2ForTokenClassification

class transformers.LayoutLMv2ForTokenClassification

<来源>

( config )

参数

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

在 LayoutLMv2 模型的顶部具有标记分类头部（隐藏状态的文本部分上的线性层）的模型，例如用于序列标记（信息提取）任务的FUNSD、SROIE、CORD和Kleister-NDA。

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

forward

<来源>

( input_ids: Optional = None bbox: Optional = None image: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.TokenClassifierOutput 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)表示右下角的位置。

• image（torch.FloatTensor，形状为(batch_size, num_channels, height, width)或detectron.structures.ImageList，其tensors形状为(batch_size, num_channels, height, width)）— 批量文档图像。

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

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

  • 对于被masked的标记为 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 表示头部未被masked。

  • 0 表示头部被masked。

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

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

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

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

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

返回

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

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

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

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

• hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回）— 形状为(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 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoProcessor, LayoutLMv2ForTokenClassification, set_seed
>>> from PIL import Image
>>> from datasets import load_dataset

>>> set_seed(88)

>>> datasets = load_dataset("nielsr/funsd", split="test")
>>> labels = datasets.features["ner_tags"].feature.names
>>> id2label = {v: k for v, k in enumerate(labels)}

>>> processor = AutoProcessor.from_pretrained("microsoft/layoutlmv2-base-uncased", revision="no_ocr")
>>> model = LayoutLMv2ForTokenClassification.from_pretrained(
...     "microsoft/layoutlmv2-base-uncased", num_labels=len(labels)
... )

>>> data = datasets[0]
>>> image = Image.open(data["image_path"]).convert("RGB")
>>> words = data["words"]
>>> boxes = data["bboxes"]  # make sure to normalize your bounding boxes
>>> word_labels = data["ner_tags"]
>>> encoding = processor(
...     image,
...     words,
...     boxes=boxes,
...     word_labels=word_labels,
...     padding="max_length",
...     truncation=True,
...     return_tensors="pt",
... )

>>> outputs = model(**encoding)
>>> logits, loss = outputs.logits, outputs.loss

>>> predicted_token_class_ids = logits.argmax(-1)
>>> predicted_tokens_classes = [id2label[t.item()] for t in predicted_token_class_ids[0]]
>>> predicted_tokens_classes[:5]
['B-ANSWER', 'B-HEADER', 'B-HEADER', 'B-HEADER', 'B-HEADER']

LayoutLMv2ForQuestionAnswering

class transformers.LayoutLMv2ForQuestionAnswering

<来源>

( config has_visual_segment_embedding = True )

参数

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

LayoutLMv2 模型，在其顶部具有用于提取问答任务的跨度分类头，例如DocVQA（在隐藏状态输出的文本部分顶部的线性层，用于计算跨度起始对数和跨度结束对数）。

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

forward

<来源>

( input_ids: Optional = None bbox: Optional = None image: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None 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（形状为(batch_size, sequence_length, 4)的torch.LongTensor，可选） — 每个输入序列标记的边界框。在范围[0, config.max_2d_position_embeddings-1]中选择。每个边界框应该是(x0, y0, x1, y1)格式的归一化版本，其中(x0, y0)对应于边界框左上角的位置，而(x1, y1)表示边界框右下角的位置。

• image（形状为(batch_size, num_channels, height, width)的torch.FloatTensor或detectron.structures.ImageList，其tensors的形状为(batch_size, num_channels, height, width)） — 文档图像的批处理。

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

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

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

  什么是注意力蒙版？

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

  • 0 对应于句子 A的标记，

  • 1 对应于 句子 B 标记。

  什么是标记类型 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 表示头部未被masked，

  • 0 表示头部被masked。

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

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

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

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

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

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

返回

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

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

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

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

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

• hidden_states (tuple(torch.FloatTensor)，可选，当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回） — 形状为 (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 之后，用于计算自注意力头中的加权平均值。

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

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

示例：

在下面的示例中，我们给 LayoutLMv2 模型一个图像（包含文本）并向其提问。它会给出一个预测，即它认为答案在从图像中解析的文本中的位置。

>>> from transformers import AutoProcessor, LayoutLMv2ForQuestionAnswering, set_seed
>>> import torch
>>> from PIL import Image
>>> from datasets import load_dataset

>>> set_seed(88)
>>> processor = AutoProcessor.from_pretrained("microsoft/layoutlmv2-base-uncased")
>>> model = LayoutLMv2ForQuestionAnswering.from_pretrained("microsoft/layoutlmv2-base-uncased")

>>> dataset = load_dataset("hf-internal-testing/fixtures_docvqa")
>>> image_path = dataset["test"][0]["file"]
>>> image = Image.open(image_path).convert("RGB")
>>> question = "When is coffee break?"
>>> encoding = processor(image, question, return_tensors="pt")

>>> outputs = model(**encoding)
>>> predicted_start_idx = outputs.start_logits.argmax(-1).item()
>>> predicted_end_idx = outputs.end_logits.argmax(-1).item()
>>> predicted_start_idx, predicted_end_idx
(154, 287)

>>> predicted_answer_tokens = encoding.input_ids.squeeze()[predicted_start_idx : predicted_end_idx + 1]
>>> predicted_answer = processor.tokenizer.decode(predicted_answer_tokens)
>>> predicted_answer  # results are not very good without further fine-tuning
'council mem - bers conducted by trrf treasurer philip g. kuehn to get answers which the public ...

>>> target_start_index = torch.tensor([7])
>>> target_end_index = torch.tensor([14])
>>> outputs = model(**encoding, start_positions=target_start_index, end_positions=target_end_index)
>>> predicted_answer_span_start = outputs.start_logits.argmax(-1).item()
>>> predicted_answer_span_end = outputs.end_logits.argmax(-1).item()
>>> predicted_answer_span_start, predicted_answer_span_end
(154, 287)