Pix2Struct

概述

Pix2Struct 模型在 Pix2Struct: Screenshot Parsing as Pretraining for Visual Language Understanding 中被提出，作者是 Kenton Lee, Mandar Joshi, Iulia Turc, Hexiang Hu, Fangyu Liu, Julian Eisenschlos, Urvashi Khandelwal, Peter Shaw, Ming-Wei Chang, Kristina Toutanova。

论文的摘要如下：

视觉情境化的语言无处不在——来源包括带有图表的教科书、带有图像和表格的网页，以及带有按钮和表单的移动应用程序。也许是由于这种多样性，以往的工作通常依赖于特定领域的方案，对底层数据、模型架构和目标的共享有限。我们提出了 Pix2Struct，一个用于纯视觉语言理解的预训练图像到文本模型，可以在包含视觉情境化语言的任务上进行微调。Pix2Struct 通过学习将网页的屏蔽截图解析为简化的 HTML 进行预训练。网络及其丰富的视觉元素清晰地反映在 HTML 结构中，为预训练数据提供了大量的来源，非常适合下游任务的多样性。直观地说，这个目标包含了常见的预训练信号，如 OCR、语言建模、图像描述。除了新颖的预训练策略外，我们还引入了可变分辨率的输入表示和语言和视觉输入更灵活的集成，其中诸如问题之类的语言提示直接呈现在输入图像的顶部。我们首次展示了单个预训练模型可以在跨四个领域的九个任务中的六个任务中实现最先进的结果：文档、插图、用户界面和自然图像。

提示

Pix2Struct 已经在各种任务和数据集上进行了微调，范围从图像描述、不同输入（书籍、图表、科学图表）上的视觉问答 (VQA)、UI 组件描述等等。完整列表可以在论文的表 1 中找到。因此，我们建议您将这些模型用于它们已经微调的任务。例如，如果您想将 Pix2Struct 用于 UI 描述，您应该使用在 UI 数据集上微调的模型。如果您想将 Pix2Struct 用于图像描述，您应该使用在自然图像描述数据集上微调的模型，依此类推。

如果您想使用该模型执行条件文本描述，请确保使用处理器时 add_special_tokens=False。

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

资源

Pix2StructConfig

class transformers.Pix2StructConfig

< source >

( text_config = None vision_config = None initializer_factor = 1.0 initializer_range = 0.02 is_vqa = False tie_word_embeddings = False is_encoder_decoder = True **kwargs )

参数

