Transformers 文档

Pix2Struct

Hugging Face's logo
加入 Hugging Face 社区

并获得增强的文档体验

开始使用

Pix2Struct

PyTorch

概述

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

论文摘要如下:

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

技巧

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

如果您想使用该模型执行条件文本字幕,请确保使用带有 `add_special_tokens=False` 的处理器。

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

资源

Pix2StructConfig

class transformers.Pix2StructConfig

< >

( 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

< >

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

返回

Pix2StructConfig

一个配置对象的实例

从 pix2struct 文本模型配置和 pix2struct 视觉模型配置实例化 Pix2StructConfig(或派生类)。

Pix2StructTextConfig

class transformers.Pix2StructTextConfig

< >

( 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 可以表示的不同标记的数量。
  • hidden_size (int, 可选, 默认为 768) — 编码器层和池化层的维度。
  • d_kv (int, 可选, 默认为 64) — 每个注意力头中键、查询、值投影的维度。
  • d_ff (int, 可选, 默认为 2048) — Transformer 编码器中“中间”(即前馈)层的维度。
  • num_layers (int, 可选, 默认为 12) — Transformer 编码器中的隐藏层数量。
  • num_heads (int, 可选, 默认为 12) — Transformer 编码器中每个注意力层的注意力头数量。
  • relative_attention_num_buckets (int, 可选, 默认为 32) — 每个注意力层使用的桶数量。
  • relative_attention_max_distance (int, 可选, 默认为 128) — 桶分离中较长序列的最大距离。
  • dropout_rate (float, 可选, 默认为 0.1) — 嵌入层、编码器和池化器中所有全连接层的 dropout 概率。
  • layer_norm_epsilon (float, 可选, 默认为 1e-6) — 层归一化层使用的 epsilon 值。
  • initializer_factor (float, 可选, 默认为 1.0) — 初始化所有权重矩阵的因子(应保持为 1,内部用于初始化测试)。
  • dense_act_fn (Union[Callable, str], 可选, 默认为 "gelu_new") — 非线性激活函数(函数或字符串)。
  • decoder_start_token_id (int, 可选, 默认为 0) — decoder_start_token_id 标记的 id。
  • use_cache (bool, 可选, 默认为 False) — 模型是否应返回最后一个键/值注意力(并非所有模型都使用)。
  • pad_token_id (int, 可选, 默认为 0) — padding 标记的 id。
  • eos_token_id (int, 可选, 默认为 1) — end-of-sequence 标记的 id。

这是用于存储 Pix2StructTextModel 配置的配置类。它用于根据指定的参数实例化 Pix2Struct 文本模型,定义模型架构。使用默认值实例化配置将产生类似于 google/pix2struct-base 架构使用的 Pix2Struct 文本解码器的配置。

配置对象继承自 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

< >

( 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) — 编码器层和池化层的维度。
  • patch_embed_hidden_size (int, 可选, 默认为 768) — Transformer 编码器中输入 patch_embedding 层的维度。
  • d_ff (int, 可选, 默认为 2048) — Transformer 编码器中“中间”(即前馈)层的维度。
  • d_kv (int, 可选, 默认为 64) — 每个注意力头中键、查询、值投影的维度。
  • num_hidden_layers (int, 可选, 默认为 12) — Transformer 编码器中的隐藏层数量。
  • num_attention_heads (int, 可选, 默认为 12) — Transformer 编码器中每个注意力层的注意力头数量。
  • dense_act_fn (strfunction, 可选, 默认为 "gelu_new") — 编码器和池化器中的非线性激活函数(函数或字符串)。如果为字符串,则支持 "gelu", "relu", "selu""gelu_new" "gelu"
  • layer_norm_eps (float, 可选, 默认为 1e-06) — 层归一化层使用的 epsilon。
  • dropout_rate (float, 可选, 默认为 0.0) — 嵌入层、编码器和池化器中所有全连接层的 dropout 概率。
  • attention_dropout (float, 可选, 默认为 0.0) — 注意力概率的 dropout 比率。
  • initializer_range (float, 可选, 默认为 1e-10) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
  • initializer_factor (float, 可选, 默认为 1.0) — 初始化所有权重矩阵的因子(应保持为 1,内部用于初始化测试)。
  • seq_len (int, 可选, 默认为 4096) — 模型支持的最大序列长度(此处指补丁数量)。
  • relative_attention_num_buckets (int, 可选, 默认为 32) — 每个注意力层使用的桶的数量。
  • relative_attention_max_distance (int, 可选, 默认为 128) — 每个注意力层使用的最大距离(以 token 为单位)。

这是一个配置类,用于存储 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

< >

( image_processor tokenizer )

参数

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

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

Pix2StructProcessor 提供了 Pix2StructImageProcessorT5TokenizerFast 的所有功能。有关更多信息,请参阅 __call__()decode() 的文档字符串。

batch_decode

< >

( *args **kwargs )

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

decode

< >

( *args **kwargs )

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

Pix2StructImageProcessor

class transformers.Pix2StructImageProcessor

< >

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

参数

  • do_convert_rgb (bool, 可选, 默认为 True) — 是否将图像转换为 RGB。
  • do_normalize (bool, 可选, 默认为 True) — 是否对图像进行归一化。可以通过 preprocess 方法中的 do_normalize 参数覆盖。根据 Pix2Struct 论文和代码,图像使用其自身的均值和标准差进行归一化。
  • patch_size (dict[str, int], 可选, 默认为 {"height" -- 16, "width": 16}):图像使用的补丁大小。根据 Pix2Struct 论文和代码,补丁大小为 16x16。
  • max_patches (int, 可选, 默认为 2048) — 根据 Pix2Struct 论文,从图像中提取的最大补丁数。
  • is_vqa (bool, 可选, 默认为 False) — 图像处理器是否用于 VQA 任务。如果为 True 并且传入 header_text,则文本将呈现在输入图像上。

构建 Pix2Struct 图像处理器。

preprocess

< >

( 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: typing.Optional[bool] = None do_normalize: typing.Optional[bool] = None max_patches: typing.Optional[int] = None patch_size: typing.Optional[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_vqaTrue 时才生效。
  • do_convert_rgb (bool, 可选, 默认为 self.do_convert_rgb) — 是否将图像转换为 RGB。
  • do_normalize (bool, 可选, 默认为 self.do_normalize) — 是否对图像进行归一化。
  • max_patches (int, 可选, 默认为 self.max_patches) — 要提取的最大补丁数。
  • patch_size (dict, 可选, 默认为 self.patch_size) — 包含补丁高度和宽度的字典。
  • return_tensors (strTensorType, 可选) — 要返回的张量类型。可以是以下之一:
    • 未设置:返回 np.ndarray 列表。
    • TensorType.TENSORFLOW'tf':返回 tf.Tensor 批次。
    • TensorType.PYTORCH'pt':返回 torch.Tensor 批次。
    • TensorType.NUMPY'np':返回 np.ndarray 批次。
    • TensorType.JAX'jax':返回 jax.numpy.ndarray 批次。
  • data_format (ChannelDimensionstr, 可选, 默认为 ChannelDimension.FIRST) — 输出图像的通道维度格式。可以是以下之一:
    • "channels_first"ChannelDimension.FIRST:图像为 (num_channels, height, width) 格式。
    • "channels_last"ChannelDimension.LAST:图像为 (height, width, num_channels) 格式。
    • 未设置:使用输入图像的通道维度格式。
  • input_data_format (ChannelDimensionstr, 可选) — 输入图像的通道维度格式。如果未设置,则从输入图像推断通道维度格式。可以是以下之一:
    • "channels_first"ChannelDimension.FIRST:图像为 (num_channels, height, width) 格式。
    • "channels_last"ChannelDimension.LAST:图像为 (height, width, num_channels) 格式。
    • "none"ChannelDimension.NONE:图像为 (height, width) 格式。

预处理一张或一批图像。处理器首先计算可以从图像中提取的,最大数量的,保持纵横比的 patch_size 大小补丁。然后用零填充图像,使图像符合 max_patches 的约束。在提取补丁之前,图像根据 per_image_standardization 的 tensorflow 实现进行标准化(https://tensorflowcn.cn/api_docs/python/tf/image/per_image_standardization)。

Pix2StructTextModel

class transformers.Pix2StructTextModel

< >

( config )

参数

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

Pix2Struct 的独立文本解码器

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

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

forward

< >

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

参数

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

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

    什么是输入 ID?

    要了解如何为预训练准备 input_ids,请查看 Pix2StructText 训练

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

    • 1 表示 token 未被掩码,
    • 0 表示 token 已被掩码.

    什么是注意力掩码?

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

    • 1 表示 token 未被掩码,
    • 0 表示 token 已被掩码.
  • inputs_embeds (形状为 (batch_size, sequence_length, hidden_size)torch.LongTensor, 可选) — (可选)您可以选择直接传入嵌入表示,而不是传入 input_ids。如果您希望对 input_ids 索引如何转换为关联向量拥有比模型内部嵌入查找矩阵更多的控制权,这将非常有用。
  • head_mask (形状为 (num_heads,)(num_layers, num_heads)torch.FloatTensor, 可选) — 用于使自注意力模块的选定头部无效的掩码。掩码值选择在 [0, 1] 之间:

    • 1 表示头部未被掩码,
    • 0 表示头部已被掩码.
  • cross_attn_head_mask (形状为 (num_heads,)(num_layers, num_heads)torch.Tensor, 可选) — 用于使解码器中交叉注意力模块的选定头部无效的掩码。掩码值选择在 [0, 1] 之间:

    • 1 表示头部未被掩码,
    • 0 表示头部已被掩码.
  • past_key_values (tuple[tuple[torch.FloatTensor]], 可选) — 预先计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可用于加速顺序解码。这通常包括模型在解码上一阶段返回的 past_key_values,当 use_cache=Trueconfig.use_cache=True 时。

    允许两种格式:

    • 一个 Cache 实例,请参阅我们的 kv cache 指南
    • 长度为 config.n_layerstuple(torch.FloatTensor) 元组,每个元组包含 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量。这也被称为传统缓存格式。

    模型将输出与作为输入传入的缓存格式相同的缓存格式。如果没有传入 past_key_values,将返回传统缓存格式。

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

  • use_cache (bool, 可选) — 如果设置为 True,则返回 past_key_values 键值状态,可用于加速解码(请参阅 past_key_values)。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的 attentions
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的 hidden_states
  • labels (形状为 (batch_size, sequence_length)torch.LongTensor, 可选) — 用于计算掩码语言建模损失的标签。索引应在 [0, ..., config.vocab_size] 或 -100 之间(请参阅 input_ids 文档字符串)。索引设置为 -100 的 token 将被忽略(掩码),损失仅针对标签在 [0, ..., config.vocab_size] 之间的 token 进行计算。
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是纯元组。
  • cache_position (形状为 (sequence_length)torch.LongTensor, 可选) — 描述输入序列 token 在序列中位置的索引。与 position_ids 不同,此张量不受填充影响。它用于在正确位置更新缓存并推断完整的序列长度。

返回

transformers.modeling_outputs.CausalLMOutputWithCrossAttentionstuple(torch.FloatTensor)

transformers.modeling_outputs.CausalLMOutputWithCrossAttentionstorch.FloatTensor 的元组(如果传入 return_dict=False 或当 config.return_dict=False 时),包含根据配置 (Pix2StructConfig) 和输入的不同元素。

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

  • 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 (Cache, 可选, 当传入 use_cache=True 或当 config.use_cache=True 时返回) — 这是一个 Cache 实例。有关更多详细信息,请参阅我们的 kv cache 指南

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

Pix2StructTextModel 的 forward 方法,覆盖了 __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

< >

( config: Pix2StructConfig )

参数

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

不带任何特定头部的裸 Pix2Struct 模型,直接输出原始隐藏状态。

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

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

forward

< >

( 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.BaseModelOutputWithPoolingtuple(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.Tensor, 可选) — 用于避免在填充 token 索引上执行注意力操作的掩码。掩码值选择在 [0, 1] 之间:

    • 1 表示 token 未被掩码,
    • 0 表示 token 已被掩码

    什么是注意力掩码?

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

    • 1 表示头部未被掩码,
    • 0 表示头部已被掩码
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。更多详细信息请参阅返回张量下的 attentions
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。更多详细信息请参阅返回张量下的 hidden_states
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。

返回

transformers.modeling_outputs.BaseModelOutputWithPoolingtuple(torch.FloatTensor)

transformers.modeling_outputs.BaseModelOutputWithPoolingtorch.FloatTensor 的元组 (如果传入 return_dict=Falseconfig.return_dict=False) ,包含根据配置 (Pix2StructConfig) 和输入的不同元素。

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

  • pooler_output (形状为 (batch_size, hidden_size)torch.FloatTensor) — 序列第一个 token (分类 token) 在经过辅助预训练任务所用层处理后的最后一层隐藏状态。例如,对于 BERT 系列模型,这将返回分类 token 在经过线性层和 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 的 forward 方法,覆盖了 __call__ 特殊方法。

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

示例

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

< >

( config: Pix2StructConfig )

参数

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

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

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

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

forward

< >

( 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[tuple[tuple[torch.FloatTensor]]] = None past_key_values: typing.Optional[tuple[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.Seq2SeqModelOutputtuple(torch.FloatTensor)

参数

  • flattened_patches (形状为 (batch_size, seq_length, hidden_size)torch.FloatTensor) — 展平的像素补丁。hidden_size 由以下公式获得:hidden_size = num_channels * patch_size * patch_size

    像素补丁的展平过程由 Pix2StructProcessor 完成。

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

    • 1 表示 token 未被掩码,
    • 0 表示 token 已被掩码

    什么是注意力掩码?

  • decoder_input_ids (形状为 (batch_size, target_sequence_length)torch.LongTensor, 可选) — 解码器输入序列 token 在词汇表中的索引。

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

    什么是解码器输入 ID?

    Pix2StructText 使用 pad_token_id 作为 decoder_input_ids 生成的起始 token。如果使用 past_key_values,可选地只输入最后一个 decoder_input_ids(那些没有将它们的 past key value 状态提供给此模型的 token)(请参阅 past_key_values)。

    要了解更多关于如何为预训练准备 decoder_input_ids,请查看 Pix2StructText 训练

  • decoder_attention_mask (形状为 (batch_size, target_sequence_length)torch.BoolTensor, 可选) — 默认行为:生成一个忽略 decoder_input_ids 中填充 token 的张量。默认情况下也会使用因果掩码。
  • head_mask (形状为 (num_heads,)(num_layers, num_heads)torch.FloatTensor, 可选) — 用于使自注意力模块中的选定头部无效的掩码。掩码值选择在 [0, 1] 之间:

    • 1 表示头部未被掩码,
    • 0 表示头部已被掩码
  • decoder_head_mask (形状为 (num_heads,)(num_layers, num_heads)torch.FloatTensor, 可选) — 用于使解码器中自注意力模块的选定头部无效的掩码。掩码值选择在 [0, 1] 之间:

    • 1 表示头部未被掩码,
    • 0 表示头部已被掩码
  • cross_attn_head_mask (形状为 (num_heads,)(num_layers, num_heads)torch.Tensor, 可选) — 用于使解码器中交叉注意力模块的选定头部无效的掩码。掩码值选择在 [0, 1] 之间:

    • 1 表示头部未被掩码,
    • 0 表示头部已被掩码
  • encoder_outputs (tuple[tuple[torch.FloatTensor]], 可选) — 元组包括 (last_hidden_state, 可选: hidden_states, 可选: attentions) 形状为 (batch_size, sequence_length, hidden_size)last_hidden_state可选)是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。
  • past_key_values (tuple[tuple[torch.FloatTensor]], 可选) — 预计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可用于加速顺序解码。这通常包括模型在解码前期返回的 past_key_values,当 use_cache=Trueconfig.use_cache=True 时。

    允许两种格式:

    • 一个 Cache 实例,请参阅我们的 kv 缓存指南
    • 一个长度为 config.n_layerstuple(torch.FloatTensor) 元组,每个元组包含两个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量。这也被称为旧版缓存格式。

    模型将输出与输入相同的缓存格式。如果未传入 past_key_values,将返回旧版缓存格式。

    如果使用 past_key_values,用户可以选择只输入最后一个 input_ids(那些没有将其过去键值状态提供给此模型的 token),形状为 (batch_size, 1),而不是所有 input_ids,形状为 (batch_size, sequence_length)

  • labels (形状为 (batch_size, sequence_length)torch.LongTensor, 可选) — 用于计算解码器掩码语言建模损失的标签。
  • decoder_inputs_embeds (形状为 (batch_size, target_sequence_length, hidden_size)torch.Tensor, 可选) — 可选地,你可以选择直接传入嵌入表示,而不是传入 decoder_input_ids。如果使用 past_key_values,可选地只输入最后一个 decoder_inputs_embeds(请参阅 past_key_values)。如果你希望对如何将 decoder_input_ids 索引转换为相关向量有更多控制,而不是使用模型的内部嵌入查找矩阵,这会很有用。

    如果 decoder_input_idsdecoder_inputs_embeds 都未设置,则 decoder_inputs_embedsinputs_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, 可选) — 描绘输入序列 token 在序列中位置的索引。与 position_ids 不同,此张量不受填充影响。它用于在正确位置更新缓存并推断完整序列长度。

返回

transformers.modeling_outputs.Seq2SeqModelOutputtuple(torch.FloatTensor)

transformers.modeling_outputs.Seq2SeqModelOutputtorch.FloatTensor 的元组 (如果传入 return_dict=Falseconfig.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 (EncoderDecoderCache, 可选, 当传入 use_cache=Trueconfig.use_cache=True 时返回) — 这是一个 EncoderDecoderCache 实例。更多详细信息,请参阅我们的 kv 缓存指南

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

  • decoder_hidden_states (tuple(torch.FloatTensor), 可选, 当传入 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — torch.FloatTensor 的元组 (如果模型有嵌入层,则为嵌入输出之一,加上每层输出之一),形状为 (batch_size, sequence_length, hidden_size)

    解码器在每个层输出的隐藏状态,加上可选的初始嵌入输出。

  • decoder_attentions (tuple(torch.FloatTensor), 可选, 当传入 output_attentions=Trueconfig.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=Trueconfig.output_hidden_states=True 时返回) — torch.FloatTensor 的元组 (如果模型有嵌入层,则为嵌入输出之一,加上每层输出之一),形状为 (batch_size, sequence_length, hidden_size)

    编码器在每个层输出的隐藏状态,加上可选的初始嵌入输出。

  • encoder_attentions (tuple(torch.FloatTensor), 可选, 当传入 output_attentions=Trueconfig.output_attentions=True 时返回) — torch.FloatTensor 的元组 (每层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)

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

Pix2StructForConditionalGeneration 的 forward 方法,覆盖了 __call__ 特殊方法。

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

示例

推理

>>> 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 上更新