text_config (dict, 可选) — 用于初始化 Pix2StructTextConfig 的配置选项字典。
vision_config (dict, 可选) — 用于初始化 Pix2StructVisionConfig 的配置选项字典。
initializer_factor (float, 可选, 默认为 1.0) — 初始化范围的乘法因子。
initializer_range (float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
is_vqa (bool, 可选, 默认为 False) — 模型是否已针对 VQA 进行微调。
kwargs (可选) — 关键字参数字典。

Pix2StructConfig 是用于存储 Pix2StructForConditionalGeneration 配置的配置类。它用于根据指定的参数实例化 Pix2Struct 模型，定义文本模型和视觉模型配置。使用默认值实例化配置将产生与 Pix2Struct-base google/pix2struct-base 架构类似的配置。

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

示例

>>> from transformers import Pix2StructConfig, Pix2StructForConditionalGeneration

>>> # Initializing a Pix2StructConfig with google/pix2struct-base style configuration
>>> configuration = Pix2StructConfig()

>>> # Initializing a Pix2StructForConditionalGeneration (with random weights) from the google/pix2struct-base style configuration
>>> model = Pix2StructForConditionalGeneration(configuration)

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

>>> # We can also initialize a Pix2StructConfig from a Pix2StructTextConfig and a Pix2StructVisionConfig

>>> # Initializing a Pix2Struct text and Pix2Struct vision configuration
>>> config_text = Pix2StructTextConfig()
>>> config_vision = Pix2StructVisionConfig()

>>> config = Pix2StructConfig.from_text_vision_configs(config_text, config_vision)

from_text_vision_configs

< source >

( text_config: Pix2StructTextConfig vision_config: Pix2StructVisionConfig **kwargs ) → Pix2StructConfig

返回 (Returns)

Pix2StructConfig

配置对象的实例 (An instance of a configuration object)

从 pix2struct 文本模型配置和 pix2struct 视觉模型配置实例化 Pix2StructConfig (或派生类)。(Instantiate a Pix2StructConfig (or a derived class) from pix2struct text model configuration and pix2struct vision model configuration.)

Pix2StructTextConfig

class transformers.Pix2StructTextConfig

< source >

( vocab_size = 50244 hidden_size = 768 d_kv = 64 d_ff = 2048 num_layers = 12 num_heads = 12 relative_attention_num_buckets = 32 relative_attention_max_distance = 128 dropout_rate = 0.1 layer_norm_epsilon = 1e-06 initializer_factor = 1.0 dense_act_fn = 'gelu_new' decoder_start_token_id = 0 use_cache = False pad_token_id = 0 eos_token_id = 1 tie_word_embeddings = False is_decoder = True **kwargs )

参数

vocab_size (int, 可选, 默认为 50244) — Pix2Struct 文本模型的词汇表大小。定义了在调用 Pix2StructTextModel 时传递的 inputs_ids 可以表示的不同 token 的数量。(Vocabulary size of the Pix2Struct text model. Defines the number of different tokens that can be represented by the inputs_ids passed when calling Pix2StructTextModel.)
hidden_size (int, 可选, 默认为 768) — 编码器层和池化器层的维度。(Dimensionality of the encoder layers and the pooler layer.)
d_kv (int, 可选, 默认为 64) — 每个注意力头中键 (key)、查询 (query)、值 (value) 投影的维度。(Dimensionality of the key, query, value projections in each attention head.)
d_ff (int, 可选, 默认为 2048) — Transformer 编码器中“中间” (即，前馈) 层的维度。(Dimensionality of the “intermediate” (i.e., feed-forward) layer in the Transformer encoder.)
num_layers (int, 可选, 默认为 12) — Transformer 编码器中隐藏层的数量。(Number of hidden layers in the Transformer encoder.)
num_heads (int, 可选, 默认为 12) — Transformer 编码器中每个注意力层的注意力头数。(Number of attention heads for each attention layer in the Transformer encoder.)
relative_attention_num_buckets (int, 可选, 默认为 32) — 每个注意力层要使用的 bucket 数量。(The number of buckets to use for each attention layer.)
relative_attention_max_distance (int, 可选, 默认为 128) — 用于 bucket 分离的较长序列的最大距离。(The maximum distance of the longer sequences for the bucket separation.)
dropout_rate (float, 可选, 默认为 0.1) — 嵌入层、编码器和池化器中所有全连接层的 dropout 概率。(The dropout probability for all fully connected layers in the embeddings, encoder, and pooler.)
layer_norm_epsilon (float, 可选, 默认为 1e-6) — 层归一化层使用的 epsilon 值。(The epsilon used by the layer normalization layers.)
initializer_factor (float, 可选, 默认为 1.0) — 用于初始化所有权重矩阵的因子 (应保持为 1，内部用于初始化测试)。(A factor for initializing all weight matrices (should be kept to 1, used internally for initialization testing).)
dense_act_fn (Union[Callable, str], 可选, 默认为 "gelu_new") — 非线性激活函数 (函数或字符串)。(The non-linear activation function (function or string).)
decoder_start_token_id (int, 可选, 默认为 0) — decoder_start_token_id token 的 id。(The id of the decoder_start_token_id token.)
use_cache (bool, 可选, 默认为 False) — 模型是否应返回最后的键/值注意力 (并非所有模型都使用)。(Whether or not the model should return the last key/values attentions (not used by all models).)
pad_token_id (int, 可选, 默认为 0) — padding token 的 id。(The id of the padding token.)
eos_token_id (int, 可选, 默认为 1) — end-of-sequence token 的 id。(The id of the end-of-sequence token.)

这是用于存储 Pix2StructTextModel 配置的配置类。它用于根据指定的参数实例化 Pix2Struct 文本模型，定义模型架构。使用默认值实例化配置将产生与 google/pix2struct-base 架构使用的 Pix2Struct 文本解码器类似的配置。(This is the configuration class to store the configuration of a Pix2StructTextModel. It is used to instantiate a Pix2Struct text model according to the specified arguments, defining the model architecture. Instantiating a configuration with the defaults will yield a similar configuration to that of the Pix2Struct text decoder used by the google/pix2struct-base architecture.)

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

示例

>>> from transformers import Pix2StructTextConfig, Pix2StructTextModel

>>> # Initializing a Pix2StructTextConfig with google/pix2struct-base style configuration
>>> configuration = Pix2StructTextConfig()

>>> # Initializing a Pix2StructTextModel (with random weights) from the google/pix2struct-base style configuration
>>> model = Pix2StructTextModel(configuration)

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

Pix2StructVisionConfig

class transformers.Pix2StructVisionConfig

< source >

( hidden_size = 768 patch_embed_hidden_size = 768 d_ff = 2048 d_kv = 64 num_hidden_layers = 12 num_attention_heads = 12 dense_act_fn = 'gelu_new' layer_norm_eps = 1e-06 dropout_rate = 0.0 attention_dropout = 0.0 initializer_range = 1e-10 initializer_factor = 1.0 seq_len = 4096 relative_attention_num_buckets = 32 relative_attention_max_distance = 128 **kwargs )

参数

hidden_size (int, 可选, 默认为 768) — 编码器层和池化器层的维度。(Dimensionality of the encoder layers and the pooler layer.)
patch_embed_hidden_size (int, 可选, 默认为 768) — Transformer 编码器中输入 patch_embedding 层的维度。(Dimensionality of the input patch_embedding layer in the Transformer encoder.)
d_ff (int, 可选, 默认为 2048) — Transformer 编码器中“中间” (即，前馈) 层的维度。(Dimensionality of the “intermediate” (i.e., feed-forward) layer in the Transformer encoder.)
d_kv (int, 可选, 默认为 64) — 每个注意力头中键 (key)、查询 (query)、值 (value) 投影的维度。(Dimensionality of the key, query, value projections per attention head.)
num_hidden_layers (int, 可选, 默认为 12) — Transformer 编码器中隐藏层的数量。(Number of hidden layers in the Transformer encoder.)
num_attention_heads (int, 可选, 默认为 12) — Transformer 编码器中每个注意力层的注意力头数。(Number of attention heads for each attention layer in the Transformer encoder.)
dense_act_fn (str 或 function, 可选, 默认为 "gelu_new") — 编码器和池化器中的非线性激活函数 (函数或字符串)。如果是字符串，则支持 "gelu"、"relu"、"selu" 和 "gelu_new" "gelu"。(The non-linear activation function (function or string) in the encoder and pooler. If string, "gelu", "relu", "selu" and "gelu_new" "gelu" are supported.)
layer_norm_eps (float, optional, defaults to 1e-06) — 层归一化层使用的 epsilon 值。
dropout_rate (float, optional, defaults to 0.0) — 用于嵌入层、编码器和池化器中所有全连接层的 dropout 概率。
attention_dropout (float, optional, defaults to 0.0) — 注意力概率的 dropout 比率。
initializer_range (float, optional, defaults to 1e-10) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
initializer_factor (float, optional, defaults to 1.0) — 用于初始化所有权重矩阵的因子（应保持为 1，内部用于初始化测试）。
seq_len (int, optional, defaults to 4096) — 模型支持的最大序列长度（此处为图像块的数量）。
relative_attention_num_buckets (int, optional, defaults to 32) — 每个注意力层要使用的 bucket 数量。
relative_attention_max_distance (int, optional, defaults to 128) — 每个注意力层要使用的最大距离（以 tokens 为单位）。

这是用于存储 Pix2StructVisionModel 配置的配置类。它用于根据指定的参数实例化 Pix2Struct 视觉模型，定义模型架构。实例化默认配置将产生与 Pix2Struct-base google/pix2struct-base 架构类似的配置。

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

示例

>>> from transformers import Pix2StructVisionConfig, Pix2StructVisionModel

>>> # Initializing a Pix2StructVisionConfig with google/pix2struct-base style configuration
>>> configuration = Pix2StructVisionConfig()

>>> # Initializing a Pix2StructVisionModel (with random weights) from the google/pix2struct-base style configuration
>>> model = Pix2StructVisionModel(configuration)

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

Pix2StructProcessor

class transformers.Pix2StructProcessor

< source >

( image_processor tokenizer )

参数

image_processor (Pix2StructImageProcessor) — Pix2StructImageProcessor 的实例。图像处理器是必需的输入。
tokenizer (Union[T5TokenizerFast, T5Tokenizer]) — [‘T5TokenizerFast`] 或 [‘T5Tokenizer`] 的实例。分词器是必需的输入。

构建一个 PIX2STRUCT 处理器，它将 BERT 分词器和 PIX2STRUCT 图像处理器封装到单个处理器中。

Pix2StructProcessor 提供 Pix2StructImageProcessor 和 T5TokenizerFast 的所有功能。有关更多信息，请参阅 __call__() 和 decode() 的文档字符串。

batch_decode

< source >

( *args **kwargs )

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

decode

< source >

( *args **kwargs )

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

Pix2StructImageProcessor

class transformers.Pix2StructImageProcessor

< source >

( do_convert_rgb: bool = True do_normalize: bool = True patch_size: typing.Dict[str, int] = None max_patches: int = 2048 is_vqa: bool = False **kwargs )

参数

do_convert_rgb (bool, optional, defaults to True) — 是否将图像转换为 RGB 格式。
do_normalize (bool, optional, defaults to True) — 是否对图像进行归一化。可以被 preprocess 方法中的 do_normalize 参数覆盖。根据 Pix2Struct 论文和代码，图像使用其自身的均值和标准差进行归一化。
patch_size (Dict[str, int], optional, defaults to {"height" -- 16, "width": 16}): 用于图像的图像块大小。根据 Pix2Struct 论文和代码，图像块大小为 16x16。
max_patches (int, optional, defaults to 2048) — 根据 Pix2Struct 论文，从图像中提取的最大图像块数量。
is_vqa (bool, optional, defaults to False) — 图像处理器是否用于 VQA 任务。如果为 True 且传入了 header_text，则文本将渲染到输入图像上。

构建 Pix2Struct 图像处理器。

preprocess

< source >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']] header_text: typing.Optional[str] = None do_convert_rgb: bool = None do_normalize: typing.Optional[bool] = None max_patches: typing.Optional[int] = None patch_size: typing.Optional[typing.Dict[str, int]] = None return_tensors: typing.Union[str, transformers.utils.generic.TensorType, NoneType] = None data_format: ChannelDimension = <ChannelDimension.FIRST: 'channels_first'> input_data_format: typing.Union[str, transformers.image_utils.ChannelDimension, NoneType] = None **kwargs )

参数

images (ImageInput) — 要预处理的图像。接受单个或一批图像。
header_text (Union[List[str], str], 可选) — 要渲染为标题的文本。仅当 image_processor.is_vqa 为 True 时有效。
do_convert_rgb (bool, 可选, 默认为 self.do_convert_rgb) — 是否将图像转换为 RGB 格式。
do_normalize (bool, 可选, 默认为 self.do_normalize) — 是否标准化图像。
max_patches (int, 可选, 默认为 self.max_patches) — 要提取的最大 patch 数量。
patch_size (dict, 可选, 默认为 self.patch_size) — 包含 patch 高度和宽度的字典。
return_tensors (str 或 TensorType, 可选) — 返回的张量类型。可以是以下之一：
- Unset: 返回 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) — 输出图像的通道维度格式。可以是以下之一：
- "channels_first" 或 ChannelDimension.FIRST: 图像格式为 (num_channels, height, width)。
- "channels_last" 或 ChannelDimension.LAST: 图像格式为 (height, width, num_channels)。
- Unset: 使用输入图像的通道维度格式。
input_data_format (ChannelDimension 或 str, 可选) — 输入图像的通道维度格式。如果未设置，则通道维度格式将从输入图像中推断。可以是以下之一：
- "channels_first" 或 ChannelDimension.FIRST: 图像格式为 (num_channels, height, width)。
- "channels_last" 或 ChannelDimension.LAST: 图像格式为 (height, width, num_channels)。
- "none" 或 ChannelDimension.NONE: 图像格式为 (height, width)。

预处理图像或一批图像。处理器首先计算可以从图像中提取的、保持宽高比的尺寸为 patch_size 的最大 patch 数量。然后，它用零填充图像，使图像符合 max_patches 的约束。在提取 patch 之前，图像会按照 tensorflow 的 per_image_standardization 实现进行标准化 (https://tensorflowcn.cn/api_docs/python/tf/image/per_image_standardization)。

Pix2StructTextModel

class transformers.Pix2StructTextModel

< source >

( config )

参数

config (Union[Pix2StructConfig, Pix2StructTextConfig]) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法来加载模型权重。

Pix2Struct 的独立文本解码器

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

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

forward

< source >

( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.FloatTensor] = None encoder_hidden_states: typing.Optional[torch.FloatTensor] = None encoder_attention_mask: typing.Optional[torch.FloatTensor] = None inputs_embeds: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None cross_attn_head_mask: typing.Optional[torch.Tensor] = None past_key_values: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None labels: typing.Optional[torch.LongTensor] = None return_dict: typing.Optional[bool] = None cache_position: typing.Optional[torch.LongTensor] = None **kwargs ) → transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 或 tuple(torch.FloatTensor)

参数

input_ids (torch.LongTensor，形状为 (batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。Pix2StructText 是一个具有相对位置嵌入的模型，因此你应该能够在左右两侧填充输入。

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

什么是输入 IDs？

要了解有关如何为预训练准备 input_ids 的更多信息，请查看 Pix2StructText 训练。
attention_mask (torch.FloatTensor，形状为 (batch_size, sequence_length), 可选) — 掩码，以避免在 padding token 索引上执行注意力机制。掩码值在 [0, 1] 中选择：
- 1 表示 tokens 未被掩码，
- 0 表示 tokens 被掩码。
什么是注意力掩码？
decoder_input_ids (torch.LongTensor，形状为 (batch_size, target_sequence_length), 可选) — 词汇表中解码器输入序列 tokens 的索引。

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

什么是解码器输入 IDs？

Pix2StructText 使用 pad_token_id 作为 decoder_input_ids 生成的起始 token。如果使用 past_key_values，则可以选择仅输入最后一个 decoder_input_ids（那些没有将其过去键值状态提供给此模型的）（请参阅 past_key_values）。

要了解有关如何为预训练准备 decoder_input_ids 的更多信息，请查看 Pix2StructText 训练。
decoder_attention_mask (torch.BoolTensor，形状为 (batch_size, target_sequence_length), 可选) — 默认行为：生成一个忽略 decoder_input_ids 中 pad tokens 的张量。因果掩码也将默认使用。
head_mask (torch.FloatTensor，形状为 (num_heads,) 或 (num_layers, num_heads), 可选) — 掩码，用于 nullify 编码器中自注意力模块的选定 head。掩码值在 [0, 1] 中选择：
- 1 表示 head 未被掩码，
- 0 表示 head 被掩码。
decoder_head_mask (torch.FloatTensor，形状为 (num_heads,) 或 (num_layers, num_heads), 可选) — 掩码，用于 nullify 解码器中自注意力模块的选定 head。掩码值在 [0, 1] 中选择：
- 1 表示 head 未被掩码，
- 0 表示 head 被掩码。
cross_attn_head_mask (torch.Tensor，形状为 (num_heads,) 或 (num_layers, num_heads), 可选) — 掩码，用于 nullify 解码器中交叉注意力模块的选定 head。掩码值在 [0, 1] 中选择：
- 1 表示 head 未被掩码，
- 0 表示 head 被掩码。
encoder_outputs (tuple(tuple(torch.FloatTensor), 可选) — 元组由 (last_hidden_state, optional: hidden_states, optional: attentions) 组成。形状为 (batch_size, sequence_length, hidden_size) 的 last_hidden_state 是编码器最后一层的输出端的隐藏状态序列。在解码器的交叉注意力中使用。
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。
inputs_embeds (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size), 可选) — （可选）除了传递 input_ids 之外，你还可以选择直接传递嵌入表示。如果你希望比模型的内部嵌入查找矩阵更精确地控制如何将 input_ids 索引转换为关联的向量，这将非常有用。
decoder_inputs_embeds (torch.FloatTensor，形状 (batch_size, target_sequence_length, hidden_size)，可选) — (可选) 您可以选择直接传递嵌入表示，而不是传递 `decoder_input_ids`。如果使用了 `past_key_values`，则可以选择仅输入最后的 `decoder_inputs_embeds`（请参阅 `past_key_values`）。如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将 `decoder_input_ids` 索引转换为关联向量，这将非常有用。

如果 `decoder_input_ids` 和 `decoder_inputs_embeds` 均未设置，则 `decoder_inputs_embeds` 取 `inputs_embeds` 的值。
use_cache (bool，可选) — 如果设置为 `True`，则返回 `past_key_values` 键值状态，并可用于加速解码（请参阅 `past_key_values`）。
output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的 `attentions`。
output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的 `hidden_states`。
return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。
cache_position (形状为 `(sequence_length)` 的 `torch.LongTensor`，可选) — 索引，描述输入序列标记在序列中的位置。它用于在正确的位置更新缓存，并推断完整序列长度。

返回 (Returns)

transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 或 `tuple(torch.FloatTensor)`

一个 transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 或 `torch.FloatTensor` 的元组 (如果传递了 `return_dict=False` 或者当 `config.return_dict=False` 时)，包含各种元素，具体取决于配置 (Pix2StructConfig) 和输入。

loss (形状为 `(1,)` 的 `torch.FloatTensor`，可选，当提供 `labels` 时返回) — 语言建模损失 (用于下一个标记预测)。
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` 时返回) — `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 之后的注意力权重，用于计算自注意力头中的加权平均值。
cross_attentions (tuple(torch.FloatTensor)，可选，当传递 `output_attentions=True` 或当 `config.output_attentions=True` 时返回) — `torch.FloatTensor` 的元组 (每层一个)，形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。

交叉注意力 softmax 之后的交叉注意力权重，用于计算交叉注意力头中的加权平均值。
past_key_values (tuple(tuple(torch.FloatTensor))，可选，当传递 `use_cache=True` 或当 `config.use_cache=True` 时返回) — `torch.FloatTensor` 元组的元组，长度为 `config.n_layers`，如果模型在编码器-解码器设置中使用，则每个元组都包含自注意力和交叉注意力层的缓存键、值状态。仅当 `config.is_decoder = True` 时相关。

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

Pix2StructTextModel 前向方法，覆盖了 `__call__` 特殊方法。

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

示例

>>> from transformers import AutoProcessor, Pix2StructTextModel

>>> processor = AutoProcessor.from_pretrained("google/pix2struct-textcaps-base")
>>> model = Pix2StructTextModel.from_pretrained("google/pix2struct-textcaps-base")

>>> inputs = processor(text="Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)
>>> loss = outputs.loss

Pix2StructVisionModel

class transformers.Pix2StructVisionModel

< source >

( config: Pix2StructConfig )

参数

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

裸 Pix2StructVision 模型转换器输出原始隐藏状态，顶部没有任何特定的头。此模型是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参阅 PyTorch 文档以了解与常规用法和行为相关的所有事项。

forward

< source >

( flattened_patches: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.BaseModelOutputWithPooling 或 `tuple(torch.FloatTensor)`

参数

flattened_patches (形状为 `(batch_size, sequence_length, num_channels x patch_height x patch_width)` 的 torch.FloatTensor) — 展平并填充的像素值。这些值可以使用 AutoImageProcessor 获得。有关详细信息，请参阅 `Pix2StructVisionImageProcessor.__call__`。有关更多详细信息，请查看原始论文 (图 5)。
attention_mask (形状为 `(batch_size, sequence_length)` 的 torch.FloatTensor，可选) — 掩码，以避免对填充像素值执行注意力机制。在 `[0, 1]` 中选择的掩码值：
head_mask (形状为 `(num_heads,)` 或 `(num_layers, num_heads)` 的 torch.FloatTensor，可选) — 掩码，用于使自注意力模块的选定头无效。在 `[0, 1]` 中选择的掩码值：
- 1 表示头**未被掩蔽**，
- 0 表示头**被掩蔽**。
output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的 `attentions`。
output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的 `hidden_states`。
return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。

返回 (Returns)

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

一个 transformers.modeling_outputs.BaseModelOutputWithPooling 或 `torch.FloatTensor` 的元组 (如果传递了 `return_dict=False` 或者当 `config.return_dict=False` 时)，包含各种元素，具体取决于配置 (Pix2StructConfig) 和输入。

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

Pix2StructVisionModel 前向方法，覆盖了 `__call__` 特殊方法。

示例

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

>>> image_processor = AutoProcessor.from_pretrained("google/pix2struct-textcaps-base")
>>> model = Pix2StructVisionModel.from_pretrained("google/pix2struct-textcaps-base")

>>> url = "https://www.ilankelman.org/stopsigns/australia.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> inputs = image_processor(images=image, return_tensors="pt")
>>> with torch.no_grad():
...     outputs = model(**inputs)

>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 2048, 768]

Pix2StructForConditionalGeneration

class transformers.Pix2StructForConditionalGeneration

< source >

( config: Pix2StructConfig )

参数

config (Union[Pix2StructConfig, Pix2StructTextConfig]) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，而只会加载配置。查看 from_pretrained() 方法以加载模型权重。

具有语言建模头的条件生成模型。可用于序列生成任务。

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

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

forward

< source >

( flattened_patches: typing.Optional[torch.FloatTensor] = None attention_mask: typing.Optional[torch.FloatTensor] = None decoder_input_ids: typing.Optional[torch.LongTensor] = None decoder_attention_mask: typing.Optional[torch.BoolTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None decoder_head_mask: typing.Optional[torch.FloatTensor] = None cross_attn_head_mask: typing.Optional[torch.Tensor] = None encoder_outputs: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None past_key_values: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None labels: typing.Optional[torch.LongTensor] = None decoder_inputs_embeds: typing.Optional[torch.Tensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None cache_position: typing.Optional[torch.LongTensor] = None ) → transformers.modeling_outputs.Seq2SeqModelOutput 或 `tuple(torch.FloatTensor)`

参数

flattened_patches (torch.FloatTensor，形状为 (batch_size, seq_length, hidden_size)) — 扁平化的像素块。 hidden_size 通过以下公式获得： hidden_size = num_channels patch_size patch_size

像素块的扁平化处理由 Pix2StructProcessor 完成。
attention_mask (torch.FloatTensor，形状为 (batch_size, sequence_length)，可选) — 用于避免在填充标记索引上执行注意力的掩码。掩码值在 [0, 1] 中选择：
- 1 表示标记未被掩码，
- 0 表示标记被掩码。
什么是注意力掩码？
decoder_input_ids (torch.LongTensor，形状为 (batch_size, target_sequence_length)，可选) — 解码器输入序列标记在词汇表中的索引。

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

什么是解码器输入 ID？

Pix2StructText 使用 pad_token_id 作为 decoder_input_ids 生成的起始标记。如果使用 past_key_values，则可以选择仅输入最后一个 decoder_input_ids（请参阅 past_key_values）。

要了解有关如何为预训练准备 decoder_input_ids 的更多信息，请查看 Pix2StructText 训练。
decoder_attention_mask (torch.BoolTensor，形状为 (batch_size, target_sequence_length)，可选) — 默认行为：生成一个张量，该张量忽略 decoder_input_ids 中的填充标记。默认情况下也将使用因果掩码。
head_mask (torch.FloatTensor，形状为 (num_heads,) 或 (num_layers, num_heads)，可选) — 用于 nullify 编码器中自注意力模块的选定头的掩码。掩码值在 [0, 1] 中选择：
- 1 表示头未被掩码，
- 0 表示头被掩码。
decoder_head_mask (torch.FloatTensor，形状为 (num_heads,) 或 (num_layers, num_heads)，可选) — 用于 nullify 解码器中自注意力模块的选定头的掩码。掩码值在 [0, 1] 中选择：
- 1 表示头未被掩码，
- 0 表示头被掩码。
cross_attn_head_mask (torch.Tensor，形状为 (num_heads,) 或 (num_layers, num_heads)，可选) — 用于 nullify 解码器中交叉注意力模块的选定头的掩码。掩码值在 [0, 1] 中选择：
- 1 表示头未被掩码，
- 0 表示头被掩码。
encoder_outputs (tuple(tuple(torch.FloatTensor)，可选) — 元组由 (last_hidden_state，optional: hidden_states，optional: attentions) 组成。 last_hidden_state 的形状为 (batch_size, sequence_length, hidden_size)，是编码器最后一层的输出处的隐藏状态序列。在解码器的交叉注意力中使用。
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（那些没有将其过去的键值状态提供给此模型的 decoder_input_ids），形状为 (batch_size, 1)，而不是所有形状为 (batch_size, sequence_length) 的 decoder_input_ids。
decoder_inputs_embeds (torch.FloatTensor，形状为 (batch_size, target_sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递 decoder_input_ids。如果使用 past_key_values，则可以选择仅输入最后一个 decoder_inputs_embeds（请参阅 past_key_values）。如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将 decoder_input_ids 索引转换为关联的向量，这将非常有用。

如果 decoder_input_ids 和 decoder_inputs_embeds 均未设置，则 decoder_inputs_embeds 取 inputs_embeds 的值。
labels (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 用于计算解码器的掩码语言建模损失的标签。
use_cache (bool，可选) — 如果设置为 True，则返回 past_key_values 键值状态，并且可以用于加速解码（请参阅 past_key_values）。
output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。
output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。
return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。

返回 (Returns)

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

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

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

如果使用 past_key_values，则仅输出形状为 (batch_size, 1, hidden_size) 的序列的最后一个隐藏状态。
past_key_values (tuple(tuple(torch.FloatTensor))，可选，当传递 use_cache=True 或当 config.use_cache=True 时返回) — 长度为 config.n_layers 的 tuple(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 输入）加速顺序解码。
decoder_hidden_states (tuple(torch.FloatTensor)，可选，当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 元组（如果模型具有嵌入层，则为嵌入输出一个，+ 每层输出一个），形状为 (batch_size, sequence_length, hidden_size)。

解码器在每层输出处的隐藏状态，以及可选的初始嵌入输出。
decoder_attentions (tuple(torch.FloatTensor)，可选，当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
cross_attentions (tuple(torch.FloatTensor)，可选，当传递 `output_attentions=True` 或当 `config.output_attentions=True` 时返回) — `torch.FloatTensor` 的元组 (每层一个)，形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。

解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
encoder_last_hidden_state (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层输出处的隐藏状态序列。
encoder_hidden_states (tuple(torch.FloatTensor)，可选，当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 元组（如果模型具有嵌入层，则为嵌入输出一个，+ 每层输出一个），形状为 (batch_size, sequence_length, hidden_size)。

编码器在每层输出处的隐藏状态，以及可选的初始嵌入输出。
encoder_attentions (tuple(torch.FloatTensor)，可选，当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

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

Pix2StructForConditionalGeneration forward 方法，覆盖了 __call__ 特殊方法。

示例

推理

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

>>> processor = AutoProcessor.from_pretrained("google/pix2struct-textcaps-base")
>>> model = Pix2StructForConditionalGeneration.from_pretrained("google/pix2struct-textcaps-base")

>>> url = "https://www.ilankelman.org/stopsigns/australia.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

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

>>> # autoregressive generation
>>> generated_ids = model.generate(**inputs, max_new_tokens=50)
>>> generated_text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
>>> print(generated_text)
A stop sign is on a street corner.

>>> # conditional generation
>>> text = "A picture of"
>>> inputs = processor(text=text, images=image, return_tensors="pt", add_special_tokens=False)

>>> generated_ids = model.generate(**inputs, max_new_tokens=50)
>>> generated_text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
>>> print(generated_text)
A picture of a stop sign with a red stop sign

训练

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

>>> processor = AutoProcessor.from_pretrained("google/pix2struct-base")
>>> model = Pix2StructForConditionalGeneration.from_pretrained("google/pix2struct-base")

>>> url = "https://www.ilankelman.org/stopsigns/australia.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> text = "A stop sign is on the street corner."

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

>>> # forward pass
>>> outputs = model(**inputs, labels=labels)
>>> loss = outputs.loss
>>> print(f"{loss.item():.5f}")
5.94282

< > 在 GitHub 上更新

Transformers

Pix2Struct

概述

资源

Pix2StructConfig

class transformers.Pix2StructConfig

from_text_vision_configs

Pix2StructTextConfig

class transformers.Pix2StructTextConfig

Pix2StructVisionConfig

class transformers.Pix2StructVisionConfig

Pix2StructProcessor

class transformers.Pix2StructProcessor

batch_decode

decode

Pix2StructImageProcessor

class transformers.Pix2StructImageProcessor

preprocess

Pix2StructTextModel

class transformers.Pix2StructTextModel

forward

Pix2StructVisionModel

class transformers.Pix2StructVisionModel

forward

Pix2StructForConditionalGeneration

class transformers.Pix2StructForConditionalGeneration

forward