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

Transformers 4.37 中文文档（四十六）

原文：huggingface.co/docs/transformers

SigLIP

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

概述

SigLIP 模型是由 Xiaohua Zhai、Basil Mustafa、Alexander Kolesnikov、Lucas Beyer 在用于语言图像预训练的 Sigmoid Loss中提出的。SigLIP 建议用简单的成对 Sigmoid 损失替换 CLIP 中使用的损失函数。这导致在 ImageNet 的零样本分类准确性方面表现更好。

论文摘要如下：

我们提出了一种简单的成对 Sigmoid 损失用于语言-图像预训练（SigLIP）。与标准的具有 softmax 归一化的对比学习不同，Sigmoid 损失仅在图像-文本对上操作，不需要全局查看成对相似性以进行归一化。Sigmoid 损失同时允许进一步扩大批处理大小，同时在较小的批处理大小下表现更好。结合锁定图像调整，仅使用四个 TPUv4 芯片，我们训练了一个在两天内实现了 84.5% ImageNet 零样本准确性的 SigLiT 模型。批处理大小与损失的解耦进一步使我们能够研究示例与对之间的影响以及负到正的比率。最后，我们将批处理大小推到极限，高达一百万，并发现随着批处理大小的增长，好处迅速减少，32k 的更合理的批处理大小已经足够。

使用提示

  • SigLIP 的使用类似于 CLIP。主要区别在于训练损失，它不需要查看批处理中所有图像和文本的成对相似性的全局视图。需要将 sigmoid 激活函数应用于 logits，而不是 softmax。

  • 目前不支持训练。如果你想要微调 SigLIP 或从头开始训练，请参考来自OpenCLIP的损失函数，该函数利用了各种torch.distributed实用程序。

  • 当使用独立的 SiglipTokenizer 或 SiglipProcessor 时，请确保传递padding="max_length"，因为模型是这样训练的。

drawing SigLIP 评估结果与 CLIP 进行比较。摘自原始论文。

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

使用示例

有两种主要方法可以使用 SigLIP：一种是使用管道 API，它为您抽象了所有复杂性，另一种是自己使用SiglipModel类。

Pipeline API

该流程允许在几行代码中使用模型：

>>> from transformers import pipeline
>>> from PIL import Image
>>> import requests

>>> # load pipe
>>> image_classifier = pipeline(task="zero-shot-image-classification", model="google/siglip-base-patch16-224")

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

>>> # inference
>>> outputs = image_classifier(image, candidate_labels=["2 cats", "a plane", "a remote"])
>>> outputs = [{"score": round(output["score"], 4), "label": output["label"] } for output in outputs]
>>> print(outputs)
[{'score': 0.1979, 'label': '2 cats'}, {'score': 0.0, 'label': 'a remote'}, {'score': 0.0, 'label': 'a plane'}]

自己使用模型

如果你想自己进行预处理和后处理，以下是如何操作的：

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

>>> model = AutoModel.from_pretrained("google/siglip-base-patch16-224")
>>> processor = AutoProcessor.from_pretrained("google/siglip-base-patch16-224")

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

>>> texts = ["a photo of 2 cats", "a photo of 2 dogs"]
>>> # important: we pass `padding=max_length` since the model was trained with this
>>> inputs = processor(text=texts, images=image, padding="max_length", return_tensors="pt")

>>> with torch.no_grad():
...     outputs = model(**inputs)

>>> logits_per_image = outputs.logits_per_image
>>> probs = torch.sigmoid(logits_per_image) # these are the probabilities
>>> print(f"{probs[0][0]:.1%} that image 0 is '{texts[0]}'")
31.9% that image 0 is 'a photo of 2 cats'

SiglipConfig

class transformers.SiglipConfig

< source >

( text_config = None vision_config = None **kwargs )

参数

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

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

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

SiglipConfig 是用于存储 SiglipModel 配置的配置类。根据指定的参数实例化一个 Siglip 模型，定义文本模型和视觉模型配置。使用默认值实例化配置将产生类似于 Siglip google/siglip-base-patch16-224架构的配置。

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

示例：

>>> from transformers import SiglipConfig, SiglipModel

>>> # Initializing a SiglipConfig with google/siglip-base-patch16-224 style configuration
>>> configuration = SiglipConfig()

>>> # Initializing a SiglipModel (with random weights) from the google/siglip-base-patch16-224 style configuration
>>> model = SiglipModel(configuration)

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

>>> # We can also initialize a SiglipConfig from a SiglipTextConfig and a SiglipVisionConfig
>>> from transformers import SiglipTextConfig, SiglipVisionConfig

>>> # Initializing a SiglipText and SiglipVision configuration
>>> config_text = SiglipTextConfig()
>>> config_vision = SiglipVisionConfig()

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

from_text_vision_configs

< source >

( text_config: SiglipTextConfig vision_config: SiglipVisionConfig **kwargs ) → export const metadata = 'undefined';SiglipConfig

返回

SiglipConfig

配置对象的一个实例

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

SiglipTextConfig

class transformers.SiglipTextConfig

< source >

( vocab_size = 32000 hidden_size = 768 intermediate_size = 3072 num_hidden_layers = 12 num_attention_heads = 12 max_position_embeddings = 64 hidden_act = 'gelu_pytorch_tanh' layer_norm_eps = 1e-06 attention_dropout = 0.0 pad_token_id = 1 bos_token_id = 49406 eos_token_id = 49407 **kwargs )

参数

  • vocab_size (int, optional, defaults to 32000) — Siglip 文本模型的词汇表大小。定义在调用 SiglipModel 时可以表示的不同标记数量。

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

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

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

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

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

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

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

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

  • pad_token_id (int, optional, defaults to 1) — 词汇表中填充标记的 id。

  • bos_token_id (int, optional, defaults to 49406) — 词汇表中序列开始标记的 id。

  • eos_token_id (int, optional, defaults to 49407) — 词汇表中序列结束标记的 id。

这是一个配置类，用于存储 SiglipTextModel 的配置。根据指定的参数实例化一个 Siglip 文本编码器，定义模型架构。使用默认值实例化配置将产生类似于 Siglip google/siglip-base-patch16-224架构的文本编码器配置。

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

示例:

>>> from transformers import SiglipTextConfig, SiglipTextModel

>>> # Initializing a SiglipTextConfig with google/siglip-base-patch16-224 style configuration
>>> configuration = SiglipTextConfig()

>>> # Initializing a SiglipTextModel (with random weights) from the google/siglip-base-patch16-224 style configuration
>>> model = SiglipTextModel(configuration)

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

SiglipVisionConfig

class transformers.SiglipVisionConfig

< source >

( 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 = 'gelu_pytorch_tanh' layer_norm_eps = 1e-06 attention_dropout = 0.0 **kwargs )

参数

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

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

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

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

  • num_channels (int, 可选, 默认为 3) — 输入图像中的通道数。

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

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

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

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

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

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

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

示例:

>>> from transformers import SiglipVisionConfig, SiglipVisionModel

>>> # Initializing a SiglipVisionConfig with google/siglip-base-patch16-224 style configuration
>>> configuration = SiglipVisionConfig()

>>> # Initializing a SiglipVisionModel (with random weights) from the google/siglip-base-patch16-224 style configuration
>>> model = SiglipVisionModel(configuration)

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

SiglipTokenizer

class transformers.SiglipTokenizer

< source >

( vocab_file eos_token = '</s>' unk_token = '<unk>' pad_token = '</s>' additional_special_tokens = None sp_model_kwargs: Optional = None model_max_length = 64 do_lower_case = True **kwargs )

参数

  • vocab_file (str) — 包含实例化分词器所需词汇的SentencePiece文件（通常具有.spm扩展名）。

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

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

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

  • additional_special_tokens (List[str], 可选) — 分词器使用的额外特殊标记。

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

    • enable_sampling: 启用子词正则化。

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

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

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

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

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

  • model_max_length (int, optional, 默认为 64) — 模型输入的最大长度（标记数）。

  • do_lower_case (bool, optional, 默认为 True) — 在标记化时是否将输入转换为小写。

构建一个 Siglip 分词器。基于 SentencePiece。

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

build_inputs_with_special_tokens

< source >

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

参数

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

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

返回

List[int]

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

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

  • 单个序列：X </s>

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

get_special_tokens_mask

< source >

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

参数

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

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

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

返回

List[int]

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

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

create_token_type_ids_from_sequences

< source >

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

参数

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

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

返回

List[int]

零列表。

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

save_vocabulary

< source >

( save_directory: str filename_prefix: Optional = None )

SiglipImageProcessor

class transformers.SiglipImageProcessor

< source >

( do_resize: bool = True size: Dict = None resample: Resampling = <Resampling.BICUBIC: 3> do_rescale: bool = True rescale_factor: Union = 0.00392156862745098 do_normalize: bool = True image_mean: Union = None image_std: Union = None **kwargs )

参数

  • do_resize (bool, optional, 默认为 True) — 是否将图像的（高度，宽度）尺寸调整为指定的 size。可以被 preprocess 方法中的 do_resize 覆盖。

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

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

  • do_rescale (bool, optional, 默认为 True) — 是否按照指定的比例 rescale_factor 重新缩放图像。可以被 preprocess 方法中的 do_rescale 覆盖。

  • rescale_factor (int 或 float, 可选, 默认为 1/255) — 如果重新缩放图像，则使用的缩放因子。可以被 preprocess 方法中的 rescale_factor 覆盖。

  • do_normalize (bool, 可选, 默认为 True) — 是否按指定的均值和标准差对图像进行归一化。可以被 preprocess 方法中的 do_normalize 覆盖。

  • image_mean (float 或 List[float], 可选, 默认为 [0.5, 0.5, 0.5]) — 如果对图像进行归一化，则使用的均值。这是一个浮点数或与图像通道数相同长度的浮点数列表。可以被 preprocess 方法中的 image_mean 参数覆盖。

  • image_std (float 或 List[float], 可选, 默认为 [0.5, 0.5, 0.5]) — 如果对图像进行归一化，则使用的标准差。这是一个浮点数或与图像通道数相同长度的浮点数列表。可以被 preprocess 方法中的 image_std 参数覆盖。

构建 SigLIP 图像处理器。

preprocess

< source >

( images: Union do_resize: bool = None size: Dict = None resample: Resampling = None do_rescale: bool = None rescale_factor: float = None do_normalize: bool = None image_mean: Union = None image_std: Union = None return_tensors: Union = None data_format: Optional = <ChannelDimension.FIRST: 'channels_first'> input_data_format: Union = None **kwargs )

参数

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

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

  • size (Dict[str, int], 可选, 默认为 self.size) — 调整大小后的图像尺寸。

  • resample (int, 可选, 默认为 self.resample) — 如果调整图像大小，则使用的重采样滤波器。这可以是枚举 PILImageResampling 中的一个。仅在 do_resize 设置为 True 时生效。

  • do_rescale (bool, 可选, 默认为 self.do_rescale) — 是否重新缩放图像。

  • rescale_factor (float, 可选, 默认为 self.rescale_factor) — 如果 do_rescale 设置为 True，则重新缩放图像的重新缩放因子。

  • do_normalize (bool, 可选, 默认为 self.do_normalize) — 是否对图像进行归一化。

  • image_mean (float 或 List[float], 可选, 默认为 self.image_mean) — 用于归一化的图像均值。仅在 do_normalize 设置为 True 时生效。

  • image_std (float 或 List[float], 可选, 默认为 self.image_std) — 用于归一化的图像标准差。仅在 do_normalize 设置为 True 时生效。

  • 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) — 输出图像的通道维度格式。可以是以下之一:

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

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

    • 未设置: 使用输入图像的通道维度格式。

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

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

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

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

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

SiglipProcessor

class transformers.SiglipProcessor

<来源>

( image_processor tokenizer )

参数

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

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

构建一个 Siglip 处理器，将 Siglip 图像处理器和 Siglip 标记器包装成一个处理器。

SiglipProcessor 提供了 SiglipImageProcessor 和 SiglipTokenizer 的所有功能。查看__call__()和 decode()以获取更多信息。

batch_decode

<来源>

( *args **kwargs )

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

decode

<来源>

( *args **kwargs )

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

SiglipModel

class transformers.SiglipModel

<来源>

( config: SiglipConfig )

参数

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

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

此模型也是 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 return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.siglip.modeling_siglip.SiglipOutput 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 表示被掩码的标记。

    什么是注意力掩码？

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

    什么是位置 ID？

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

  • return_loss (bool, 可选) — 是否返回对比损失。

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

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

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

返回

transformers.models.siglip.modeling_siglip.SiglipOutput或tuple(torch.FloatTensor)

一个transformers.models.siglip.modeling_siglip.SiglipOutput或一个torch.FloatTensor元组（如果传递了return_dict=False或config.return_dict=False时）包含根据配置（<class 'transformers.models.siglip.configuration_siglip.SiglipConfig'>）和输入的不同元素。

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

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

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

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

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

  • text_model_output(BaseModelOutputWithPooling): SiglipTextModel 的输出。

  • vision_model_output(BaseModelOutputWithPooling): SiglipVisionModel 的输出。

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

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

示例：

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

>>> model = AutoModel.from_pretrained("google/siglip-base-patch16-224")
>>> processor = AutoProcessor.from_pretrained("google/siglip-base-patch16-224")

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

>>> texts = ["a photo of 2 cats", "a photo of 2 dogs"]
>>> # important: we pass `padding=max_length` since the model was trained with this
>>> inputs = processor(text=texts, images=image, padding="max_length", return_tensors="pt")

>>> with torch.no_grad():
...     outputs = model(**inputs)

>>> logits_per_image = outputs.logits_per_image
>>> probs = torch.sigmoid(logits_per_image) # these are the probabilities
>>> print(f"{probs[0][0]:.1%} that image 0 is '{texts[0]}'")
31.9% that image 0 is 'a photo of 2 cats'

get_text_features

<来源>

( 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，形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。默认情况下，如果提供，将忽略填充。

    可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 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？

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

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

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

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

例如：

>>> from transformers import AutoTokenizer, AutoModel
>>> import torch

>>> model = AutoModel.from_pretrained("google/siglip-base-patch16-224")
>>> tokenizer = AutoTokenizer.from_pretrained("google/siglip-base-patch16-224")

>>> # important: make sure to set padding="max_length" as that's how the model was trained
>>> inputs = tokenizer(["a photo of a cat", "a photo of a dog"], padding="max_length", return_tensors="pt")
>>> with torch.no_grad():
...     text_features = model.get_text_features(**inputs)

get_image_features

< source >

( 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, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的attentions。

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

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

返回

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

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

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

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

示例：

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

>>> model = AutoModel.from_pretrained("google/siglip-base-patch16-224")
>>> processor = AutoProcessor.from_pretrained("google/siglip-base-patch16-224")

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

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

>>> with torch.no_grad():
...     image_features = model.get_image_features(**inputs)

SiglipTextModel

class transformers.SiglipTextModel

<来源>

( config: SiglipTextConfig )

参数

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

SigLIP 的文本模型，没有任何头部或顶部的投影。该模型继承自 PreTrainedModel。查看超类文档，了解库为其所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

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

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（形状为(batch_size, sequence_length)的torch.LongTensor）— 词汇表中输入序列标记的索引。默认情况下将忽略填充。

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

    什么是输入 ID？

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

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

    • 对于被masked的标记为 0。

    什么是注意力掩码？

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

    什么是位置 ID？

  • 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.siglip.configuration_siglip.SiglipTextConfig'>）和输入的不同元素。

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

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

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

示例：

>>> from transformers import AutoTokenizer, SiglipTextModel

>>> model = SiglipTextModel.from_pretrained("google/siglip-base-patch16-224")
>>> tokenizer = AutoTokenizer.from_pretrained("google/siglip-base-patch16-224")

>>> # important: make sure to set padding="max_length" as that's how the model was trained
>>> inputs = tokenizer(["a photo of a cat", "a photo of a dog"], padding="max_length", return_tensors="pt")

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

SiglipVisionModel

class transformers.SiglipVisionModel

<来源>

( config: SiglipVisionConfig )

参数

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

SigLIP 中的视觉模型，没有顶部的头部或投影。该模型继承自 PreTrainedModel。检查超类文档以获取库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

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

forward

<来源>

( pixel_values 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)) — 像素值。默认情况下将忽略填充。可以使用 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.siglip.configuration_siglip.SiglipVisionConfig'>）和输入的不同元素。

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

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

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

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

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

示例：

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

>>> model = SiglipVisionModel.from_pretrained("google/siglip-base-patch16-224")
>>> processor = AutoProcessor.from_pretrained("google/siglip-base-patch16-224")

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

语音编码器解码器模型

原始文本：huggingface.co/docs/transformers/v4.37.2/en/model_doc/speech-encoder-decoder

SpeechEncoderDecoderModel 可用于使用任何预训练语音自编码模型作为编码器（例如 Wav2Vec2，Hubert）和任何预训练自回归模型作为解码器初始化语音到文本模型。

已经证明使用预训练检查点初始化语音序列到文本序列模型，用于语音识别和语音翻译，例如在Large-Scale Self- and Semi-Supervised Learning for Speech Translation中由 Changhan Wang，Anne Wu，Juan Pino，Alexei Baevski，Michael Auli，Alexis Conneau 展示。

如何使用 SpeechEncoderDecoderModel 进行推理的示例可以在 Speech2Text2 中看到。

从模型配置随机初始化 SpeechEncoderDecoderModel。

SpeechEncoderDecoderModel 可以从编码器和解码器配置随机初始化。在以下示例中，我们展示了如何使用默认的 Wav2Vec2Model 配置作为编码器和默认的BertForCausalLM配置作为解码器。

>>> from transformers import BertConfig, Wav2Vec2Config, SpeechEncoderDecoderConfig, SpeechEncoderDecoderModel

>>> config_encoder = Wav2Vec2Config()
>>> config_decoder = BertConfig()

>>> config = SpeechEncoderDecoderConfig.from_encoder_decoder_configs(config_encoder, config_decoder)
>>> model = SpeechEncoderDecoderModel(config=config)

从预训练的编码器和预训练的解码器初始化 SpeechEncoderDecoderModel。

SpeechEncoderDecoderModel 可以从预训练的编码器检查点和预训练的解码器检查点初始化。请注意，任何预训练的基于 Transformer 的语音模型，例如 Wav2Vec2，Hubert 都可以作为编码器，以及预训练的自编码模型，例如 BERT，预训练的因果语言模型，例如 GPT2，以及序列到序列模型的预训练解码器部分，例如 BART 的解码器，都可以作为解码器。根据您选择的解码器架构，交叉注意力层可能会被随机初始化。从预训练的编码器和解码器检查点初始化 SpeechEncoderDecoderModel 需要对模型进行下游任务微调，正如在Warm-starting-encoder-decoder blog post中所示。为此，SpeechEncoderDecoderModel类提供了一个 SpeechEncoderDecoderModel.from_encoder_decoder_pretrained()方法。

>>> from transformers import SpeechEncoderDecoderModel

>>> model = SpeechEncoderDecoderModel.from_encoder_decoder_pretrained(
...     "facebook/hubert-large-ll60k", "bert-base-uncased"
... )

加载现有的 SpeechEncoderDecoderModel 检查点并执行推理。

要加载SpeechEncoderDecoderModel类的微调检查点，SpeechEncoderDecoderModel 提供了from_pretrained(...)方法，就像 Transformers 中的任何其他模型架构一样。

要执行推理，可以使用generate方法，该方法允许自回归生成文本。此方法支持各种解码形式，例如贪婪、束搜索和多项式采样。

>>> from transformers import Wav2Vec2Processor, SpeechEncoderDecoderModel
>>> from datasets import load_dataset
>>> import torch

>>> # load a fine-tuned speech translation model and corresponding processor
>>> model = SpeechEncoderDecoderModel.from_pretrained("facebook/wav2vec2-xls-r-300m-en-to-15")
>>> processor = Wav2Vec2Processor.from_pretrained("facebook/wav2vec2-xls-r-300m-en-to-15")

>>> # let's perform inference on a piece of English speech (which we'll translate to German)
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> input_values = processor(ds[0]["audio"]["array"], return_tensors="pt").input_values

>>> # autoregressively generate transcription (uses greedy decoding by default)
>>> generated_ids = model.generate(input_values)
>>> generated_text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
>>> print(generated_text)
Mr. Quilter ist der Apostel der Mittelschicht und wir freuen uns, sein Evangelium willkommen heißen zu können.

训练

创建模型后，可以像 BART、T5 或任何其他编码器解码器模型一样对（语音，文本）对数据集进行微调。如您所见，模型只需要 2 个输入才能计算损失：input_values（语音输入）和labels（编码目标序列的input_ids）。

>>> from transformers import AutoTokenizer, AutoFeatureExtractor, SpeechEncoderDecoderModel
>>> from datasets import load_dataset

>>> encoder_id = "facebook/wav2vec2-base-960h"  # acoustic model encoder
>>> decoder_id = "bert-base-uncased"  # text decoder

>>> feature_extractor = AutoFeatureExtractor.from_pretrained(encoder_id)
>>> tokenizer = AutoTokenizer.from_pretrained(decoder_id)
>>> # Combine pre-trained encoder and pre-trained decoder to form a Seq2Seq model
>>> model = SpeechEncoderDecoderModel.from_encoder_decoder_pretrained(encoder_id, decoder_id)

>>> model.config.decoder_start_token_id = tokenizer.cls_token_id
>>> model.config.pad_token_id = tokenizer.pad_token_id

>>> # load an audio input and pre-process (normalise mean/std to 0/1)
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> input_values = feature_extractor(ds[0]["audio"]["array"], return_tensors="pt").input_values

>>> # load its corresponding transcription and tokenize to generate labels
>>> labels = tokenizer(ds[0]["text"], return_tensors="pt").input_ids

>>> # the forward function automatically creates the correct decoder_input_ids
>>> loss = model(input_values=input_values, labels=labels).loss
>>> loss.backward()

SpeechEncoderDecoderConfig

class transformers.SpeechEncoderDecoderConfig

<来源>

( **kwargs )

参数

  • kwargs（可选）— 关键字参数的字典。特别是：

    • encoder（PretrainedConfig，可选）— 定义编码器配置的配置对象的实例。

    • decoder（PretrainedConfig，可选）— 定义解码器配置的配置对象的实例。

SpeechEncoderDecoderConfig 是用于存储 SpeechEncoderDecoderModel 配置的配置类。根据指定的参数实例化一个编码器解码器模型，定义编码器和解码器配置。

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

示例：

>>> from transformers import BertConfig, Wav2Vec2Config, SpeechEncoderDecoderConfig, SpeechEncoderDecoderModel

>>> # Initializing a Wav2Vec2 & BERT style configuration
>>> config_encoder = Wav2Vec2Config()
>>> config_decoder = BertConfig()

>>> config = SpeechEncoderDecoderConfig.from_encoder_decoder_configs(config_encoder, config_decoder)

>>> # Initializing a Wav2Vec2Bert model from a Wav2Vec2 & bert-base-uncased style configurations
>>> model = SpeechEncoderDecoderModel(config=config)

>>> # Accessing the model configuration
>>> config_encoder = model.config.encoder
>>> config_decoder = model.config.decoder
>>> # set decoder config to causal lm
>>> config_decoder.is_decoder = True
>>> config_decoder.add_cross_attention = True

>>> # Saving the model, including its configuration
>>> model.save_pretrained("my-model")

>>> # loading model and config from pretrained folder
>>> encoder_decoder_config = SpeechEncoderDecoderConfig.from_pretrained("my-model")
>>> model = SpeechEncoderDecoderModel.from_pretrained("my-model", config=encoder_decoder_config)

from_encoder_decoder_configs

<来源>

( encoder_config: PretrainedConfig decoder_config: PretrainedConfig **kwargs ) → export const metadata = 'undefined';SpeechEncoderDecoderConfig

返回

SpeechEncoderDecoderConfig

配置对象的实例

从预训练的编码器模型配置和解码器模型配置实例化一个 SpeechEncoderDecoderConfig（或派生类）。

SpeechEncoderDecoderModel

class transformers.SpeechEncoderDecoderModel

<来源>

( config: Optional = None encoder: Optional = None decoder: Optional = None )

参数

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

此类可用于初始化一个具有任何预训练语音自编码模型作为编码器和任何预训练文本自回归模型作为解码器的语音序列到文本序列模型。编码器通过 from_pretrained()函数加载，解码器通过 from_pretrained()函数加载。交叉注意力层会自动添加到解码器，并应在下游生成任务（如摘要）上进行微调。

在Sascha Rothe, Shashi Narayan, Aliaksei Severyn. Michael Matena, Yanqi Zhou, Wei Li, Peter J. Liu的研究中展示了使用预训练检查点初始化序列到序列模型对序列生成任务的有效性。

此外，在Large-Scale Self- and Semi-Supervised Learning for Speech Translation中展示了如何利用大型预训练语音模型进行语音翻译可以显著提高性能。

在训练/微调了这样一个语音编码器解码器模型之后，它可以像其他模型一样保存/加载（有关更多信息，请参阅示例）。

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

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

SpeechEncoderDecoderModel 是一个通用模型类，当使用:methtransformers.AutoModel.from_pretrained*类方法为编码器创建一个库的基本模型类，并使用:meth*transformers.AutoModelForCausalLM.from_pretrained类方法为解码器创建一个 transformer 架构时，将被实例化。

forward

<来源>

( inputs: Optional = None attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None encoder_outputs: Optional = None past_key_values: Optional = None decoder_inputs_embeds: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None input_values: Optional = None input_features: Optional = None return_dict: Optional = None **kwargs ) → export const metadata = 'undefined';transformers.modeling_outputs.Seq2SeqLMOutput or tuple(torch.FloatTensor)

参数

  • inputs（形状为(batch_size, sequence_length)或(batch_size, sequence_length, feature_dim)的torch.FloatTensor，可选）— 输入原始语音波形或语音特征的浮点值。可以通过将.flac或.wav音频文件加载到List[float]类型的数组或numpy.ndarray中获得值，例如通过 soundfile 库（pip install soundfile）。要将数组准备为inputs，应使用 Wav2Vec2Processor 或 Speech2TextProcessor 进行填充和转换为torch.FloatTensor类型的张量。

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

    • 1 用于“未屏蔽”的标记，

    • 0 用于“屏蔽”的标记。

    什么是注意力掩码？

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

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

    什么是输入 ID？

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

    对于训练，模型会通过将labels向右移动，用pad_token_id替换-100，并在其前面加上decoder_start_token_id来自动创建decoder_input_ids。

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

  • encoder_outputs (tuple(torch.FloatTensor), optional) — 此元组必须包含（last_hidden_state，可选：hidden_states，可选：attentions）last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor）是编码器最后一层的隐藏状态张量。用于解码器的交叉注意力。

  • past_key_values (tuple(tuple(torch.FloatTensor)) of length config.n_layers with each tuple having 4 tensors of shape (batch_size, num_heads, sequence_length - 1, embed_size_per_head)) — 包含注意力块的预计算键和值隐藏状态。可用于加速解码。

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

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

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

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

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

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

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

  • input_values (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 输入原始语音波形的浮点值。可以通过将.flac或.wav音频文件加载到List[float]或numpy.ndarray类型的数组中来获取值，例如通过 soundfile 库（pip install soundfile）。要准备数组为input_values，应使用 Wav2Vec2Processor 进行填充和转换为torch.FloatTensor类型的张量。有关详细信息，请参阅 Wav2Vec2Processor.call()。

  • input_features (torch.FloatTensor of shape (batch_size, sequence_length, feature_size), optional) — 从原始语音波形中提取的 fbank 特征的浮点值。原始语音波形可以通过将.flac或.wav音频文件加载到List[float]类型的数组或numpy.ndarray中获得，例如通过 soundfile 库（pip install soundfile）。要准备好数组为input_features，应使用 Speech2TextFeatureExtractor 来提取 fbank 特征，填充并转换为torch.FloatTensor类型的张量。参见call()

  • return_dict (bool, optional) — 如果设置为True，模型将返回一个~utils.Seq2SeqLMOutput而不是一个普通元组。

  • kwargs (optional) — 剩余的关键字参数字典。关键字参数有两种类型：

    • 在编码器前向函数中作为**encoder_kwargs输入的前缀。

    • 在解码器前向函数中作为**decoder_kwargs输入的decoder_前缀。

返回

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

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

  • loss (torch.FloatTensor of shape (1,), optional, returned when labels is provided) — 语言建模损失。

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

  • past_key_values (tuple(tuple(torch.FloatTensor)), optional, returned when use_cache=True is passed or when 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输入）。

  • decoder_hidden_states (tuple(torch.FloatTensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — torch.FloatTensor元组（如果模型有嵌入层，则为嵌入的输出+每个层的输出）的形状为(batch_size, sequence_length, hidden_size)。

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

  • decoder_attentions (tuple(torch.FloatTensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — torch.FloatTensor元组（每个层一个）的形状为(batch_size, num_heads, sequence_length, sequence_length)。

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

  • cross_attentions (tuple(torch.FloatTensor), optional, returned when output_attentions=True is passed or when 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)，optional) — 模型编码器最后一层的隐藏状态序列。

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

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

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

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

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

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

示例：

>>> from transformers import SpeechEncoderDecoderModel, AutoProcessor
>>> from datasets import load_dataset
>>> import torch

>>> processor = AutoProcessor.from_pretrained("facebook/wav2vec2-xls-r-300m-en-to-15")
>>> model = SpeechEncoderDecoderModel.from_pretrained("facebook/wav2vec2-xls-r-300m-en-to-15")

>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")

>>> input_values = processor(ds[0]["audio"]["array"], return_tensors="pt").input_values
>>> # Inference: Translate English speech to German
>>> generated = model.generate(input_values)
>>> decoded = processor.batch_decode(generated, skip_special_tokens=True)[0]
>>> decoded
'Mr. Quilter ist der Apostel der Mittelschicht und wir freuen uns, sein Evangelium willkommen heißen zu können.'

>>> # Training: Train model on English transcription
>>> labels = processor(text=ds[0]["text"], return_tensors="pt").input_ids

>>> loss = model(input_values, labels=labels).loss
>>> loss.backward()

from_encoder_decoder_pretrained

< source >

( encoder_pretrained_model_name_or_path: str = None decoder_pretrained_model_name_or_path: str = None *model_args **kwargs )

参数

  • encoder_pretrained_model_name_or_path (str, optional) — 初始化编码器所需的信息。可以是：

    • 一个字符串，托管在 huggingface.co 模型库中的预训练模型的模型 id。有效的模型 id 可以位于根级别，如bert-base-uncased，或者在用户或组织名称下命名空间化，如dbmdz/bert-base-german-cased。

    • 一个目录的路径，其中包含使用 save_pretrained()保存的模型权重，例如，./my_model_directory/。

    • 一个tensorflow 索引检查点文件的路径或 url（例如，./tf_model/model.ckpt.index）。在这种情况下，from_tf应设置为True，并且应将配置对象提供为config参数。使用提供的转换脚本将 TensorFlow 检查点转换为 PyTorch 模型并加载 PyTorch 模型的加载路径比较慢。

  • decoder_pretrained_model_name_or_path (str, optional, 默认为None) — 初始化解码器所需的信息。可以是：

    • 一个字符串，托管在 huggingface.co 模型库中的预训练模型的模型 id。有效的模型 id 可以位于根级别，如bert-base-uncased，或者在用户或组织名称下命名空间化，如dbmdz/bert-base-german-cased。

    • 一个目录的路径，其中包含使用 save_pretrained()保存的模型权重，例如，./my_model_directory/。

    • 一个tensorflow 索引检查点文件的路径或 url（例如，./tf_model/model.ckpt.index）。在这种情况下，from_tf应设置为True，并且应将配置对象提供为config参数。使用提供的转换脚本将 TensorFlow 检查点转换为 PyTorch 模型并加载 PyTorch 模型的加载路径比较慢。

  • model_args（剩余的位置参数，optional） — 所有剩余的位置参数将传递给底层模型的__init__方法。

  • kwargs（剩余的关键字参数字典，可选）-可用于更新配置对象（加载后）并初始化模型（例如，output_attentions=True）。

    • 要更新编码器配置，请为每个配置参数使用前缀encoder_。

    • 要更新解码器配置，请为每个配置参数使用前缀decoder_。

    • 要更新父模型配置，请不要为每个配置参数使用前缀。

    根据是否提供config，行为会有所不同或自动加载。

从预训练模型检查点的库中实例化一个编码器和一个解码器。

默认情况下，使用model.eval()将模型设置为评估模式（Dropout 模块被停用）。要训练模型，首先需要使用model.train()将其设置回训练模式。

示例：

>>> from transformers import SpeechEncoderDecoderModel

>>> # initialize a wav2vec2bert from a pretrained Wav2Vec2 and a pretrained BERT model. Note that the cross-attention layers will be randomly initialized
>>> model = SpeechEncoderDecoderModel.from_encoder_decoder_pretrained(
...     "facebook/wav2vec2-base-960h", "bert-base-uncased"
... )
>>> # saving model after fine-tuning
>>> model.save_pretrained("./wav2vec2bert")
>>> # load fine-tuned model
>>> model = SpeechEncoderDecoderModel.from_pretrained("./wav2vec2bert")

FlaxSpeechEncoderDecoderModel

class transformers.FlaxSpeechEncoderDecoderModel

<来源>

( config: SpeechEncoderDecoderConfig input_shape: Optional = None seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )

参数

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

  • dtype（jax.numpy.dtype，可选，默认为jax.numpy.float32）-计算的数据类型。可以是jax.numpy.float32、jax.numpy.float16（在 GPU 上）和jax.numpy.bfloat16（在 TPU 上）之一。

    这可用于在 GPU 或 TPU 上启用混合精度训练或半精度推断。如果指定了dtype，则所有计算将使用给定的数据类型执行。

    请注意，这仅指定了计算的数据类型，并不影响模型参数的数据类型。

    如果要更改模型参数的数据类型，请参阅 to_fp16()和 to_bf16()。

此类可用于使用任何预训练语音自编码模型作为编码器和任何预训练文本自回归模型作为解码器初始化语音序列到文本序列模型。编码器通过 from_pretrained()函数加载，解码器通过 from_pretrained()函数加载。交叉注意力层会自动添加到解码器，并应在下游生成任务（如摘要）上进行微调。

在Sascha Rothe, Shashi Narayan, Aliaksei Severyn. Michael Matena, Yanqi Zhou, Wei Li, Peter J. Liu的论文中展示了使用预训练检查点初始化序列到序列模型以进行序列生成任务的有效性。

此外，在Large-Scale Self- and Semi-Supervised Learning for Speech Translation中展示了如何利用大型预训练语音模型进行语音翻译，从而实现显著的性能提升。

在训练/微调了这样一个语音编码器解码器模型之后，它可以像其他模型一样保存/加载（有关更多信息，请参阅示例）。

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

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

FlaxSpeechEncoderDecoderModel 是一个通用的模型类，当使用:methtransformers.FlaxAutoModel.from_pretrained*类方法为编码器创建时，将实例化为一个变压器架构，其中模块（flax.nn.Module）是库的一个基本模型类的编码器模块，另一个是解码器模块，为解码器创建时使用:meth*transformers.FlaxAutoModelForCausalLM.from_pretrained类方法。

__call__

<来源>

( inputs: Array attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None decoder_position_ids: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None train: bool = False freeze_feature_encoder: bool = False params: dict = None dropout_rng: PRNGKey = None ) → export const metadata = 'undefined';transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput or tuple(torch.FloatTensor)

参数

  • inputs（形状为(batch_size, sequence_length)或(batch_size, sequence_length, feature_dim)的jnp.ndarray，可选）— 输入原始语音波形或语音特征的浮点值。值可以通过将.flac或.wav音频文件加载到List[float]类型的数组或numpy.ndarray中获得，例如通过 soundfile 库（pip install soundfile）。要将数组准备成inputs，应使用 Wav2Vec2Processor 或 Speech2TextProcessor 进行填充和转换为torch.FloatTensor类型的张量。

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

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

    • 0 表示被掩码的标记。

    什么是注意力掩码？

  • decoder_input_ids（形状为(batch_size, target_sequence_length)的jnp.ndarray，可选）— 词汇表中解码器输入序列标记的索引。

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

    什么是输入 ID？

    如果使用了past_key_values，则可选择仅输入最后的decoder_input_ids（参见past_key_values）。

    对于序列到序列训练，应提供decoder_input_ids。decoder_input_ids应在模型外部创建，方法是将labels向右移动，用pad_token_id替换-100，并在decoder_start_token_id之前添加它们。

  • decoder_attention_mask（形状为(batch_size, target_sequence_length)的jnp.ndarray，可选）— 默认行为：生成一个忽略decoder_input_ids中填充标记的张量。因果掩码也将默认使用。

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

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

  • return_dict (bool, 可选) — 如果设置为True，模型将返回一个~utils.FlaxSeq2SeqLMOutput而不是一个普通元组。

返回值

transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput 或tuple(torch.FloatTensor)

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

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

  • past_key_values (tuple(tuple(jnp.ndarray)), 可选, 当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的tuple(jnp.ndarray)元组，每个元组有 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(jnp.ndarray), 可选, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的jnp.ndarray元组（一个用于嵌入输出，一个用于每一层的输出）。

    解码器每一层输出的隐藏状态加上初始嵌入输出。

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

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

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

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

  • encoder_last_hidden_state (jnp.ndarray，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层输出的隐藏状态序列。

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

    编码器每一层输出的隐藏状态加上初始嵌入输出。

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

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

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

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

示例：

>>> from transformers import FlaxSpeechEncoderDecoderModel, AutoTokenizer

>>> # load a fine-tuned wav2vec2-2-bart model
>>> model = FlaxSpeechEncoderDecoderModel.from_pretrained("patrickvonplaten/wav2vec2-2-bart-large")
>>> # load output tokenizer
>>> tokenizer_output = AutoTokenizer.from_pretrained("facebook/bart-large")

>>> inputs = jnp.ones((2, 5000), dtype=jnp.float32)

>>> # use bart's special bos, pad and eos tokens
>>> model.config.decoder_start_token_id = model.decoder.config.bos_token_id
>>> model.config.pad_token_id = model.decoder.config.pad_token_id
>>> model.config.eos_token_id = model.decoder.config.eos_token_id

>>> outputs = model.generate(inputs)
# Assert something? More interesting input? dtype correct?

from_encoder_decoder_pretrained

< source >

( encoder_pretrained_model_name_or_path: Union = None decoder_pretrained_model_name_or_path: Union = None *model_args **kwargs )

参数

  • encoder_pretrained_model_name_or_path（Union[str, os.PathLike]，可选） — 初始化编码器所需的信息。可以是：

    • 一个字符串，托管在 huggingface.co 模型存储库内的预训练模型的模型 ID。有效的模型 ID 可以位于根级别，如bert-base-uncased，或者在用户或组织名称下命名空间，如dbmdz/bert-base-german-cased。

    • 一个目录的路径，其中包含使用 save_pretrained()保存的模型权重，例如，./my_model_directory/。

  • decoder_pretrained_model_name_or_path（Union[str, os.PathLike]，可选，默认为None） — 初始化解码器所需的信息。可以是：

    • 一个字符串，托管在 huggingface.co 模型存储库内的预训练模型的模型 ID。有效的模型 ID 可以位于根级别，如bert-base-uncased，或者在用户或组织名称下命名空间，如dbmdz/bert-base-german-cased。

    • 一个目录的路径，其中包含使用 save_pretrained()保存的模型权重，例如，./my_model_directory/。

  • model_args（剩余的位置参数，可选） — 所有剩余的位置参数将传递给底层模型的__init__方法。

  • kwargs（剩余的关键字参数字典，可选） — 可用于更新配置对象（在加载后）并初始化模型（例如，output_attentions=True）。

    • 要更新编码器配置，请为每个配置参数使用前缀encoder_。

    • 要更新解码器配置，请为每个配置参数使用前缀decoder_。

    • 要更新父模型配置，请不要为每个配置参数使用前缀。

    根据是否提供config或自动加载而表现不同。

从预训练模型检查点的一个或两个库基类实例化编码器和解码器。

示例：

>>> from transformers import FlaxSpeechEncoderDecoderModel

>>> # initialize a wav2vec2-2-bart from pretrained wav2vec2 and bart models. Note that the cross-attention layers will be randomly initialized
>>> model = FlaxSpeechEncoderDecoderModel.from_encoder_decoder_pretrained(
...     "facebook/wav2vec2-large-lv60", "facebook/bart-large"
... )
>>> # saving model after fine-tuning
>>> model.save_pretrained("./wav2vec2-2-bart-large")
>>> # load fine-tuned model
>>> model = FlaxSpeechEncoderDecoderModel.from_pretrained("./wav2vec2-2-bart-large")

TAPAS

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

概述

TAPAS 模型是由 Jonathan Herzig、Paweł Krzysztof Nowak、Thomas Müller、Francesco Piccinno 和 Julian Martin Eisenschlos 在通过预训练实现弱监督表格解析的 TAPAS中提出的。这是一种基于 BERT 的模型，专门设计（和预训练）用于回答关于表格数据的问题。与 BERT 相比，TAPAS 使用相对位置嵌入，并具有 7 种编码表格结构的标记类型。TAPAS 在大型数据集上进行了掩码语言建模（MLM）目标的预训练，该数据集包含来自英文维基百科和相应文本的数百万个表格。

对于问题回答，TAPAS 在顶部有 2 个头：一个单元选择头和一个聚合头，用于（可选地）在选定的单元之间执行聚合（例如计数或求和）。TAPAS 已在多个数据集上进行了微调：

  • SQA（由微软提供的顺序问答）

  • WTQ（由斯坦福大学提供的维基表问题）

  • WikiSQL（由 Salesforce 提供）

它在 SQA 和 WTQ 上取得了最新的成果，同时在 WikiSQL 上的表现与 SOTA 相当，但结构更简单。

该论文的摘要如下：

对表格进行自然语言问题回答通常被视为语义解析任务。为了减轻完整逻辑形式的收集成本，一种流行的方法是专注于弱监督，包括指示而不是逻辑形式。然而，从弱监督训练语义解析器存在困难，并且生成的逻辑形式仅用作检索指示之前的中间步骤。在本文中，我们提出了 TAPAS，一种在表格上回答问题而无需生成逻辑形式的方法。TAPAS 从弱监督中训练，并通过选择表格单元并可选地应用相应的聚合运算符来预测指示。TAPAS 扩展了 BERT 的架构以对表格进行编码，从维基百科爬取的文本段和表格的有效联合预训练进行初始化，并进行端到端训练。我们在三个不同的语义解析数据集上进行实验，发现 TAPAS 在 SQA 上的最新准确率从 55.1 提高到 67.2，与 WIKISQL 和 WIKITQ 上的最新技术相媲美，但模型结构更简单。我们还发现，在我们的设置中，从 WIKISQL 到 WIKITQ 的转移学习，可以获得 48.7 的准确率，比最新技术高出 4.2 个百分点。

此外，作者进一步对 TAPAS 进行了预训练，以识别表格蕴涵，通过创建一个平衡的数据集，其中包含数百万个自动创建的训练示例，这些示例在微调之前的中间步骤中学习。TAPAS 的作者将这种进一步的预训练称为中间预训练（因为 TAPAS 首先在 MLM 上进行预训练，然后在另一个数据集上进行预训练）。他们发现中间预训练进一步提高了在 SQA 上的性能，实现了新的最新技术，以及在TabFact上的最新技术，这是一个包含 16k 维基百科表格的大规模数据集，用于表格蕴涵（二元分类任务）。有关更多详细信息，请参阅他们的后续论文：通过中间预训练理解表格，作者为 Julian Martin Eisenschlos、Syrine Krichene 和 Thomas Müller。

drawing TAPAS 架构。摘自原始博客文章。

这个模型是由nielsr贡献的。这个模型的 Tensorflow 版本是由kamalkraj贡献的。原始代码可以在这里找到。

使用提示

  • TAPAS 默认使用相对位置嵌入（在表格的每个单元格重新启动位置嵌入）。请注意，这是在原始 TAPAS 论文发表后添加的内容。根据作者的说法，这通常会导致略微更好的性能，并且允许您在不耗尽嵌入的情况下编码更长的序列。这反映在 TapasConfig 的reset_position_index_per_cell参数中，默认设置为True。hub上提供的默认版本的模型都使用相对位置嵌入。您仍然可以通过在调用from_pretrained()方法时传入额外参数revision="no_reset"来使用绝对位置嵌入的模型。通常建议在右侧而不是左侧填充输入。

  • TAPAS 基于 BERT，因此例如TAPAS-base对应于BERT-base架构。当然，TAPAS-large将获得最佳性能（论文中报告的结果来自TAPAS-large）。各种大小模型的结果显示在原始 GitHub 存储库上。

  • TAPAS 有在 SQA 上微调的检查点，能够回答与表格相关的问题，这意味着您可以提出后续问题，比如“他多大了？”与之前的问题相关。请注意，在对话设置中，TAPAS 的前向传递有点不同：在这种情况下，您必须逐个向模型提供每个表格-问题对，以便prev_labels令牌类型 id 可以被模型的预测labels覆盖到前一个问题。查看“用法”部分获取更多信息。

  • TAPAS 类似于 BERT，因此依赖于掩码语言建模（MLM）目标。因此，它在预测掩码标记和 NLU 方面效率很高，但不适用于文本生成。使用因果语言建模（CLM）目标训练的模型在这方面更好。请注意，TAPAS 可以作为 EncoderDecoderModel 框架中的编码器使用，将其与自回归文本解码器（如 GPT-2）结合使用。

用法：微调

这里我们解释了如何在自己的数据集上微调 TapasForQuestionAnswering。

步骤 1：选择三种使用 TAPAS 的方式之一 - 或者进行实验

基本上，有三种不同的方式可以微调 TapasForQuestionAnswering，对应于 TAPAS 进行微调的不同数据集：

  1. SQA：如果您对在对话设置中与表相关的后续问题感兴趣。例如，如果您首先问“第一个演员的名字是什么？”然后您可以问一个后续问题，比如“他多大了？”。在这里，问题不涉及任何聚合（所有问题都是单元格选择问题）。

  2. WTQ：如果您对在对话设置中提问不感兴趣，而只是提问与表相关的问题，可能涉及聚合，比如计算行数、求和单元格值或平均单元格值。然后，例如您可以问“Cristiano Ronaldo 在他的职业生涯中进球总数是多少？”。这种情况也被称为弱监督，因为模型本身必须仅根据问题的答案学习适当的聚合操作符（SUM/COUNT/AVERAGE/NONE）。

  3. WikiSQL-supervised: 这个数据集基于 WikiSQL，模型在训练过程中会得到真实的聚合操作符。这也被称为强监督。在这里，学习适当的聚合操作符要容易得多。

总结一下：

任务 示例数据集 描述
对话 SQA 仅单元选择问题的对话
聚合的弱监督 WTQ 问题可能涉及聚合，模型必须仅根据答案作为监督来学习这一点
聚合的强监督 WikiSQL-supervised 问题可能涉及聚合，模型必须学习这一点，给出黄金聚合操作符

Pytorch 隐藏 Pytorch 内容

使用预训练基础模型和从 hub 随机初始化分类头初始化模型可以按照下面所示进行。

>>> from transformers import TapasConfig, TapasForQuestionAnswering

>>> # for example, the base sized model with default SQA configuration
>>> model = TapasForQuestionAnswering.from_pretrained("google/tapas-base")

>>> # or, the base sized model with WTQ configuration
>>> config = TapasConfig.from_pretrained("google/tapas-base-finetuned-wtq")
>>> model = TapasForQuestionAnswering.from_pretrained("google/tapas-base", config=config)

>>> # or, the base sized model with WikiSQL configuration
>>> config = TapasConfig("google-base-finetuned-wikisql-supervised")
>>> model = TapasForQuestionAnswering.from_pretrained("google/tapas-base", config=config)

当然，您不一定要遵循 TAPAS 微调的这三种方式之一。您还可以通过定义初始化 TapasConfig 时想要的任何超参数来进行实验，然后基于该配置创建 TapasForQuestionAnswering。例如，如果您有一个包含对话问题和可能涉及聚合的问题的数据集，那么您可以这样做。这里是一个例子：

>>> from transformers import TapasConfig, TapasForQuestionAnswering

>>> # you can initialize the classification heads any way you want (see docs of TapasConfig)
>>> config = TapasConfig(num_aggregation_labels=3, average_logits_per_cell=True)
>>> # initializing the pre-trained base sized model with our custom classification heads
>>> model = TapasForQuestionAnswering.from_pretrained("google/tapas-base", config=config)

TensorFlow 隐藏 TensorFlow 内容

使用预训练基础模型和从 hub 随机初始化分类头初始化模型可以按照下面所示进行。请确保已安装tensorflow_probability依赖项：

>>> from transformers import TapasConfig, TFTapasForQuestionAnswering

>>> # for example, the base sized model with default SQA configuration
>>> model = TFTapasForQuestionAnswering.from_pretrained("google/tapas-base")

>>> # or, the base sized model with WTQ configuration
>>> config = TapasConfig.from_pretrained("google/tapas-base-finetuned-wtq")
>>> model = TFTapasForQuestionAnswering.from_pretrained("google/tapas-base", config=config)

>>> # or, the base sized model with WikiSQL configuration
>>> config = TapasConfig("google-base-finetuned-wikisql-supervised")
>>> model = TFTapasForQuestionAnswering.from_pretrained("google/tapas-base", config=config)

当然，您不一定要遵循 TAPAS 微调的这三种方式之一。您还可以通过定义初始化 TapasConfig 时想要的任何超参数来进行实验，然后基于该配置创建 TFTapasForQuestionAnswering。例如，如果您有一个包含对话问题和可能涉及聚合的问题的数据集，那么您可以这样做。这里是一个例子：

>>> from transformers import TapasConfig, TFTapasForQuestionAnswering

>>> # you can initialize the classification heads any way you want (see docs of TapasConfig)
>>> config = TapasConfig(num_aggregation_labels=3, average_logits_per_cell=True)
>>> # initializing the pre-trained base sized model with our custom classification heads
>>> model = TFTapasForQuestionAnswering.from_pretrained("google/tapas-base", config=config)

您还可以从已经微调的检查点开始。这里需要注意的是，WTQ 上已经微调的检查点由于 L2 损失有些脆弱。有关更多信息，请参见这里。

要查看 HuggingFace 的 hub 上可用的所有预训练和微调的 TAPAS 检查点，请参见这里。

步骤 2：准备您的数据以 SQA 格式

其次，无论您选择了什么，都应该准备好您的数据集以SQA格式。这种格式是一个带有以下列的 TSV/CSV 文件：

  • id：可选，表-问题对的 ID，用于记录目的。

  • annotator：可选，注释表-问题对的人的 ID，用于记录目的。

  • position: 整数，指示问题是与表相关的第一个、第二个、第三个等等。只有在对话设置（SQA）的情况下才需要（在进行 WTQ/WikiSQL 监督时不需要此列）。

  • question: 字符串

  • table_file: 字符串，包含表格数据的 csv 文件的名称

  • answer_coordinates: 一个或多个元组的列表（每个元组都是答案的单元格坐标，即行列对）

  • answer_text: 一个或多个字符串的列表（每个字符串都是答案的一部分单元格值）

  • aggregation_label: 聚合运算符的索引。只有在强监督聚合的情况下才需要（WikiSQL 监督的情况）。

  • float_answer: 问题的浮点答案，如果有的话（如果没有则为 np.nan）。只有在弱监督聚合的情况下才需要（例如 WTQ 和 WikiSQL）。

表格本身应该存在于一个文件夹中，每个表格都是一个单独的 csv 文件。请注意，TAPAS 算法的作者使用具有一些自动逻辑的转换脚本将其他数据集（WTQ、WikiSQL）转换为 SQA 格式。作者在这里解释了这一点。可以在这里找到一个适用于 HuggingFace 实现的此脚本的转换。有趣的是，这些转换脚本并不完美（answer_coordinates和float_answer字段是基于answer_text填充的），这意味着 WTQ 和 WikiSQL 的结果实际上可能会得到改善。

步骤 3：使用 TapasTokenizer 将数据转换为张量

Pytorch 隐藏 Pytorch 内容

第三，假设您已经准备好了以 TSV/CSV 格式（以及包含表格数据的相应 CSV 文件）的数据，那么您可以使用 TapasTokenizer 将表格问题对转换为input_ids、attention_mask、token_type_ids等。再次根据您选择的三种情况中的哪一种，TapasForQuestionAnswering 需要不同的输入进行微调：

任务 所需输入
对话 input_ids，attention_mask，token_type_ids，labels
弱监督聚合 input_ids，attention_mask，token_type_ids，labels，numeric_values，numeric_values_scale，float_answer
强监督聚合 input ids，attention mask，token type ids，labels，aggregation_labels

TapasTokenizer 根据 TSV 文件的answer_coordinates和answer_text列创建labels、numeric_values和numeric_values_scale。第 2 步的 TSV 文件中已经包含了float_answer和aggregation_labels。以下是一个示例：

>>> from transformers import TapasTokenizer
>>> import pandas as pd

>>> model_name = "google/tapas-base"
>>> tokenizer = TapasTokenizer.from_pretrained(model_name)

>>> data = {"Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"], "Number of movies": ["87", "53", "69"]}
>>> queries = [
...     "What is the name of the first actor?",
...     "How many movies has George Clooney played in?",
...     "What is the total number of movies?",
... ]
>>> answer_coordinates = [[(0, 0)], [(2, 1)], [(0, 1), (1, 1), (2, 1)]]
>>> answer_text = [["Brad Pitt"], ["69"], ["209"]]
>>> table = pd.DataFrame.from_dict(data)
>>> inputs = tokenizer(
...     table=table,
...     queries=queries,
...     answer_coordinates=answer_coordinates,
...     answer_text=answer_text,
...     padding="max_length",
...     return_tensors="pt",
... )
>>> inputs
{'input_ids': tensor([[ ... ]]), 'attention_mask': tensor([[...]]), 'token_type_ids': tensor([[[...]]]),
'numeric_values': tensor([[ ... ]]), 'numeric_values_scale: tensor([[ ... ]]), labels: tensor([[ ... ]])}

请注意，TapasTokenizer 期望表格数据为仅文本。您可以在数据框上使用.astype(str)将其转换为仅文本数据。当然，这只是如何对单个训练示例进行编码的示例。建议创建一个数据加载器以迭代处理批次：

>>> import torch
>>> import pandas as pd

>>> tsv_path = "your_path_to_the_tsv_file"
>>> table_csv_path = "your_path_to_a_directory_containing_all_csv_files"

>>> class TableDataset(torch.utils.data.Dataset):
...     def __init__(self, data, tokenizer):
...         self.data = data
...         self.tokenizer = tokenizer

...     def __getitem__(self, idx):
...         item = data.iloc[idx]
...         table = pd.read_csv(table_csv_path + item.table_file).astype(
...             str
...         )  # be sure to make your table data text only
...         encoding = self.tokenizer(
...             table=table,
...             queries=item.question,
...             answer_coordinates=item.answer_coordinates,
...             answer_text=item.answer_text,
...             truncation=True,
...             padding="max_length",
...             return_tensors="pt",
...         )
...         # remove the batch dimension which the tokenizer adds by default
...         encoding = {key: val.squeeze(0) for key, val in encoding.items()}
...         # add the float_answer which is also required (weak supervision for aggregation case)
...         encoding["float_answer"] = torch.tensor(item.float_answer)
...         return encoding

...     def __len__(self):
...         return len(self.data)

>>> data = pd.read_csv(tsv_path, sep="\t")
>>> train_dataset = TableDataset(data, tokenizer)
>>> train_dataloader = torch.utils.data.DataLoader(train_dataset, batch_size=32)

TensorFlow 隐藏 TensorFlow 内容

第三，假设您已经准备好了以 TSV/CSV 格式（以及包含表格数据的相应 CSV 文件）的数据，那么您可以使用 TapasTokenizer 将表格问题对转换为input_ids、attention_mask、token_type_ids等。再次根据您选择的三种情况中的哪一种，TFTapasForQuestionAnswering 需要不同的输入进行微调：

任务 所需输入
会话 input_ids，attention_mask，token_type_ids，labels
聚合的弱监督 input_ids，attention_mask，token_type_ids，labels，numeric_values，numeric_values_scale，float_answer
聚合的强监督 input ids，attention mask，token type ids，labels，aggregation_labels

TapasTokenizer 根据 TSV 文件的answer_coordinates和answer_text列创建labels，numeric_values和numeric_values_scale。第 2 步的 TSV 文件中已经包含了float_answer和aggregation_labels。以下是一个示例：

>>> from transformers import TapasTokenizer
>>> import pandas as pd

>>> model_name = "google/tapas-base"
>>> tokenizer = TapasTokenizer.from_pretrained(model_name)

>>> data = {"Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"], "Number of movies": ["87", "53", "69"]}
>>> queries = [
...     "What is the name of the first actor?",
...     "How many movies has George Clooney played in?",
...     "What is the total number of movies?",
... ]
>>> answer_coordinates = [[(0, 0)], [(2, 1)], [(0, 1), (1, 1), (2, 1)]]
>>> answer_text = [["Brad Pitt"], ["69"], ["209"]]
>>> table = pd.DataFrame.from_dict(data)
>>> inputs = tokenizer(
...     table=table,
...     queries=queries,
...     answer_coordinates=answer_coordinates,
...     answer_text=answer_text,
...     padding="max_length",
...     return_tensors="tf",
... )
>>> inputs
{'input_ids': tensor([[ ... ]]), 'attention_mask': tensor([[...]]), 'token_type_ids': tensor([[[...]]]),
'numeric_values': tensor([[ ... ]]), 'numeric_values_scale: tensor([[ ... ]]), labels: tensor([[ ... ]])}

请注意，TapasTokenizer 期望表格数据为仅文本。您可以在数据框上使用.astype(str)将其转换为仅文本数据。当然，这仅显示了如何对单个训练示例进行编码。建议创建数据加载器以迭代处理批次：

>>> import tensorflow as tf
>>> import pandas as pd

>>> tsv_path = "your_path_to_the_tsv_file"
>>> table_csv_path = "your_path_to_a_directory_containing_all_csv_files"

>>> class TableDataset:
...     def __init__(self, data, tokenizer):
...         self.data = data
...         self.tokenizer = tokenizer

...     def __iter__(self):
...         for idx in range(self.__len__()):
...             item = self.data.iloc[idx]
...             table = pd.read_csv(table_csv_path + item.table_file).astype(
...                 str
...             )  # be sure to make your table data text only
...             encoding = self.tokenizer(
...                 table=table,
...                 queries=item.question,
...                 answer_coordinates=item.answer_coordinates,
...                 answer_text=item.answer_text,
...                 truncation=True,
...                 padding="max_length",
...                 return_tensors="tf",
...             )
...             # remove the batch dimension which the tokenizer adds by default
...             encoding = {key: tf.squeeze(val, 0) for key, val in encoding.items()}
...             # add the float_answer which is also required (weak supervision for aggregation case)
...             encoding["float_answer"] = tf.convert_to_tensor(item.float_answer, dtype=tf.float32)
...             yield encoding["input_ids"], encoding["attention_mask"], encoding["numeric_values"], encoding[
...                 "numeric_values_scale"
...             ], encoding["token_type_ids"], encoding["labels"], encoding["float_answer"]

...     def __len__(self):
...         return len(self.data)

>>> data = pd.read_csv(tsv_path, sep="\t")
>>> train_dataset = TableDataset(data, tokenizer)
>>> output_signature = (
...     tf.TensorSpec(shape=(512,), dtype=tf.int32),
...     tf.TensorSpec(shape=(512,), dtype=tf.int32),
...     tf.TensorSpec(shape=(512,), dtype=tf.float32),
...     tf.TensorSpec(shape=(512,), dtype=tf.float32),
...     tf.TensorSpec(shape=(512, 7), dtype=tf.int32),
...     tf.TensorSpec(shape=(512,), dtype=tf.int32),
...     tf.TensorSpec(shape=(512,), dtype=tf.float32),
... )
>>> train_dataloader = tf.data.Dataset.from_generator(train_dataset, output_signature=output_signature).batch(32)

请注意，在这里，我们独立对每个表格-问题对进行编码。只要您的数据集不是会话式，这样做就没问题。如果您的数据集涉及会话式问题（例如 SQA），那么您应该首先按表格（按其position索引顺序）将queries，answer_coordinates和answer_text分组在一起，并批量对每个表格及其问题进行编码。这将确保prev_labels标记类型（请参阅 TapasTokenizer 文档）被正确设置。有关更多信息，请参阅此笔记本。有关使用 TensorFlow 模型的更多信息，请参阅此笔记本。

**步骤 4：训练（微调）模型

Pytorch 隐藏 Pytorch 内容

然后可以按照以下方式对 TapasForQuestionAnswering 进行微调（这里展示了聚合案例的弱监督）：

>>> from transformers import TapasConfig, TapasForQuestionAnswering, AdamW

>>> # this is the default WTQ configuration
>>> config = TapasConfig(
...     num_aggregation_labels=4,
...     use_answer_as_supervision=True,
...     answer_loss_cutoff=0.664694,
...     cell_selection_preference=0.207951,
...     huber_loss_delta=0.121194,
...     init_cell_selection_weights_to_zero=True,
...     select_one_column=True,
...     allow_empty_column_selection=False,
...     temperature=0.0352513,
... )
>>> model = TapasForQuestionAnswering.from_pretrained("google/tapas-base", config=config)

>>> optimizer = AdamW(model.parameters(), lr=5e-5)

>>> model.train()
>>> for epoch in range(2):  # loop over the dataset multiple times
...     for batch in train_dataloader:
...         # get the inputs;
...         input_ids = batch["input_ids"]
...         attention_mask = batch["attention_mask"]
...         token_type_ids = batch["token_type_ids"]
...         labels = batch["labels"]
...         numeric_values = batch["numeric_values"]
...         numeric_values_scale = batch["numeric_values_scale"]
...         float_answer = batch["float_answer"]

...         # zero the parameter gradients
...         optimizer.zero_grad()

...         # forward + backward + optimize
...         outputs = model(
...             input_ids=input_ids,
...             attention_mask=attention_mask,
...             token_type_ids=token_type_ids,
...             labels=labels,
...             numeric_values=numeric_values,
...             numeric_values_scale=numeric_values_scale,
...             float_answer=float_answer,
...         )
...         loss = outputs.loss
...         loss.backward()
...         optimizer.step()

TensorFlow 隐藏 TensorFlow 内容

然后可以按照以下方式对 TFTapasForQuestionAnswering 进行微调（这里展示了聚合案例的弱监督）：

>>> import tensorflow as tf
>>> from transformers import TapasConfig, TFTapasForQuestionAnswering

>>> # this is the default WTQ configuration
>>> config = TapasConfig(
...     num_aggregation_labels=4,
...     use_answer_as_supervision=True,
...     answer_loss_cutoff=0.664694,
...     cell_selection_preference=0.207951,
...     huber_loss_delta=0.121194,
...     init_cell_selection_weights_to_zero=True,
...     select_one_column=True,
...     allow_empty_column_selection=False,
...     temperature=0.0352513,
... )
>>> model = TFTapasForQuestionAnswering.from_pretrained("google/tapas-base", config=config)

>>> optimizer = tf.keras.optimizers.Adam(learning_rate=5e-5)

>>> for epoch in range(2):  # loop over the dataset multiple times
...     for batch in train_dataloader:
...         # get the inputs;
...         input_ids = batch[0]
...         attention_mask = batch[1]
...         token_type_ids = batch[4]
...         labels = batch[-1]
...         numeric_values = batch[2]
...         numeric_values_scale = batch[3]
...         float_answer = batch[6]

...         # forward + backward + optimize
...         with tf.GradientTape() as tape:
...             outputs = model(
...                 input_ids=input_ids,
...                 attention_mask=attention_mask,
...                 token_type_ids=token_type_ids,
...                 labels=labels,
...                 numeric_values=numeric_values,
...                 numeric_values_scale=numeric_values_scale,
...                 float_answer=float_answer,
...             )
...         grads = tape.gradient(outputs.loss, model.trainable_weights)
...         optimizer.apply_gradients(zip(grads, model.trainable_weights))

用法：推断

Pytorch 隐藏 Pytorch 内容

这里我们解释了如何使用 TapasForQuestionAnswering 或 TFTapasForQuestionAnswering 进行推断（即对新数据进行预测）。对于推断，只需向模型提供input_ids，attention_mask和token_type_ids（您可以使用 TapasTokenizer 获取），即可获得 logits。接下来，您可以使用方便的~models.tapas.tokenization_tapas.convert_logits_to_predictions方法将其转换为预测坐标和可选的聚合索引。

但是，请注意，推断取决于设置是否为会话式不同。在非会话式设置中，可以并行对批次中的所有表格-问题对进行推断。以下是一个示例：

>>> from transformers import TapasTokenizer, TapasForQuestionAnswering
>>> import pandas as pd

>>> model_name = "google/tapas-base-finetuned-wtq"
>>> model = TapasForQuestionAnswering.from_pretrained(model_name)
>>> tokenizer = TapasTokenizer.from_pretrained(model_name)

>>> data = {"Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"], "Number of movies": ["87", "53", "69"]}
>>> queries = [
...     "What is the name of the first actor?",
...     "How many movies has George Clooney played in?",
...     "What is the total number of movies?",
... ]
>>> table = pd.DataFrame.from_dict(data)
>>> inputs = tokenizer(table=table, queries=queries, padding="max_length", return_tensors="pt")
>>> outputs = model(**inputs)
>>> predicted_answer_coordinates, predicted_aggregation_indices = tokenizer.convert_logits_to_predictions(
...     inputs, outputs.logits.detach(), outputs.logits_aggregation.detach()
... )

>>> # let's print out the results:
>>> id2aggregation = {0: "NONE", 1: "SUM", 2: "AVERAGE", 3: "COUNT"}
>>> aggregation_predictions_string = [id2aggregation[x] for x in predicted_aggregation_indices]

>>> answers = []
>>> for coordinates in predicted_answer_coordinates:
...     if len(coordinates) == 1:
...         # only a single cell:
...         answers.append(table.iat[coordinates[0]])
...     else:
...         # multiple cells
...         cell_values = []
...         for coordinate in coordinates:
...             cell_values.append(table.iat[coordinate])
...         answers.append(", ".join(cell_values))

>>> display(table)
>>> print("")
>>> for query, answer, predicted_agg in zip(queries, answers, aggregation_predictions_string):
...     print(query)
...     if predicted_agg == "NONE":
...         print("Predicted answer: " + answer)
...     else:
...         print("Predicted answer: " + predicted_agg + " > " + answer)
What is the name of the first actor?
Predicted answer: Brad Pitt
How many movies has George Clooney played in?
Predicted answer: COUNT > 69
What is the total number of movies?
Predicted answer: SUM > 87, 53, 69

TensorFlow 隐藏 TensorFlow 内容

在这里，我们解释了如何使用 TFTapasForQuestionAnswering 进行推断（即在新数据上进行预测）。对于推断，只需要向模型提供input_ids、attention_mask和token_type_ids（可以使用 TapasTokenizer 获得）即可获得 logits。接下来，您可以使用方便的~models.tapas.tokenization_tapas.convert_logits_to_predictions方法将其转换为预测的坐标和可选的聚合索引。

但是，请注意，推断取决于设置是否是对话式。在非对话式设置中，可以并行对批处理中的所有表格-问题对进行推断。以下是一个示例：

>>> from transformers import TapasTokenizer, TFTapasForQuestionAnswering
>>> import pandas as pd

>>> model_name = "google/tapas-base-finetuned-wtq"
>>> model = TFTapasForQuestionAnswering.from_pretrained(model_name)
>>> tokenizer = TapasTokenizer.from_pretrained(model_name)

>>> data = {"Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"], "Number of movies": ["87", "53", "69"]}
>>> queries = [
...     "What is the name of the first actor?",
...     "How many movies has George Clooney played in?",
...     "What is the total number of movies?",
... ]
>>> table = pd.DataFrame.from_dict(data)
>>> inputs = tokenizer(table=table, queries=queries, padding="max_length", return_tensors="tf")
>>> outputs = model(**inputs)
>>> predicted_answer_coordinates, predicted_aggregation_indices = tokenizer.convert_logits_to_predictions(
...     inputs, outputs.logits, outputs.logits_aggregation
... )

>>> # let's print out the results:
>>> id2aggregation = {0: "NONE", 1: "SUM", 2: "AVERAGE", 3: "COUNT"}
>>> aggregation_predictions_string = [id2aggregation[x] for x in predicted_aggregation_indices]

>>> answers = []
>>> for coordinates in predicted_answer_coordinates:
...     if len(coordinates) == 1:
...         # only a single cell:
...         answers.append(table.iat[coordinates[0]])
...     else:
...         # multiple cells
...         cell_values = []
...         for coordinate in coordinates:
...             cell_values.append(table.iat[coordinate])
...         answers.append(", ".join(cell_values))

>>> display(table)
>>> print("")
>>> for query, answer, predicted_agg in zip(queries, answers, aggregation_predictions_string):
...     print(query)
...     if predicted_agg == "NONE":
...         print("Predicted answer: " + answer)
...     else:
...         print("Predicted answer: " + predicted_agg + " > " + answer)
What is the name of the first actor?
Predicted answer: Brad Pitt
How many movies has George Clooney played in?
Predicted answer: COUNT > 69
What is the total number of movies?
Predicted answer: SUM > 87, 53, 69

在对话式设置中，每个表格-问题对必须顺序提供给模型，以便前一个表格-问题对的prev_labels标记类型可以被前一个表格-问题对的预测labels覆盖。再次，更多信息可以在此笔记本（适用于 PyTorch）和此笔记本（适用于 TensorFlow）中找到。

资源

  • 文本分类任务指南

  • 掩码语言建模任务指南

TAPAS 特定输出

class transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutput

<来源>

( loss: Optional = None logits: FloatTensor = None logits_aggregation: FloatTensor = None hidden_states: Optional = None attentions: Optional = None )

参数

  • loss（形状为(1,)的torch.FloatTensor，可选，当提供labels（可能还有answer、aggregation_labels、numeric_values和numeric_values_scale）时返回） — 作为分层单元选择对数似然损失和（可选）半监督回归损失以及（可选）聚合的监督损失的总损失。

  • logits（形状为(batch_size, sequence_length)的torch.FloatTensor） — 每个标记的单元选择头的预测分数。

  • logits_aggregation（torch.FloatTensor，可选，形状为(batch_size, num_aggregation_labels)） — 每个聚合运算符的聚合头的预测分数。

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

TapasForQuestionAnswering 的输出类型。

TapasConfig

class transformers.TapasConfig

<来源>

( 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 = 1024 type_vocab_sizes = [3, 256, 256, 2, 256, 256, 10] initializer_range = 0.02 layer_norm_eps = 1e-12 pad_token_id = 0 positive_label_weight = 10.0 num_aggregation_labels = 0 aggregation_loss_weight = 1.0 use_answer_as_supervision = None answer_loss_importance = 1.0 use_normalized_answer_loss = False huber_loss_delta = None temperature = 1.0 aggregation_temperature = 1.0 use_gumbel_for_cells = False use_gumbel_for_aggregation = False average_approximation_function = 'ratio' cell_selection_preference = None answer_loss_cutoff = None max_num_rows = 64 max_num_columns = 32 average_logits_per_cell = False select_one_column = True allow_empty_column_selection = False init_cell_selection_weights_to_zero = False reset_position_index_per_cell = True disable_per_token_loss = False aggregation_labels = None no_aggregation_label_index = None **kwargs )

参数

  • vocab_size（int，可选，默认为 30522） — TAPAS 模型的词汇表大小。定义了在调用 TapasModel 时可以表示的不同标记的数量。

  • 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"、"swish"和"gelu_new"。

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

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

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

  • type_vocab_sizes (List[int], optional, 默认为[3, 256, 256, 2, 256, 256, 10]) — 在调用 TapasModel 时传递的token_type_ids的词汇大小。

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

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

  • positive_label_weight (float, optional, 默认为 10.0) — 正标签的权重。

  • num_aggregation_labels (int, optional, 默认为 0) — 要预测的聚合运算符数量。

  • aggregation_loss_weight (float, optional, 默认为 1.0) — 聚合损失的重要性权重。

  • use_answer_as_supervision (bool, optional) — 是否将答案作为聚合示例的唯一监督。

  • answer_loss_importance (float, optional, 默认为 1.0) — 回归损失的重要性权重。

  • use_normalized_answer_loss (bool, optional, 默认为False) — 是否通过预测值和期望值的最大值对答案损失进行归一化。

  • huber_loss_delta (float, optional) — 用于计算回归损失的 Delta 参数。

  • temperature (float, optional, 默认为 1.0) — 用于控制（或改变）单元格 logits 概率的偏斜度的值。

  • aggregation_temperature (float, optional, 默认为 1.0) — 缩放聚合 logits 以控制概率的偏斜度。

  • use_gumbel_for_cells (bool, optional, 默认为False) — 是否对单元格选择应用 Gumbel-Softmax。

  • use_gumbel_for_aggregation (bool, optional, 默认为False) — 是否对聚合选择应用 Gumbel-Softmax。

  • average_approximation_function (string, optional, 默认为"ratio") — 计算弱监督情况下单元格期望平均值的方法。可以选择"ratio"、"first_order"或"second_order"之一。

  • cell_selection_preference (float, optional) — 在模糊情况下对单元格选择的偏好。仅适用于聚合的弱监督情况（WTQ、WikiSQL）。如果聚合概率的总质量（不包括“NONE”运算符）高于此超参数，则对示例进行聚合预测。

  • answer_loss_cutoff (float, optional) — 忽略答案损失大于截断值的示例。

  • max_num_rows (int, optional, 默认为 64) — 最大行数。

  • max_num_columns (int, optional, 默认为 32) — 最大列数。

  • average_logits_per_cell (bool, optional, defaults to False) — 是否对每个单元格的 logits 进行平均。

  • select_one_column (bool, optional, defaults to True) — 是否限制模型只选择来自单个列的单元格。

  • allow_empty_column_selection (bool, optional, defaults to False) — 是否允许不选择任何列。

  • init_cell_selection_weights_to_zero (bool, optional, defaults to False) — 是否将单元格选择权重初始化为 0，以便初始概率为 50%。

  • reset_position_index_per_cell (bool, optional, defaults to True) — 是否在每个单元格重新开始位置索引（即使用相对位置嵌入）。

  • disable_per_token_loss (bool, optional, defaults to False) — 是否禁用对单元格的任何（强或弱）监督。

  • aggregation_labels (Dict[int, label], optional) — 用于聚合结果的聚合标签。例如，WTQ 模型具有以下聚合标签：{0: "NONE", 1: "SUM", 2: "AVERAGE", 3: "COUNT"}

  • no_aggregation_label_index (int, optional) — 如果定义了聚合标签，并且其中一个标签表示“无聚合”，则应将其设置为其索引。例如，WTQ 模型在索引 0 处具有“NONE”聚合标签，因此对于这些模型，应将该值设置为 0。

这是用于存储 TapasModel 配置的配置类。它用于根据指定的参数实例化 TAPAS 模型，定义模型架构。使用默认值实例化配置将产生类似于 TAPAS google/tapas-base-finetuned-sqa架构的配置。

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

除 BERT 外的超参数取自原始实现的 run_task_main.py 和 hparam_utils.py。原始实现可在github.com/google-research/tapas/tree/master找到。

示例：

>>> from transformers import TapasModel, TapasConfig

>>> # Initializing a default (SQA) Tapas configuration
>>> configuration = TapasConfig()
>>> # Initializing a model from the configuration
>>> model = TapasModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config

TapasTokenizer

class transformers.TapasTokenizer

< source >

( 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]' empty_token = '[EMPTY]' tokenize_chinese_chars = True strip_accents = None cell_trim_length: int = -1 max_column_id: int = None max_row_id: int = None strip_column_names: bool = False update_answer_coordinates: bool = False min_question_length = None max_question_length = None model_max_length: int = 512 additional_special_tokens: Optional = 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, 默认为 "[MASK]") — 用于屏蔽值的标记。在使用掩码语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。

  • empty_token (str, optional, 默认为 "[EMPTY]") — 用于表格中空单元格值的标记。空单元格值包括""、"n/a"、"nan"和"?"。

  • tokenize_chinese_chars (bool, optional, 默认为 True) — 是否对中文字符进行标记。这对于日语可能应该被停用（参见此问题）。

  • strip_accents (bool, optional) — 是否去除所有重音符号。如果未指定此选项，则将由lowercase的值确定（与原始 BERT 相同）。

  • cell_trim_length (int, optional, 默认为 -1) — 如果 > 0：修剪单元格，使长度 <= 此值。还会禁用进一步的单元格修剪，因此应该与truncation设置为True一起使用。

  • max_column_id (int, optional) — 要提取的最大列 id。

  • max_row_id (int, optional) — 要提取的最大行 id。

  • strip_column_names (bool, optional, 默认为 False) — 是否添加空字符串而不是列名。

  • update_answer_coordinates (bool, optional, 默认为 False) — 是否重新计算答案文本的答案坐标。

  • min_question_length (int, optional) — 每个问题的最小长度，以标记为单位（否则将被跳过）。

  • max_question_length (int, optional) — 每个问题的最大长度，以标记为单位（否则将被跳过）。

构建一个 TAPAS 分词器。基于 WordPiece。将表格和一个或多个相关句子展平，以供 TAPAS 模型使用。

这个分词器继承自 PreTrainedTokenizer，其中包含大部分主要方法。用户应该参考这个超类以获取有关这些方法的更多信息。TapasTokenizer 创建了几个标记类型 id 来编码表格结构。更准确地说，它按照以下顺序添加了 7 个标记类型 id：segment_ids、column_ids、row_ids、prev_labels、column_ranks、inv_column_ranks和numeric_relations：

  • segment_ids: 指示一个标记属于问题（0）还是表格（1）。对于特殊标记和填充，值为 0。

  • column_ids: 指示一个标记属于表格的哪一列（从 1 开始）。对于所有问题标记、特殊标记和填充，值为 0。

  • row_ids: 指示一个标记属于表格的哪一行（从 1 开始）。对于所有问题标记、特殊标记和填充，值为 0。列标题的标记也为 0。

  • prev_labels: 指示一个标记是否是前一个问题的答案的一部分（1）还是不是（0）。在对话设置中很有用（如 SQA）。

  • column_ranks: 指示表格标记相对于列的排名，如果适用的话。例如，如果你有一个列“电影数量”，值为 87、53 和 69，则这些标记的列排名分别为 3、1 和 2。对于所有问题标记、特殊标记和填充，值为 0。

  • inv_column_ranks: 指示表格标记相对于列的逆序排名，如果适用的话。例如，如果你有一个列“电影数量”，值为 87、53 和 69，则这些标记的逆序列排名分别为 1、3 和 2。对于所有问题标记、特殊标记和填充，值为 0。

  • numeric_relations: 指示问题和表格标记之间的数值关系。对于所有问题标记、特殊标记和填充，值为 0。

TapasTokenizer 在表格和相关句子上运行端到端的分词：标点符号拆分和 wordpiece。

__call__

<来源>

( table: pd.DataFrame queries: Union = None answer_coordinates: Union = None answer_text: Union = None add_special_tokens: bool = True padding: Union = False truncation: Union = False max_length: Optional = None 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 )

参数

  • table (pd.DataFrame) — 包含表格数据的表格。请注意，所有单元格的值必须是文本。在 Pandas 数据帧上使用.astype(str)将其转换为字符串。

  • queries (str 或 List[str]) — 与要编码的表格相关的问题或问题批次。请注意，在批处理的情况下，所有问题必须引用相同的表格。

  • answer_coordinates (List[Tuple] 或 List[List[Tuple]], 可选) — 批次中每个表格-问题对的答案坐标。如果只提供单个表格-问题对，则 answer_coordinates 必须是一个包含一个或多个元组的列表。每个元组必须是（行索引，列索引）对。第一行数据行（而不是列标题行）的索引为 0。第一列的索引为 0。如果提供了一个表格-问题对批次，则 answer_coordinates 必须是一个包含元组列表的列表（每个列表对应一个单个表格-问题对）。

  • answer_text (List[str] 或 List[List[str]], 可选) — 批次中每个表格-问题对的答案文本。如果只提供单个表格-问题对，则 answer_text 必须是一个包含一个或多个字符串的列表。每个字符串必须是相应答案坐标的答案文本。如果提供了一个表格-问题对批次，则 answer_coordinates 必须是一个包含元组列表的列表（每个列表对应一个单个表格-问题对）。

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

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

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

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

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

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

    • True 或 'drop_rows_to_fit'：截断到指定长度的最大长度，或者如果未提供该参数，则截断到模型的最大可接受输入长度。这将逐行截断，从表中删除行。

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

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

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

  • is_split_into_words (bool, 可选, 默认为False) — 输入是否已经预分词（例如，已分割为单词）。如果设置为True，分词器会假定输入已经分割为单词（例如，通过在空格上分割），然后对其进行分词。这对于 NER 或标记分类很有用。

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

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

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

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

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

用于对一个或多个与表格相关的序列进行标记化和准备模型的主要方法。

convert_logits_to_predictions

< source >

( data logits logits_agg = None cell_classification_threshold = 0.5 ) → export const metadata = 'undefined';tuple comprising various elements depending on the inputs

参数

  • data (dict) — 将特征映射到实际值的字典。应使用 TapasTokenizer 创建。

  • logits (torch.Tensor 或 tf.Tensor，形状为 (batch_size, sequence_length)) — 包含标记级别上的 logits 的张量。

  • logits_agg (torch.Tensor 或 tf.Tensor，形状为 (batch_size, num_aggregation_labels)，可选) — 包含聚合 logits 的张量。

  • cell_classification_threshold (float，可选，默认为 0.5) — 用于单元格选择的阈值。所有概率大于此阈值的表格单元格将被选择。

返回

包含各种元素的元组，取决于输入

  • predicted_answer_coordinates (List[List[[tuple]]，长度为 batch_size)：预测的答案坐标，作为元组列表的列表。列表中的每个元素包含批次中单个示例的预测答案坐标，作为元组列表。每个元组是一个单元格，即 (行索引，列索引)。

  • predicted_aggregation_indices (List[int]，长度为 batch_size，可选，当提供 logits_aggregation 时返回): 预测的聚合运算符索引。

将 TapasForQuestionAnswering 的 logits 转换为实际预测的答案坐标和可选的聚合索引。

基于此函数的原始实现可在 此处 找到。

save_vocabulary

< source >

( save_directory: str filename_prefix: Optional = None )

PytorchHide Pytorch content

TapasModel

class transformers.TapasModel

< source >

( config add_pooling_layer = True )

参数

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

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

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

这个类与 BertModel 相比有一点小改变，考虑了额外的标记类型 id。

该模型可以作为编码器（仅具有自注意力）以及解码器运行，此时在自注意力层之间添加了一层交叉注意力，遵循Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser 和 Illia Polosukhin描述的架构。

forward

< source >

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None 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.BaseModelOutputWithPooling or tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参见 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

    什么是输入 ID？

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

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

    • 0 表示被掩码的标记。

    什么是注意力掩码？

  • token_type_ids (torch.LongTensor，形状为(batch_size, sequence_length, 7)，optional) — 编码表格结构的标记索引。可以使用 AutoTokenizer 获取索引。有关更多信息，请参见此类。

    什么是标记类型 ID？

  • position_ids (torch.LongTensor，形状为(batch_size, sequence_length)，optional) — 每个输入序列标记在位置嵌入中的位置索引。如果 TapasConfig 的reset_position_index_per_cell设置为True，则将使用相对位置嵌入。选在范围[0, config.max_position_embeddings - 1]内。

    什么是位置 ID？

  • head_mask (torch.FloatTensor，形状为(num_heads,)或(num_layers, num_heads)，optional) — 用于使自注意力模块中选择的头部失效的掩码。掩码值选在[0, 1]范围内：- 1 表示头部未被掩码，- 0 表示头部被掩码。

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

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

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

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

返回

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

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

  • 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), 可选的, 当传递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 之后，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoTokenizer, TapasModel
>>> import pandas as pd

>>> tokenizer = AutoTokenizer.from_pretrained("google/tapas-base")
>>> model = TapasModel.from_pretrained("google/tapas-base")

>>> data = {
...     "Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"],
...     "Age": ["56", "45", "59"],
...     "Number of movies": ["87", "53", "69"],
... }
>>> table = pd.DataFrame.from_dict(data)
>>> queries = ["How many movies has George Clooney played in?", "How old is Brad Pitt?"]

>>> inputs = tokenizer(table=table, queries=queries, padding="max_length", return_tensors="pt")
>>> outputs = model(**inputs)

>>> last_hidden_states = outputs.last_hidden_state

TapasForMaskedLM

class transformers.TapasForMaskedLM

<来源>

( config )

参数

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

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

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

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None encoder_hidden_states: Optional = None encoder_attention_mask: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None **kwargs ) → 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？

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

    • 对于未被掩码的令牌为 1，

    • 对于被掩码的令牌为 0。

    什么是注意力掩码？

  • token_type_ids（形状为(batch_size, sequence_length, 7)的torch.LongTensor，可选）— 编码表格结构的令牌索引。可以使用 AutoTokenizer 获取索引。有关更多信息，请参见此类。

    什么是令牌类型 ID？

  • position_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 每个输入序列令牌在位置嵌入中的位置索引。如果 TapasConfig 的reset_position_index_per_cell设置为True，将使用相对位置嵌入。在范围[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，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的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的令牌将被忽略（掩码），损失仅计算具有标签在[0, ..., config.vocab_size]范围内的令牌。

返回

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

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

  • loss（形状为(1,)的torch.FloatTensor，可选，在提供labels时返回）— 掩码语言建模（MLM）损失。

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

  • hidden_states (tuple(torch.FloatTensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — Tuple of torch.FloatTensor (one for the output of the embeddings, if the model has an embedding layer, + one for the output of each layer) of shape (batch_size, sequence_length, hidden_size)。

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

  • attentions (tuple(torch.FloatTensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — Tuple of torch.FloatTensor (one for each layer) of shape (batch_size, num_heads, sequence_length, sequence_length)。

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

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

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

示例：

>>> from transformers import AutoTokenizer, TapasForMaskedLM
>>> import pandas as pd

>>> tokenizer = AutoTokenizer.from_pretrained("google/tapas-base")
>>> model = TapasForMaskedLM.from_pretrained("google/tapas-base")

>>> data = {
...     "Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"],
...     "Age": ["56", "45", "59"],
...     "Number of movies": ["87", "53", "69"],
... }
>>> table = pd.DataFrame.from_dict(data)

>>> inputs = tokenizer(
...     table=table, queries="How many [MASK] has George [MASK] played in?", return_tensors="pt"
... )
>>> labels = tokenizer(
...     table=table, queries="How many movies has George Clooney played in?", return_tensors="pt"
... )["input_ids"]

>>> outputs = model(**inputs, labels=labels)
>>> logits = outputs.logits

TapasForSequenceClassification

class transformers.TapasForSequenceClassification

<来源>

( config )

参数

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

在顶部具有序列分类头的 Tapas 模型（在池化输出的顶部有一个线性层），例如用于表格推理任务的 TabFact（Chen 等，2020）。

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

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

forward

<来源>

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

参数

  • input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。

    什么是输入 ID？

  • 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, 7), optional) — 编码表格结构的标记索引。可以使用 AutoTokenizer 获取索引。有关更多信息，请参阅此类。

    什么是 token type IDs?

  • position_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 每个输入序列标记在位置嵌入中的位置索引。如果 TapasConfig 的reset_position_index_per_cell设置为True，将使用相对位置嵌入。选择范围为[0, config.max_position_embeddings - 1]。

    什么是 position IDs?

  • head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于使自注意力模块的选定头部无效的掩码。掩码值选择在[0, 1]范围内：- 1 表示头部未被掩码，- 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，则计算分类损失（交叉熵）。注意：在原始实现中称为“classification_class_index”。

返回

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

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

  • 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)，可选，当传递 output_attentions=True 或 config.output_attentions=True 时返回）— 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 torch.FloatTensor 元组（每层一个）。

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

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

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

示例：

>>> from transformers import AutoTokenizer, TapasForSequenceClassification
>>> import torch
>>> import pandas as pd

>>> tokenizer = AutoTokenizer.from_pretrained("google/tapas-base-finetuned-tabfact")
>>> model = TapasForSequenceClassification.from_pretrained("google/tapas-base-finetuned-tabfact")

>>> data = {
...     "Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"],
...     "Age": ["56", "45", "59"],
...     "Number of movies": ["87", "53", "69"],
... }
>>> table = pd.DataFrame.from_dict(data)
>>> queries = [
...     "There is only one actor who is 45 years old",
...     "There are 3 actors which played in more than 60 movies",
... ]

>>> inputs = tokenizer(table=table, queries=queries, padding="max_length", return_tensors="pt")
>>> labels = torch.tensor([1, 0])  # 1 means entailed, 0 means refuted

>>> outputs = model(**inputs, labels=labels)
>>> loss = outputs.loss
>>> logits = outputs.logits

TapasForQuestionAnswering

class transformers.TapasForQuestionAnswering

< source >

( config: TapasConfig )

参数

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

Tapas 模型具有用于表格问答任务的单元选择头和可选的聚合头（用于计算 logits 和可选的 logits_aggregation 的隐藏状态输出上的线性层），例如用于 SQA、WTQ 或 WikiSQL 监督任务。

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

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

前进

< source >

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None table_mask: Optional = None labels: Optional = None aggregation_labels: Optional = None float_answer: Optional = None numeric_values: Optional = None numeric_values_scale: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutput 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]：

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

    • 对于被 masked 的标记为 0。

    什么是注意力掩码？

  • token_type_ids（形状为 (batch_size, sequence_length, 7) 的 torch.LongTensor，可选）— 编码表格结构的标记索引。可以使用 AutoTokenizer 获取索引。查看此类获取更多信息。

    什么是标记类型 ID？

  • position_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 每个输入序列标记在位置嵌入中的位置索引。如果 TapasConfig 的reset_position_index_per_cell设置为True，将使用相对位置嵌入。选择范围为[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 而不是一个普通的元组。

  • table_mask (torch.LongTensor of shape (batch_size, seq_length), optional) — 表的掩码。指示哪些标记属于表格（1）。问题标记、表头和填充为 0。

  • labels (torch.LongTensor of shape (batch_size, seq_length), optional) — 用于计算分层单元选择损失的每个标记的标签。这编码了答案在表中出现的位置。可以使用 AutoTokenizer 获得。

    • 1 表示是答案的标记，

    • 0 表示不是答案的标记。

  • aggregation_labels (torch.LongTensor of shape (batch_size, ), optional) — 用于计算聚合损失的批次中每个示例的聚合函数索引。索引应在[0, ..., config.num_aggregation_labels - 1]范围内。仅在强监督聚合（WikiSQL-supervised）的情况下需要。

  • float_answer (torch.FloatTensor of shape (batch_size, ), optional) — 批次中每个示例的浮点答案。对于单元选择问题，设置为float(‘nan’)。仅在弱监督（WTQ）的情况下需要计算聚合掩码和回归损失。

  • numeric_values (torch.FloatTensor of shape (batch_size, seq_length), optional) — 每个标记的数值，对于不是数值的标记为 NaN。可以使用 AutoTokenizer 获得。仅在弱监督聚合（WTQ）的情况下需要计算回归损失。

  • numeric_values_scale (torch.FloatTensor of shape (batch_size, seq_length), optional) — 每个标记的数值的规模。可以使用 AutoTokenizer 获得。仅在弱监督聚合（WTQ）的情况下需要计算回归损失。

返回

transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutput 或 tuple(torch.FloatTensor)

一个 transformers.models.tapas.modeling_tapas.TableQuestionAnsweringOutput 或一个torch.FloatTensor元组（如果传递了return_dict=False或config.return_dict=False）包括根据配置（TapasConfig）和输入的不同元素。

  • loss (torch.FloatTensor，形状为(1,)，可选，当提供labels（可能还有answer、aggregation_labels、numeric_values和numeric_values_scale）时返回) — 作为分层单元选择对数似然损失的总和以及（可选）半监督回归损失和（可选）聚合的监督损失的总损失。

  • logits (torch.FloatTensor，形状为(batch_size, sequence_length)) — 每个标记的单元选择头的预测分数。

  • logits_aggregation (torch.FloatTensor, 可选, 形状为(batch_size, num_aggregation_labels)) — 聚合头的预测分数，对于每个聚合运算符。

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

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

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

示例：

>>> from transformers import AutoTokenizer, TapasForQuestionAnswering
>>> import pandas as pd

>>> tokenizer = AutoTokenizer.from_pretrained("google/tapas-base-finetuned-wtq")
>>> model = TapasForQuestionAnswering.from_pretrained("google/tapas-base-finetuned-wtq")

>>> data = {
...     "Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"],
...     "Age": ["56", "45", "59"],
...     "Number of movies": ["87", "53", "69"],
... }
>>> table = pd.DataFrame.from_dict(data)
>>> queries = ["How many movies has George Clooney played in?", "How old is Brad Pitt?"]

>>> inputs = tokenizer(table=table, queries=queries, padding="max_length", return_tensors="pt")
>>> outputs = model(**inputs)

>>> logits = outputs.logits
>>> logits_aggregation = outputs.logits_aggregation

TensorFlowHide TensorFlow 内容

TFTapasModel

class transformers.TFTapasModel

<来源>

( config: TapasConfig *inputs **kwargs )

参数

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

裸的 Tapas 模型变换器输出原始的隐藏状态，没有任何特定的头部。

这个模型继承自 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})

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

call

< source >

( input_ids: TFModelInputType | 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 training: Optional[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()。

    什么是输入 IDs？

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

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

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

    什么是注意力掩码？

  • token_type_ids (np.ndarray 或 tf.Tensor，形状为 (batch_size, sequence_length, 7)，可选) — 编码表格结构的标记索引。可以使用 AutoTokenizer 获取索引。查看此类以获取更多信息。

    什么是 token type IDs？

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

    什么是位置 IDs？

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

    • 值为 1 表示头部未被 masked。

    • 值为 0 表示头部被 masked。

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

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

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

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

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

返回

transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling 或tf.Tensor元组

一个 transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling 或一个tf.Tensor元组（如果传递return_dict=False或config.return_dict=False）包括根据配置（TapasConfig）和输入的不同元素。

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

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

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

示例：

>>> from transformers import AutoTokenizer, TapasModel
>>> import pandas as pd

>>> tokenizer = AutoTokenizer.from_pretrained("google/tapas-base")
>>> model = TapasModel.from_pretrained("google/tapas-base")

>>> data = {
...     "Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"],
...     "Age": ["56", "45", "59"],
...     "Number of movies": ["87", "53", "69"],
... }
>>> table = pd.DataFrame.from_dict(data)
>>> queries = ["How many movies has George Clooney played in?", "How old is Brad Pitt?"]

>>> inputs = tokenizer(table=table, queries=queries, padding="max_length", return_tensors="tf")
>>> outputs = model(**inputs)

>>> last_hidden_states = outputs.last_hidden_state

TFTapasForMaskedLM

class transformers.TFTapasForMaskedLM

<来源>

( config: TapasConfig *inputs **kwargs )

参数

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

带有顶部的语言建模头的 Tapas 模型。

此模型继承自 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 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（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 用于“未被掩蔽”的标记，

    • 0 用于“被掩蔽”的标记。

    什么是注意力掩码？

  • token_type_ids（形状为(batch_size, sequence_length, 7)的np.ndarray或tf.Tensor，可选）— 编码表格结构的标记索引。可以使用 AutoTokenizer 获取索引。查看此类以获取更多信息。

    什么是标记类型 ID？

  • position_ids (np.ndarray 或形状为(batch_size, sequence_length)的tf.Tensor，optional) — 每个输入序列标记在位置嵌入中的位置索引。如果 TapasConfig 的reset_position_index_per_cell设置为True，将使用相对位置嵌入。在范围[0, config.max_position_embeddings - 1]中选择。

    什么是位置 ID？

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

    • 1 表示头部未被掩码,

    • 0 表示头部被掩码。

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

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

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

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

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

  • labels (tf.Tensor 或形状为(batch_size, sequence_length)的np.ndarray，optional) — 用于计算掩码语言建模损失的标签。索引应在[-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时）包含各种元素，具体取决于配置（TapasConfig）和输入。

  • loss (tf.Tensor，形状为(n,)，optional，当提供labels时返回，其中 n 是非掩码标签的数量) — 掩码语言建模（MLM）损失。

  • logits (tf.Tensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头部的预测分数（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)，可选，当传递output_attentions=True或config.output_attentions=True时返回） - 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。

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

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

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

示例：

>>> from transformers import AutoTokenizer, TapasForMaskedLM
>>> import pandas as pd

>>> tokenizer = AutoTokenizer.from_pretrained("google/tapas-base")
>>> model = TapasForMaskedLM.from_pretrained("google/tapas-base")

>>> data = {
...     "Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"],
...     "Age": ["56", "45", "59"],
...     "Number of movies": ["87", "53", "69"],
... }
>>> table = pd.DataFrame.from_dict(data)

>>> inputs = tokenizer(
...     table=table, queries="How many [MASK] has George [MASK] played in?", return_tensors="tf"
... )
>>> labels = tokenizer(
...     table=table, queries="How many movies has George Clooney played in?", return_tensors="tf"
... )["input_ids"]

>>> outputs = model(**inputs, labels=labels)
>>> logits = outputs.logits

TFTapasForSequenceClassification

class transformers.TFTapasForSequenceClassification

<来源>

( config: TapasConfig *inputs **kwargs )

参数

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

在顶部具有序列分类头的 Tapas 模型（在汇总输出的顶部有一个线性层），例如用于表格蕴涵任务，如 TabFact（Chen 等，2020）。

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

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

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

  • 将所有输入作为关键字参数（类似于 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 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 (np.ndarray，tf.Tensor，List[tf.Tensor]，Dict[str, tf.Tensor] 或 Dict[str, np.ndarray]，每个示例的形状必须为 (batch_size, num_choices, sequence_length)） — 词汇表中输入序列标记的索引。

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

    什么是输入 ID？

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

    • 对于未屏蔽的标记，

    • 0 对于被屏蔽的标记。

    什么是注意力掩码？

  • token_type_ids (np.ndarray 或 tf.Tensor，形状为 (batch_size, num_choices, sequence_length, 7)，可选) — 编码表格结构的标记索引。可以使用 AutoTokenizer 获取索引。查看此类以获取更多信息。

    什么是标记类型 ID？

  • position_ids (np.ndarray 或 tf.Tensor，形状为 (batch_size, num_choices, sequence_length)，可选) — 每个输入序列标记在位置嵌入中的位置索引。如果 TapasConfig 的 reset_position_index_per_cell 设置为 True，将使用相对位置嵌入。选择范围为 [0, config.max_position_embeddings - 1]。

    什么是位置 ID？

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

    • 1 表示头部未被屏蔽，

    • 0 表示头部被屏蔽。

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

  • output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。查看返回张量中的 attentions 以获取更多细节。此参数仅在急切模式下可用，在图模式下将使用配置中的值。

  • output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。查看返回张量中的 hidden_states 以获取更多细节。此参数仅在急切模式下可用，在图模式下将使用配置中的值。

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

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

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

返回

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

一个 transformers.modeling_tf_outputs.TFSequenceClassifierOutput 或者一个tf.Tensor元组（如果传入return_dict=False或者当config.return_dict=False时）包含各种元素，取决于配置（TapasConfig）和输入。

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

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

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

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

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

示例：

>>> from transformers import AutoTokenizer, TapasForSequenceClassification
>>> import tensorflow as tf
>>> import pandas as pd

>>> tokenizer = AutoTokenizer.from_pretrained("google/tapas-base-finetuned-tabfact")
>>> model = TapasForSequenceClassification.from_pretrained("google/tapas-base-finetuned-tabfact")

>>> data = {
...     "Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"],
...     "Age": ["56", "45", "59"],
...     "Number of movies": ["87", "53", "69"],
... }
>>> table = pd.DataFrame.from_dict(data)
>>> queries = [
...     "There is only one actor who is 45 years old",
...     "There are 3 actors which played in more than 60 movies",
... ]

>>> inputs = tokenizer(table=table, queries=queries, padding="max_length", return_tensors="tf")
>>> labels = tf.convert_to_tensor([1, 0])  # 1 means entailed, 0 means refuted

>>> outputs = model(**inputs, labels=labels)
>>> loss = outputs.loss
>>> logits = outputs.logits

TFTapasForQuestionAnswering

class transformers.TFTapasForQuestionAnswering

< source >

( config: TapasConfig *inputs **kwargs )

参数

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

Tapas 模型，带有单元选择头和可选的聚合头，用于表格上的问答任务（在隐藏状态输出的顶部进行线性层计算logits和可选的logits_aggregation），例如用于 SQA、WTQ 或 WikiSQL 监督任务。

此模型继承自 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 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 table_mask: np.ndarray | tf.Tensor | None = None aggregation_labels: np.ndarray | tf.Tensor | None = None float_answer: np.ndarray | tf.Tensor | None = None numeric_values: np.ndarray | tf.Tensor | None = None numeric_values_scale: 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.models.tapas.modeling_tf_tapas.TFTableQuestionAnsweringOutput 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 或形状为(batch_size, sequence_length)的tf.Tensor，可选) — 避免在填充标记索引上执行注意力的蒙版。蒙版值选择在[0, 1]之间：

    • 1 表示标记未被masked，

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

    注意力蒙版是什么？

  • token_type_ids (np.ndarray 或形状为(batch_size, sequence_length, 7)的tf.Tensor，可选) — 编码表格结构的标记索引。可以使用 AutoTokenizer 获取索引。查看此类获取更多信息。

    什么是标记类型 ID？

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

    什么是位置 ID？

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

    • 1 表示头部未被masked，

    • 0 表示头部被masked。

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

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

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

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

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

  • table_mask (tf.Tensor，形状为(batch_size, seq_length)，optional) — 表的掩码。指示哪些标记属于表格（1）。问题标记、表头和填充为 0。

  • labels (tf.Tensor，形状为(batch_size, seq_length)，optional) — 用于计算分层单元选择损失的每个标记的标签。这编码了答案在表中出现的位置。可以使用 AutoTokenizer 获得。

    • 1 表示是答案的一部分，

    • 0 表示不是答案的标记。

  • aggregation_labels (tf.Tensor，形状为(batch_size, )，optional) — 用于计算聚合损失的每个示例的聚合函数索引。索引应在[0, ..., config.num_aggregation_labels - 1]范围内。仅在强监督的情况下用于聚合（WikiSQL-supervised）。

  • float_answer (tf.Tensor，形状为(batch_size, )，optional) — 批次中每个示例的浮点答案。对于单元选择问题，设置为float('nan')。仅在弱监督（WTQ）的情况下需要，以计算聚合掩码和回归损失。

  • numeric_values (tf.Tensor，形状为(batch_size, seq_length)，optional) — 每个标记的数值，对于不是数值的标记为 NaN。可以使用 AutoTokenizer 获得。仅在弱监督的情况下用于聚合（WTQ）以计算回归损失。

  • numeric_values_scale (tf.Tensor，形状为(batch_size, seq_length)，optional) — 每个标记的数值的规模。可以使用 AutoTokenizer 获得。仅在弱监督的情况下用于聚合（WTQ）以计算回归损失。

返回

transformers.models.tapas.modeling_tf_tapas.TFTableQuestionAnsweringOutput或tuple(tf.Tensor)

一个transformers.models.tapas.modeling_tf_tapas.TFTableQuestionAnsweringOutput或一个tf.Tensor元组（如果传递了return_dict=False或当config.return_dict=False时），包括根据配置（TapasConfig）和输入而异的各种元素。

  • 损失 (tf.Tensor 的形状为 (1,), 可选的, 当提供 labels（可能还有 answer, aggregation_labels, numeric_values 和 numeric_values_scale）时返回) — 总损失，由层次单元选择对数似然损失的总和以及（可选的）半监督回归损失和（可选的）聚合的监督损失组成。

  • logits (tf.Tensor 的形状为 (batch_size, sequence_length)) — 每个标记的单元选择头的预测分数。

  • logits_aggregation (tf.Tensor, 可选的, 形状为 (batch_size, num_aggregation_labels)) — 每个聚合操作符的聚合头的预测分数。

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

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

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

示例:

>>> from transformers import AutoTokenizer, TapasForQuestionAnswering
>>> import pandas as pd

>>> tokenizer = AutoTokenizer.from_pretrained("google/tapas-base-finetuned-wtq")
>>> model = TapasForQuestionAnswering.from_pretrained("google/tapas-base-finetuned-wtq")

>>> data = {
...     "Actors": ["Brad Pitt", "Leonardo Di Caprio", "George Clooney"],
...     "Age": ["56", "45", "59"],
...     "Number of movies": ["87", "53", "69"],
... }
>>> table = pd.DataFrame.from_dict(data)
>>> queries = ["How many movies has George Clooney played in?", "How old is Brad Pitt?"]

>>> inputs = tokenizer(table=table, queries=queries, padding="max_length", return_tensors="tf")
>>> outputs = model(**inputs)

>>> logits = outputs.logits
>>> logits_aggregation = outputs.logits_aggregation

TrOCR

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

概述

TrOCR 模型是由 Minghao Li、Tengchao Lv、Lei Cui、Yijuan Lu、Dinei Florencio、Cha Zhang、Zhoujun Li、Furu Wei 在TrOCR: Transformer-based Optical Character Recognition with Pre-trained Models中提出的。TrOCR 包括一个图像 Transformer 编码器和一个自回归文本 Transformer 解码器，用于执行光学字符识别（OCR）。

论文的摘要如下：

文本识别是文档数字化的一个长期研究问题。现有的文本识别方法通常基于 CNN 进行图像理解和基于 RNN 进行字符级文本生成。此外，通常需要另一个语言模型作为后处理步骤来提高整体准确性。在本文中，我们提出了一种端到端的文本识别方法，使用预训练的图像 Transformer 和文本 Transformer 模型，即 TrOCR，它利用 Transformer 架构进行图像理解和词片级文本生成。TrOCR 模型简单而有效，可以使用大规模合成数据进行预训练，并使用人工标记的数据集进行微调。实验表明，TrOCR 模型在印刷和手写文本识别任务上优于当前最先进的模型。

drawing TrOCR 架构。摘自原始论文。

请参考VisionEncoderDecoder类如何使用这个模型。

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

使用提示

  • 开始使用 TrOCR 的最快方法是查看教程笔记本，展示了如何在推理时使用模型以及在自定义数据上进行微调。

  • TrOCR 在被微调到下游数据集之前经过 2 个阶段的预训练。它在印刷（例如SROIE 数据集）和手写（例如IAM 手写数据集）文本识别任务上取得了最先进的结果。更多信息，请参阅官方模型。

  • TrOCR 始终在 VisionEncoderDecoder 框架内使用。

资源

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

文本分类

文本生成

⚡️ 推理

推理

TrOCR 的VisionEncoderDecoder模型接受图像作为输入，并利用 generate()来自回归地生成给定输入图像的文本。

[ViTImageProcessor/DeiTImageProcessor]类负责预处理输入图像，[RobertaTokenizer/XLMRobertaTokenizer]解码生成的目标令牌为目标字符串。TrOCRProcessor 将[ViTImageProcessor/DeiTImageProcessor]和[RobertaTokenizer/XLMRobertaTokenizer]封装成单个实例，用于提取输入特征和解码预测的令牌 ID。

  • 逐步光学字符识别（OCR）
>>> from transformers import TrOCRProcessor, VisionEncoderDecoderModel
>>> import requests
>>> from PIL import Image

>>> processor = TrOCRProcessor.from_pretrained("microsoft/trocr-base-handwritten")
>>> model = VisionEncoderDecoderModel.from_pretrained("microsoft/trocr-base-handwritten")

>>> # load image from the IAM dataset
>>> url = "https://fki.tic.heia-fr.ch/static/img/a01-122-02.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw).convert("RGB")

>>> pixel_values = processor(image, return_tensors="pt").pixel_values
>>> generated_ids = model.generate(pixel_values)

>>> generated_text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]

查看模型中心以查找 TrOCR 检查点。

TrOCRConfig

class transformers.TrOCRConfig

<来源>

( vocab_size = 50265 d_model = 1024 decoder_layers = 12 decoder_attention_heads = 16 decoder_ffn_dim = 4096 activation_function = 'gelu' max_position_embeddings = 512 dropout = 0.1 attention_dropout = 0.0 activation_dropout = 0.0 decoder_start_token_id = 2 init_std = 0.02 decoder_layerdrop = 0.0 use_cache = True scale_embedding = False use_learned_position_embeddings = True layernorm_embedding = True pad_token_id = 1 bos_token_id = 0 eos_token_id = 2 **kwargs )

参数

  • vocab_size (int, optional, defaults to 50265) — TrOCR 模型的词汇量。定义了在调用 TrOCRForCausalLM 时可以表示的不同令牌数量。

  • d_model (int, optional, defaults to 1024) — 层和池化层的维度。

  • decoder_layers (int, optional, defaults to 12) — 解码器层数。

  • decoder_attention_heads (int, optional, defaults to 16) — Transformer 解码器中每个注意力层的注意力头数。

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

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

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

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

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

  • activation_dropout (float, optional, defaults to 0.0) — 全连接层内激活的丢弃比例。

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

  • decoder_layerdrop (float, optional, defaults to 0.0) — 解码器的 LayerDrop 概率。有关更多详细信息，请参阅 LayerDrop 论文)。

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

  • scale_embedding (bool, optional, defaults to False) — 是否将词嵌入按 sqrt(d_model)进行缩放。

  • use_learned_position_embeddings (bool, optional, defaults to True) — 是否使用学习的位置嵌入。如果不是，则将使用正弦位置嵌入。

  • layernorm_embedding（bool，可选，默认为True）—是否在单词+位置嵌入后使用 layernorm。

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

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

示例：

>>> from transformers import TrOCRConfig, TrOCRForCausalLM

>>> # Initializing a TrOCR-base style configuration
>>> configuration = TrOCRConfig()

>>> # Initializing a model (with random weights) from the TrOCR-base style configuration
>>> model = TrOCRForCausalLM(configuration)

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

TrOCRProcessor

class transformers.TrOCRProcessor

<来源>

( image_processor = None tokenizer = None **kwargs )

参数

  • image_processor（[ViTImageProcessor/DeiTImageProcessor]，可选）—[ViTImageProcessor/DeiTImageProcessor]的实例。图像处理器是必需的输入。

  • tokenizer（[RobertaTokenizer/XLMRobertaTokenizer]，可选）—[RobertaTokenizer/XLMRobertaTokenizer]的实例。标记器是必需的输入。

构建一个 TrOCR 处理器，将视觉图像处理器和 TrOCR 标记器封装到单个处理器中。

TrOCRProcessor 提供了所有[ViTImageProcessor/DeiTImageProcessor]和[RobertaTokenizer/XLMRobertaTokenizer]的功能。查看call()和 decode()以获取更多信息。

__call__

<来源>

( *args **kwargs )

在正常模式下使用时，此方法将所有参数转发到 AutoImageProcessor 的__call__()并返回其输出。如果在上下文as_target_processor()中使用此方法，则将所有参数转发到 TrOCRTokenizer 的~TrOCRTokenizer.__call__。请参考上述两种方法的文档获取更多信息。

from_pretrained

<来源>

( pretrained_model_name_or_path: Union cache_dir: Union = None force_download: bool = False local_files_only: bool = False token: Union = None revision: str = 'main' **kwargs )

参数

  • pretrained_model_name_or_path（str或os.PathLike）—这可以是：

    • 一个字符串，预训练特征提取器的模型 ID，托管在 huggingface.co 上的模型存储库中。有效的模型 ID 可以位于根级别，如bert-base-uncased，或命名空间在用户或组织名称下，如dbmdz/bert-base-german-cased。

    • 一个目录的路径，其中包含使用 save_pretrained()方法保存的特征提取器文件，例如./my_model_directory/。

    • 一个保存的特征提取器 JSON 文件的路径或 URL，例如./my_model_directory/preprocessor_config.json。**kwargs —传递给 from_pretrained()和~tokenization_utils_base.PreTrainedTokenizer.from_pretrained的额外关键字参数。

实例化与预训练模型相关联的处理器。

这个类方法只是调用特征提取器 from_pretrained()、图像处理器 ImageProcessingMixin 和分词器~tokenization_utils_base.PreTrainedTokenizer.from_pretrained方法。有关更多信息，请参阅上述方法的文档字符串。

save_pretrained

<来源>

( save_directory push_to_hub: bool = False **kwargs )

参数

  • save_directory (str或os.PathLike) — 特征提取器 JSON 文件和分词器文件将保存在的目录（如果目录不存在将被创建）。

  • push_to_hub (bool, 可选, 默认为False) — 是否在保存后将模型推送到 Hugging Face 模型中心。您可以使用repo_id指定要推送到的存储库（将默认为您命名空间中的save_directory名称）。

  • kwargs (Dict[str, Any], 可选) — 传递给 push_to_hub()方法的额外关键字参数。

将此处理器的属性（特征提取器、分词器等）保存在指定目录中，以便可以使用 from_pretrained()方法重新加载。

这个类方法只是调用 save_pretrained()和 save_pretrained()。有关更多信息，请参阅上述方法的文档字符串。

batch_decode

<来源>

( *args **kwargs )

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

decode

<来源>

( *args **kwargs )

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

TrOCRForCausalLM

class transformers.TrOCRForCausalLM

<来源>

( config )

参数

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

带有语言建模头的 TrOCR 解码器。可用作 EncoderDecoderModel 和VisionEncoderDecoder的解码器部分。此模型继承自 PreTrainedModel。检查超类文档以了解库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

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

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None encoder_hidden_states: Optional = None encoder_attention_mask: Optional = None head_mask: Optional = None cross_attn_head_mask: Optional = None past_key_values: Optional = None inputs_embeds: 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.modeling_outputs.CausalLMOutputWithCrossAttentions 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.Tensor，可选）— 用于避免在填充标记索引上执行注意力的掩码。掩码值选在[0, 1]之间：

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

    • 0 表示标记是被掩码。

    什么是注意力掩码？

  • encoder_hidden_states（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）— 编码器最后一层的隐藏状态序列。如果模型配置为解码器，则在交叉注意力中使用。

  • encoder_attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）— 用于避免在编码器输入的填充标记索引上执行注意力的掩码。如果模型配置为解码器，则在交叉注意力中使用此掩码。掩码值选在[0, 1]之间：

  • head_mask（形状为(decoder_layers, decoder_attention_heads)的torch.Tensor，可选）— 用于使注意力模块的选定头部失效的掩码。掩码值选在[0, 1]之间：

    • 1 表示头部是未被掩码，

    • 0 表示头部是被掩码。

  • cross_attn_head_mask（形状为(decoder_layers, decoder_attention_heads)的torch.Tensor，可选）— 用于使交叉注意力模块的选定头部失效的掩码。掩码值选在[0, 1]之间：

    • 1 表示头部是未被掩码，

    • 0 表示头部是被掩码。

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

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

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

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

    • 对于被masked的标记为 0。

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

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

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

返回

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

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

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

  • logits (torch.FloatTensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（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 之后的注意力权重，用于计算自注意力头中的加权平均值。

  • cross_attentions (tuple(torch.FloatTensor)，可选，当传递output_attentions=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的torch.FloatTensor元组的元组，每个元组包含自注意力和交叉注意力层的缓存键、值状态，如果模型用于编码器-解码器设置，则相关。仅在config.is_decoder = True时相关。

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

示例：

>>> from transformers import (
...     TrOCRConfig,
...     TrOCRProcessor,
...     TrOCRForCausalLM,
...     ViTConfig,
...     ViTModel,
...     VisionEncoderDecoderModel,
... )
>>> import requests
>>> from PIL import Image

>>> # TrOCR is a decoder model and should be used within a VisionEncoderDecoderModel
>>> # init vision2text model with random weights
>>> encoder = ViTModel(ViTConfig())
>>> decoder = TrOCRForCausalLM(TrOCRConfig())
>>> model = VisionEncoderDecoderModel(encoder=encoder, decoder=decoder)

>>> # If you want to start from the pretrained model, load the checkpoint with `VisionEncoderDecoderModel`
>>> processor = TrOCRProcessor.from_pretrained("microsoft/trocr-base-handwritten")
>>> model = VisionEncoderDecoderModel.from_pretrained("microsoft/trocr-base-handwritten")

>>> # load image from the IAM dataset
>>> url = "https://fki.tic.heia-fr.ch/static/img/a01-122-02.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw).convert("RGB")
>>> pixel_values = processor(image, return_tensors="pt").pixel_values
>>> text = "industry, ' Mr. Brown commented icily. ' Let us have a"

>>> # training
>>> model.config.decoder_start_token_id = processor.tokenizer.cls_token_id
>>> model.config.pad_token_id = processor.tokenizer.pad_token_id
>>> model.config.vocab_size = model.config.decoder.vocab_size

>>> labels = processor.tokenizer(text, return_tensors="pt").input_ids
>>> outputs = model(pixel_values, labels=labels)
>>> loss = outputs.loss
>>> round(loss.item(), 2)
5.30

>>> # inference
>>> generated_ids = model.generate(pixel_values)
>>> generated_text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
>>> generated_text
'industry, " Mr. Brown commented icily. " Let us have a'

TVLT

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

概述

TVLT 模型是由 Zineng Tang、Jaemin Cho、Yixin Nie、Mohit Bansal 提出的，首三位作者贡献相同。无文本视觉语言变换器（TVLT）是一个使用原始视觉和音频输入进行视觉和语言表示学习的模型，而不使用文本特定模块，如标记化或自动语音识别（ASR）。它可以执行各种音频视觉和视觉语言任务，如检索、问答等。

论文摘要如下：

在这项工作中，我们提出了无文本视觉语言变换器（TVLT），其中同质变换器块接受原始视觉和音频输入进行视觉和语言表示学习，具有最小的模态特定设计，并且不使用文本特定模块，如标记化或自动语音识别（ASR）。 TVLT 通过重建连续视频帧和音频频谱图的掩码块（掩码自编码）和对比建模来训练，并对齐视频和音频。 TVLT 在各种多模态任务上取得了与基于文本的对应物相当的性能，如视觉问答、图像检索、视频检索和多模态情感分析，推理速度快 28 倍，参数仅为原来的 1/3。我们的研究结果表明，在不假定文本事先存在的情况下，可以从低级视觉和音频信号中学习紧凑高效的视觉-语言表示的可能性。

drawing

TVLT 架构。取自原始论文)。

原始代码可以在这里找到。该模型由Zineng Tang贡献。

使用提示

  • TVLT 是一个接受pixel_values和audio_values作为输入的模型。可以使用 TvltProcessor 为模型准备数据。该处理器将图像处理器（用于图像/视频模态）和音频特征提取器（用于音频模态）封装在一起。

  • TVLT 是使用各种大小的图像/视频和音频进行训练的：作者将输入图像/视频调整大小并裁剪到 224，并限制音频频谱图的长度为 2048。为了使视频和音频的批处理成为可能，作者使用pixel_mask指示哪些像素是真实/填充的，以及audio_mask指示哪些音频值是真实/填充的。

  • TVLT 的设计与标准视觉变换器（ViT）和掩码自编码器（MAE）非常相似，如 ViTMAE。不同之处在于该模型包括音频模态的嵌入层。

  • 此模型的 PyTorch 版本仅在 torch 1.10 及更高版本中可用。

TvltConfig

class transformers.TvltConfig

<来源>

( image_size = 224 spectrogram_length = 2048 frequency_length = 128 image_patch_size = [16, 16] audio_patch_size = [16, 16] num_image_channels = 3 num_audio_channels = 1 num_frames = 8 hidden_size = 768 num_hidden_layers = 12 num_attention_heads = 12 intermediate_size = 3072 hidden_act = 'gelu' hidden_dropout_prob = 0.0 attention_probs_dropout_prob = 0.0 initializer_range = 0.02 layer_norm_eps = 1e-06 qkv_bias = True use_mean_pooling = False decoder_num_attention_heads = 16 decoder_hidden_size = 512 decoder_num_hidden_layers = 8 decoder_intermediate_size = 2048 pixel_mask_ratio = 0.75 audio_mask_ratio = 0.15 audio_mask_type = 'frame-level' task_matching = True task_mae = True loss_type = 'classification' **kwargs )

参数

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

  • spectrogram_length (int, optional, 默认为 2048) — 每个音频频谱图的时间长度。

  • frequency_length (int, optional, 默认为 128) — 音频频谱图的频率长度。

  • image_patch_size (List[int], optional, 默认为 [16, 16]) — 每个图像块的大小（分辨率）。

  • audio_patch_size (List[int], optional, 默认为 [16, 16]) — 每个音频块的大小（分辨率）。

  • num_image_channels (int, optional, 默认为 3) — 输入图像通道数。

  • num_audio_channels (int, optional, 默认为 1) — 输入音频通道数。

  • num_frames (int，可选，默认为 8) — 输入视频的最大帧数。

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

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

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

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

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

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

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

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

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

  • qkv_bias (bool，可选，默认为 True) — 是否向查询、键和值添加偏置。

  • use_mean_pooling (bool，可选，默认为 False) — 是否对最终隐藏状态进行平均池化，而不是使用 [CLS] 标记的最终隐藏状态。

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

  • decoder_hidden_size (int，可选，默认为 512) — 解码器的维度。

  • decoder_num_hidden_layers (int，可选，默认为 8) — 解码器中的隐藏层数。

  • decoder_intermediate_size (int，可选，默认为 2048) — 解码器中“中间”（即前馈）层的维度。

  • pixel_mask_ratio (float，可选，默认为 0.75) — 图像补丁掩码比例。

  • audio_mask_ratio (float，可选，默认为 0.15) — 音频补丁掩码比例。

  • audio_mask_type (str，可选，默认为 "frame-level") — 音频补丁掩码类型，可选择"frame-level"和“patch-level”。

  • task_matching (bool，可选，默认为 True) — 是否在预训练中使用视觉音频匹配任务。

  • task_mae (bool，可选，默认为 True) — 是否在预训练中使用掩码自编码器（MAE）。

  • loss_type (str，可选，默认为 "classification") — 包括回归和分类在内的损失类型。

这是一个配置类，用于存储 TvltModel 的配置。根据指定的参数实例化一个 TVLT 模型，定义模型架构。使用默认值实例化配置将产生类似于 TVLT ZinengTang/tvlt-base 架构的配置。

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

示例：

>>> from transformers import TvltConfig, TvltModel

>>> # # Initializing a TVLT ZinengTang/tvlt-base style configuration
>>> configuration = TvltConfig()

>>> # # Initializing a model (with random weights) from the ZinengTang/tvlt-base style configuration
>>> model = TvltModel(configuration)

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

TvltProcessor

class transformers.TvltProcessor

<来源>

( image_processor feature_extractor )

参数

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

  • feature_extractor（TvltFeatureExtractor）— TvltFeatureExtractor 的一个实例。特征提取器是一个必需的输入。

构建一个 TVLT 处理器，将 TVLT 图像处理器和 TVLT 特征提取器包装成一个单一处理器。

TvltProcessor 提供了 TvltImageProcessor 和 TvltFeatureExtractor 的所有功能。查看call()的文档字符串以获取更多信息。

__call__

<来源>

( images = None audio = None images_mixed = None sampling_rate = None mask_audio = False mask_pixel = False *args **kwargs )

将images参数转发到 TvltImageProcessor 的 preprocess()，将audio参数转发到 TvltFeatureExtractor 的call()。更多信息请参考上述两个方法的文档字符串。

TvltImageProcessor

class transformers.TvltImageProcessor

<来源>

( do_resize: bool = True size: Dict = None patch_size: List = [16, 16] num_frames: int = 8 resample: Resampling = <Resampling.BILINEAR: 2> do_center_crop: bool = True crop_size: Dict = None do_rescale: bool = True rescale_factor: Union = 0.00392156862745098 do_normalize: bool = True image_mean: Union = [0.5, 0.5, 0.5] image_std: Union = [0.5, 0.5, 0.5] init_mask_generator = False **kwargs )

参数

  • do_resize（bool，可选，默认为True）— 是否将图像的（高度，宽度）尺寸调整为指定的size。可以被preprocess方法中的do_resize参数覆盖。

  • size（Dict[str, int] 可选，默认为{"shortest_edge" -- 224}）：调整大小后的输出图像大小。图像的最短边将被调整为size["shortest_edge"]，同时保持原始图像的纵横比。可以通过preprocess方法中的size进行覆盖。

  • patch_size（List[int] 可选，默认为[16,16]）— 图像补丁嵌入的补丁大小。

  • num_frames（int 可选，默认为 8）— 视频帧的最大数量。

  • resample（PILImageResampling，可选，默认为PILImageResampling.BILINEAR）— 调整图像大小时要使用的重采样滤波器。可以被preprocess方法中的resample参数覆盖。

  • do_center_crop（bool，可选，默认为True）— 是否将图像居中裁剪到指定的crop_size。可以被preprocess方法中的do_center_crop参数覆盖。

  • crop_size（Dict[str, int]，可选，默认为{"height" -- 224, "width": 224}）：应用中心裁剪后的图像大小。可以被preprocess方法中的crop_size参数覆盖。

  • do_rescale（bool，可选，默认为True）— 是否按指定比例rescale_factor对图像进行重新缩放。可以被preprocess方法中的do_rescale参数覆盖。

  • rescale_factor（int或float，可选，默认为 1/255）— 定义在重新缩放图像时要使用的比例因子。可以被preprocess方法中的rescale_factor参数覆盖。

  • do_normalize（bool，可选，默认为True）— 是否对图像进行归一化。可以被preprocess方法中的do_normalize参数覆盖。

  • image_mean（float或List[float]，可选，默认为IMAGENET_STANDARD_MEAN）— 在归一化图像时使用的均值。这是一个浮点数或与图像通道数相同长度的浮点数列表。可以被preprocess方法中的image_mean参数覆盖。

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

构建一个 TVLT 图像处理器。

此处理器可通过将图像转换为 1 帧视频来为模型准备视频或图像。

preprocess

<来源>

( videos: Union do_resize: bool = None size: Dict = None patch_size: List = None num_frames: int = None resample: Resampling = None do_center_crop: bool = None crop_size: Dict = None do_rescale: bool = None rescale_factor: float = None do_normalize: bool = None image_mean: Union = None image_std: Union = None is_mixed: bool = False return_tensors: Union = None data_format: ChannelDimension = <ChannelDimension.FIRST: 'channels_first'> input_data_format: Union = None **kwargs ) → export const metadata = 'undefined';BatchFeature

参数

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

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

  • size (Dict[str, int], 可选, 默认为self.size) — 应用调整大小后的图像大小。

  • patch_size (List[int] 可选, 默认为 self.patch_size) — 图像补丁嵌入的补丁大小。

  • num_frames (int 可选, 默认为 self.num_frames) — 视频帧的最大数量。

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

  • do_center_crop (bool, 可选, 默认为self.do_centre_crop) — 是否对图像进行中心裁剪。

  • crop_size (Dict[str, int], 可选, 默认为self.crop_size) — 应用中心裁剪后的图像大小。

  • do_rescale (bool, 可选, 默认为self.do_rescale) — 是否将图像值重新缩放到[0 - 1]之间。

  • rescale_factor (float, 可选, 默认为self.rescale_factor) — 如果do_rescale设置为True，则要缩放图像的缩放因子。

  • do_normalize (bool, 可选, 默认为self.do_normalize) — 是否对图像进行归一化。

  • image_mean (float 或 List[float], 可选, 默认为self.image_mean) — 图像均值。

  • image_std (float 或 List[float], 可选, 默认为self.image_std) — 图像标准差。

  • is_mixed (bool, 可选) — 如果输入视频有负样本。

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

    • 未设置: 使用输入图像的推断通道维度格式。

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

返回

BatchFeature

具有以下字段的 BatchFeature：

  • pixel_values — 要馈送给模型的像素值，形状为(batch_size, num_channels, height, width)。

  • pixel_mask — 用于输入模型的像素掩码，形状为（batch_size，num_pixel_patches）。

  • pixel_values_mixed — 具有正负值的像素值，用于输入模型，形状为（batch_size，num_channels，height，width）。

  • pixel_mask_mixed — 具有正负值的像素掩码，用于输入模型，形状为（batch_size，num_pixel_patches）。

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

TvltFeatureExtractor

class transformers.TvltFeatureExtractor

< source >

( spectrogram_length = 2048 num_channels = 1 patch_size = [16, 16] feature_size = 128 sampling_rate = 44100 hop_length_to_sampling_rate = 86 n_fft = 2048 padding_value = 0.0 **kwargs )

参数

  • spectrogram_length (Dict[str, int] optional, defaults to 2048) — 每个音频频谱图的时间长度。

  • num_channels (int optional, defaults to 1) — 音频通道数。

  • patch_size (List[int] optional, defaults to [16, 16]) — 音频补丁嵌入的补丁大小。

  • feature_size (int, optional, defaults to 128) — 音频频谱图的频率长度。

  • sampling_rate (int, optional, defaults to 44100) — 音频文件应数字化的采样率，以赫兹（Hz）表示。

  • hop_length_to_sampling_rate (int, optional, defaults to 86) — Hop length 是用于获取 Mel 频率系数的 STFT 中重叠窗口的长度。例如，对于采样率 44100，跳跃长度为 512，即 44100 / 512 = 86

  • n_fft (int, optional, defaults to 2048) — 傅立叶变换的大小。

  • padding_value (float, optional, defaults to 0.0) — 用于填充音频的填充值。应对应于静音。

构建一个 TVLT 音频特征提取器。此特征提取器可用于为模型准备音频。

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

__call__

< source >

( raw_speech: Union return_tensors: Union = None return_attention_mask: Optional = True sampling_rate: Optional = None resample: bool = False mask_audio: bool = False **kwargs ) → export const metadata = 'undefined';BatchFeature

参数

  • raw_speech (np.ndarray, List[float], List[np.ndarray], List[List[float]]) — 要填充的序列或序列批次。每个序列可以是一个 numpy 数组，一个浮点值列表，一个 numpy 数组列表或一个浮点值列表的列表。必须是单声道音频，不是立体声，即每个时间步长一个浮点数。

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

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

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

  • return_attention_mask (bool, optional, default to True) — 是否返回注意力掩码。如果保持默认值，将根据特定 feature_extractor 的默认值返回注意力掩码。什么是注意力掩码？

    对于 TvltTransformer 模型，应始终传递attention_mask以进行批量推断，以避免细微错误。

  • sampling_rate (int, optional) — 对raw_speech输入进行采样的采样率。强烈建议在前向调用时传递sampling_rate，以防止静默错误并允许自动语音识别流水线。当前模型支持采样率为 16000 和 44100。

  • resample (bool, optional, defaults to False) — 如果采样率不匹配，则重新采样输入音频以匹配。

  • mask_audio (bool, optional, defaults to False) — 是否对 MAE 任务的输入音频进行掩码。

返回

BatchFeature

具有以下字段的 BatchFeature：

  • audio_values — 要馈送给模型的音频值，形状为(batch_size, num_channels, height, width)。

  • audio_mask — 要馈送给模型的音频掩码，形状为(batch_size, num_audio_patches)。

为模型准备一个或多个音频的主要方法。

TvltModel

class transformers.TvltModel

<来源>

( config )

参数

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

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

forward

<来源>

( pixel_values: FloatTensor audio_values: FloatTensor pixel_mask: Optional = None audio_mask: Optional = None mask_pixel: bool = False mask_audio: bool = False output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.tvlt.modeling_tvlt.TvltModelOutput or tuple(torch.FloatTensor)

参数

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

  • audio_values (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 音频值。可以使用 TvltProcessor 获取音频值。有关详细信息，请参阅 TvltProcessor.call()。

  • pixel_mask (torch.FloatTensor of shape (batch_size, num_pixel_patches)) — 像素掩码。可以使用 TvltProcessor 获取像素掩码。有关详细信息，请参阅 TvltProcessor.call()。

  • audio_mask (torch.FloatTensor of shape (batch_size, num_audio_patches)) — 音频掩码。可以使用 TvltProcessor 获取音频掩码。有关详细信息，请参阅 TvltProcessor.call()。

  • pixel_values_mixed (torch.FloatTensor of shape (batch_size, num_frames, num_channels, height, width)) — 在 Tvlt 视听匹配中混合正负样本的像素值。可以使用 TvltProcessor 获取混合像素值。有关详细信息，请参阅 TvltProcessor.call()。

  • pixel_mask_mixed (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — pixel_values_mixed 的像素掩码。可以使用 TvltProcessor 获取混合像素掩码。有关详细信息，请参阅 TvltProcessor.call()。

  • mask_pixel (bool, optional) — 是否对 MAE 任务遮蔽像素。仅在 TvltForPreTraining 中设置为 True。

  • mask_audio (bool, optional) — 是否对 MAE 任务遮蔽音频。仅在 TvltForPreTraining 中设置为 True。

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

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

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

返回

transformers.models.tvlt.modeling_tvlt.TvltModelOutput 或 tuple(torch.FloatTensor)

一个 transformers.models.tvlt.modeling_tvlt.TvltModelOutput 或一个 torch.FloatTensor 元组（如果传递 return_dict=False 或 config.return_dict=False）包含各种元素，取决于配置（TvltConfig）和输入。

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

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

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

  • pixel_label_masks (torch.FloatTensor，形状为 (batch_size, pixel_patch_length)) — 指示哪些像素 patch 被 mask（1）哪些没有被 mask（0）的张量。

  • audio_label_masks (torch.FloatTensor，形状为 (batch_size, audio_patch_length)) — 指示哪些音频 patch 被 mask（1）哪些没有被 mask（0）的张量。

  • pixel_ids_restore (torch.LongTensor，形状为 (batch_size, pixel_patch_length)) — 包含像素 masking 的 ids 排列的张量。

  • audio_ids_restore (torch.LongTensor，形状为 (batch_size, audio_patch_length)) — 包含音频 masking 的 ids 排列的张量。

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

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

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

示例：

>>> from transformers import TvltProcessor, TvltModel
>>> import numpy as np
>>> import torch

>>> num_frames = 8
>>> images = list(np.random.randn(num_frames, 3, 224, 224))
>>> audio = list(np.random.randn(10000))

>>> processor = TvltProcessor.from_pretrained("ZinengTang/tvlt-base")
>>> model = TvltModel.from_pretrained("ZinengTang/tvlt-base")

>>> input_dict = processor(images, audio, sampling_rate=44100, return_tensors="pt")

>>> outputs = model(**input_dict)
>>> loss = outputs.loss

TvltForPreTraining

class transformers.TvltForPreTraining

< source >

( config )

参数

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

带有顶部解码器用于自监督预训练的 TVLT 模型变压器。此模型是 PyTorch torch.nn.Module子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

< source >

( pixel_values: FloatTensor audio_values: FloatTensor pixel_mask: Optional = None audio_mask: Optional = None labels: Optional = None pixel_values_mixed: Optional = None pixel_mask_mixed: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.tvlt.modeling_tvlt.TvltForPreTrainingOutput or tuple(torch.FloatTensor)

参数

  • pixel_values (torch.FloatTensor of shape (batch_size, num_frames, num_channels, height, width)) — 像素值。可以使用 TvltProcessor 获取像素值。详细信息请参见 TvltProcessor.call()。

  • audio_values (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 音频值。可以使用 TvltProcessor 获取音频值。详细信息请参见 TvltProcessor.call()。

  • pixel_mask (torch.FloatTensor of shape (batch_size, num_pixel_patches)) — 像素掩码。可以使用 TvltProcessor 获取像素掩码。详细信息请参见 TvltProcessor.call()。

  • audio_mask (torch.FloatTensor of shape (batch_size, num_audio_patches)) — 音频掩码。音频掩码可以使用 TvltProcessor 获取。详细信息请参见 TvltProcessor.call()。

  • pixel_values_mixed (torch.FloatTensor of shape (batch_size, num_frames, num_channels, height, width)) — 在 Tvlt 视听匹配中混合正负样本的像素值。混合的像素值可以使用 TvltProcessor 获取。详细信息请参见 TvltProcessor.call()。

  • pixel_mask_mixed (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 混合像素值的像素掩码。可以使用 TvltProcessor 获取像素掩码混合。详细信息请参见 TvltProcessor.call()。

  • mask_pixel (bool, 可选) — 是否为 MAE 任务屏蔽像素。仅在 TvltForPreTraining 中设置为 True。

  • mask_audio (bool, 可选) — 是否为 MAE 任务屏蔽音频。仅在 TvltForPreTraining 中设置为 True。

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

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

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

  • pixel_values_mixed (torch.FloatTensor of shape (batch_size, num_frames, num_channels, height, width)) — 在 Tvlt 视听匹配中混合正负样本的像素值。音频值可以使用 TvltProcessor 获取。详细信息请参见 TvltProcessor.call()。

  • pixel_mask_mixed（形状为(batch_size, num_channels, height, width)的torch.FloatTensor）— 像素值混合的像素掩码。可以使用 TvltProcessor 获取像素值混合。有关详细信息，请参阅 TvltProcessor.call()。

  • labels（形状为(batch_size, num_labels)的torch.LongTensor，可选）— 用于计算视听匹配损失的标签。索引应在[0, 1]范围内。num_labels 必须为 1。

返回

transformers.models.tvlt.modeling_tvlt.TvltForPreTrainingOutput或tuple(torch.FloatTensor)

一个transformers.models.tvlt.modeling_tvlt.TvltForPreTrainingOutput或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含根据配置（TvltConfig）和输入的各种元素。

  • loss（形状为(1,)的torch.FloatTensor）— 像素重建损失。

  • matching_logits（形状为(batch_size, 1)的torch.FloatTensor）— 匹配目标对数。

  • pixel_logits（形状为(batch_size, pixel_patch_length, image_patch_size ** 3 * pixel_num_channels)的torch.FloatTensor）：像素重建对数。

  • audio_logits（形状为(batch_size, audio_patch_length, image_patch_size[0] * image_patch_size[1])的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 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import TvltProcessor, TvltForPreTraining
>>> import numpy as np
>>> import torch

>>> num_frames = 8
>>> images = list(np.random.randn(num_frames, 3, 224, 224))
>>> images_mixed = list(np.random.randn(num_frames, 3, 224, 224))
>>> audio = list(np.random.randn(10000))
>>> processor = TvltProcessor.from_pretrained("ZinengTang/tvlt-base")
>>> model = TvltForPreTraining.from_pretrained("ZinengTang/tvlt-base")
>>> input_dict = processor(
...     images, audio, images_mixed, sampling_rate=44100, mask_pixel=True, mask_audio=True, return_tensors="pt"
... )

>>> outputs = model(**input_dict)
>>> loss = outputs.loss

TvltForAudioVisualClassification

class transformers.TvltForAudioVisualClassification

<来源>

( config )

参数

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

Tvlt 模型变压器，顶部带有分类器头（在[CLS]标记的最终隐藏状态之上的 MLP）用于音频视觉分类任务，例如 CMU-MOSEI 情感分析和音频到视频检索。

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

forward

<来源>

( pixel_values: FloatTensor audio_values: FloatTensor pixel_mask: Optional = None audio_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None labels: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.SequenceClassifierOutput or tuple(torch.FloatTensor)

参数

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

  • audio_values (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — 音频值。可以使用 TvltProcessor 获取音频值。有关详细信息，请参阅 TvltProcessor.call()。

  • pixel_mask (torch.FloatTensor of shape (batch_size, num_pixel_patches)) — 像素掩码。可以使用 TvltProcessor 获取像素掩码。有关详细信息，请参阅 TvltProcessor.call()。

  • audio_mask (torch.FloatTensor of shape (batch_size, num_audio_patches)) — 音频掩码。可以使用 TvltProcessor 获取音频掩码。有关详细信息，请参阅 TvltProcessor.call()。

  • pixel_values_mixed (torch.FloatTensor of shape (batch_size, num_frames, num_channels, height, width)) — 在 Tvlt 视听匹配中混合正负样本的像素值。可以使用 TvltProcessor 获取混合像素值。有关详细信息，请参阅 TvltProcessor.call()。

  • pixel_mask_mixed (torch.FloatTensor of shape (batch_size, num_channels, height, width)) — pixel_values_mixed 的像素掩码。可以使用 TvltProcessor 获取混合像素掩码。有关详细信息，请参阅 TvltProcessor.call()。

  • mask_pixel (bool, optional) — 是否为 MAE 任务屏蔽像素。仅在 TvltForPreTraining 中设置为 True。

  • mask_audio (bool, optional) — 是否为 MAE 任务屏蔽音频。仅在 TvltForPreTraining 中设置为 True。

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

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

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

  • labels (torch.LongTensor of shape (batch_size, num_labels), optional) — 用于计算音视频损失的标签。索引应在[0, ..., num_classes-1]范围内，其中 num_classes 是音视频任务中类别的数量。

返回

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

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

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

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

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

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

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

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

为音频视觉分类而设计的 TvltForAudioVisualClassification 前向方法，覆盖了__call__特殊方法。

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

示例：

>>> from transformers import TvltProcessor, TvltForAudioVisualClassification
>>> import numpy as np
>>> import torch

>>> num_frames = 8
>>> images = list(np.random.randn(num_frames, 3, 224, 224))
>>> audio = list(np.random.randn(10000))
>>> processor = TvltProcessor.from_pretrained("ZinengTang/tvlt-base")
>>> model = TvltForAudioVisualClassification.from_pretrained("ZinengTang/tvlt-base")
>>> input_dict = processor(images, audio, sampling_rate=44100, return_tensors="pt")

>>> outputs = model(**input_dict)
>>> loss = outputs.loss

TVP

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

概述

文本视觉提示（TVP）框架是由 Yimeng Zhang，Xin Chen，Jinghan Jia，Sijia Liu，Ke Ding 在论文Text-Visual Prompting for Efficient 2D Temporal Video Grounding中提出的。

论文的摘要如下：

在本文中，我们研究了时间视频定位（TVG）问题，旨在预测长视频中由文本句子描述的时刻的起始/结束时间点。由于精细的 3D 视觉特征，TVG 技术近年来取得了显著进展。然而，3D 卷积神经网络（CNNs）的高复杂性使得提取密集的 3D 视觉特征耗时，需要大量内存和计算资源。为了实现高效的 TVG，我们提出了一种新颖的文本-视觉提示（TVP）框架，将优化的扰动模式（我们称之为“提示”）集成到 TVG 模型的视觉输入和文本特征中。与 3D CNN 形成鲜明对比，我们展示了 TVP 允许我们在 2D TVG 模型中有效地共同训练视觉编码器和语言编码器，并且仅使用低复杂度的稀疏 2D 视觉特征改善了跨模态特征融合的性能。此外，我们提出了一种用于高效学习 TVG 的时间距离 IoU（TDIoU）损失。对两个基准数据集 Charades-STA 和 ActivityNet Captions 数据集的实验经验表明，所提出的 TVP 显著提升了 2D TVG 的性能（例如，在 Charades-STA 上提高了 9.79%，在 ActivityNet Captions 上提高了 30.77%），并且相比使用 3D 视觉特征的 TVG 实现了 5 倍的推理加速。

这项研究解决了时间视频定位（TVG）问题，即在长视频中准确定位特定事件的开始和结束时间，如文本句子所描述。文本-视觉提示（TVP）被提出以增强 TVG。TVP 涉及将专门设计的模式（称为“提示”）集成到 TVG 模型的视觉（基于图像）和文本（基于单词）输入组件中。这些提示提供额外的时空上下文，提高了模型准确确定视频中事件时间的能力。该方法使用 2D 视觉输入代替 3D 输入。虽然 3D 输入提供更多的时空细节，但处理起来也更耗时。使用 2D 输入与提示方法旨在更有效地提供类似水平的上下文和准确性。

drawing TVP 架构。摘自原始论文

该模型由Jiqing Feng贡献。原始代码可以在这里找到。

使用提示和示例

提示是经过优化的扰动模式，将添加到输入视频帧或文本特征中。通用集指的是对于任何输入使用完全相同的提示集，这意味着这些提示被一致地添加到所有视频帧和文本特征中，而不考虑输入的内容。

TVP 包括一个视觉编码器和跨模态编码器。一个通用的视觉提示集和文本提示集分别集成到采样的视频帧和文本特征中。特别地，一组不同的视觉提示被应用于一个未修剪视频的均匀采样帧中。

该模型的目标是将可训练的提示集成到视觉输入和文本特征中，以解决时间视频定位（TVG）问题。原则上，可以在提出的架构中应用任何视觉、跨模态编码器。

TvpProcessor 将 BertTokenizer 和 TvpImageProcessor 包装成一个单一实例，分别对文本进行编码和准备图像。

以下示例展示了如何使用 TvpProcessor 和 TvpForVideoGrounding 运行时间视频定位。

import av
import cv2
import numpy as np
import torch
from huggingface_hub import hf_hub_download
from transformers import AutoProcessor, TvpForVideoGrounding

def pyav_decode(container, sampling_rate, num_frames, clip_idx, num_clips, target_fps):
    '''
    Convert the video from its original fps to the target_fps and decode the video with PyAV decoder.
    Args:
        container (container): pyav container.
        sampling_rate (int): frame sampling rate (interval between two sampled frames).
        num_frames (int): number of frames to sample.
        clip_idx (int): if clip_idx is -1, perform random temporal sampling.
            If clip_idx is larger than -1, uniformly split the video to num_clips
            clips, and select the clip_idx-th video clip.
        num_clips (int): overall number of clips to uniformly sample from the given video.
        target_fps (int): the input video may have different fps, convert it to
            the target video fps before frame sampling.
    Returns:
        frames (tensor): decoded frames from the video. Return None if the no
            video stream was found.
        fps (float): the number of frames per second of the video.
    '''
    video = container.streams.video[0]
    fps = float(video.average_rate)
    clip_size = sampling_rate * num_frames / target_fps * fps
    delta = max(num_frames - clip_size, 0)
    start_idx = delta * clip_idx / num_clips
    end_idx = start_idx + clip_size - 1
    timebase = video.duration / num_frames
    video_start_pts = int(start_idx * timebase)
    video_end_pts = int(end_idx * timebase)
    seek_offset = max(video_start_pts - 1024, 0)
    container.seek(seek_offset, any_frame=False, backward=True, stream=video)
    frames = {}
    for frame in container.decode(video=0):
        if frame.pts < video_start_pts:
            continue
        frames[frame.pts] = frame
        if frame.pts > video_end_pts:
            break
    frames = [frames[pts] for pts in sorted(frames)]
    return frames, fps

def decode(container, sampling_rate, num_frames, clip_idx, num_clips, target_fps):
    '''
    Decode the video and perform temporal sampling.
    Args:
        container (container): pyav container.
        sampling_rate (int): frame sampling rate (interval between two sampled frames).
        num_frames (int): number of frames to sample.
        clip_idx (int): if clip_idx is -1, perform random temporal sampling.
            If clip_idx is larger than -1, uniformly split the video to num_clips
            clips, and select the clip_idx-th video clip.
        num_clips (int): overall number of clips to uniformly sample from the given video.
        target_fps (int): the input video may have different fps, convert it to
            the target video fps before frame sampling.
    Returns:
        frames (tensor): decoded frames from the video.
    '''
    assert clip_idx >= -2, "Not a valied clip_idx {}".format(clip_idx)
    frames, fps = pyav_decode(container, sampling_rate, num_frames, clip_idx, num_clips, target_fps)
    clip_size = sampling_rate * num_frames / target_fps * fps
    index = np.linspace(0, clip_size - 1, num_frames)
    index = np.clip(index, 0, len(frames) - 1).astype(np.int64)
    frames = np.array([frames[idx].to_rgb().to_ndarray() for idx in index])
    frames = frames.transpose(0, 3, 1, 2)
    return frames

file = hf_hub_download(repo_id="Intel/tvp_demo", filename="AK2KG.mp4", repo_type="dataset")
model = TvpForVideoGrounding.from_pretrained("Intel/tvp-base")

decoder_kwargs = dict(
    container=av.open(file, metadata_errors="ignore"),
    sampling_rate=1,
    num_frames=model.config.num_frames,
    clip_idx=0,
    num_clips=1,
    target_fps=3,
)
raw_sampled_frms = decode(**decoder_kwargs)

text = "a person is sitting on a bed."
processor = AutoProcessor.from_pretrained("Intel/tvp-base")
model_inputs = processor(
    text=[text], videos=list(raw_sampled_frms), return_tensors="pt", max_text_length=100#, size=size
)

model_inputs["pixel_values"] = model_inputs["pixel_values"].to(model.dtype)
output = model(**model_inputs)

def get_video_duration(filename):
    cap = cv2.VideoCapture(filename)
    if cap.isOpened():
        rate = cap.get(5)
        frame_num = cap.get(7)
        duration = frame_num/rate
        return duration
    return -1

duration = get_video_duration(file)
start, end = processor.post_process_video_grounding(output.logits, duration)

print(f"The time slot of the video corresponding to the text \"{text}\" is from {start}s to {end}s")

提示：

  • TVP 的这个实现使用 BertTokenizer 生成文本嵌入和 Resnet-50 模型计算视觉嵌入。

  • 已发布预训练 tvp-base 的检查点。

  • 请参考 Table 2 了解 TVP 在时间视频定位任务上的性能。

TvpConfig

class transformers.TvpConfig

< source >

( backbone_config = None distance_loss_weight = 1.0 duration_loss_weight = 0.1 visual_prompter_type = 'framepad' visual_prompter_apply = 'replace' visual_prompt_size = 96 max_img_size = 448 num_frames = 48 vocab_size = 30522 hidden_size = 768 intermediate_size = 3072 num_hidden_layers = 12 num_attention_heads = 12 max_position_embeddings = 512 max_grid_col_position_embeddings = 100 max_grid_row_position_embeddings = 100 hidden_dropout_prob = 0.1 hidden_act = 'gelu' layer_norm_eps = 1e-12 initializer_range = 0.02 attention_probs_dropout_prob = 0.1 **kwargs )

参数

  • backbone_config (PretrainedConfig or dict, optional) — 骨干模型的配置。

  • distance_loss_weight (float, optional, defaults to 1.0) — 距离损失的权重。

  • duration_loss_weight (float, optional, defaults to 0.1) — 持续时间损失的权重。

  • visual_prompter_type (str, optional, defaults to "framepad") — 视觉提示类型。填充的类型。Framepad 表示在每个帧上填充。应为"framepad"或“framedownpad”之一。

  • visual_prompter_apply (str, optional, defaults to "replace") — 应用视觉提示的方式。Replace 表示使用提示的值来更改视觉输入中的原始值。应为"replace"、“add”或“remove”之一。

  • visual_prompt_size (int, optional, defaults to 96) — 视觉提示的大小。

  • max_img_size (int, optional, defaults to 448) — 帧的最大尺寸。

  • num_frames (int, optional, defaults to 48) — 从视频中提取的帧数。

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

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

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

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

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

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

  • max_grid_col_position_embeddings (int, optional, defaults to 100) — 从视频帧中提取的水平补丁的最大数量。

  • max_grid_row_position_embeddings (int, optional, defaults to 100) — 从视频帧中提取的垂直补丁的最大数量。

  • hidden_dropout_prob (float, optional, defaults to 0.1) — 隐藏层的丢失概率。

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

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

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

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

这是一个配置类，用于存储 TvpModel 的配置。它用于根据指定的参数实例化一个 Tvp 模型，定义模型架构。使用默认值实例化配置将产生类似于Tvp Intel/tvp-base架构的配置。

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

from_backbone_config

<来源>

( backbone_config: PretrainedConfig **kwargs ) → export const metadata = 'undefined';TvpConfig

参数

  • backbone_config (PretrainedConfig) — 骨干配置。

返回

TvpConfig

配置对象的一个实例

从预训练的骨干模型配置实例化一个 TvpConfig（或派生类）。

to_dict

<来源>

( ) → export const metadata = 'undefined';Dict[str, any]

返回

Dict[str, any]

包含构成此配置实例的所有属性的字典，

将此实例序列化为 Python 字典。覆盖默认 to_dict()。

TvpImageProcessor

class transformers.TvpImageProcessor

<来源>

( do_resize: bool = True size: Dict = None resample: Resampling = <Resampling.BILINEAR: 2> do_center_crop: bool = True crop_size: Dict = None do_rescale: bool = True rescale_factor: Union = 0.00392156862745098 do_pad: bool = True pad_size: Dict = None constant_values: Union = 0 pad_mode: PaddingMode = <PaddingMode.CONSTANT: 'constant'> do_normalize: bool = True do_flip_channel_order: bool = True image_mean: Union = None image_std: Union = None **kwargs )

参数

  • do_resize (bool，可选，默认为True) — 是否将图像的（高度，宽度）尺寸调整为指定的size。可以被preprocess方法中的do_resize参数覆盖。

  • size (Dict[str, int] 可选，默认为{"longest_edge" -- 448})：调整大小后的输出图像大小。图像的最长边将被调整为size["longest_edge"]，同时保持原始图像的纵横比。可以被preprocess方法中的size覆盖。

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

  • do_center_crop (bool，可选，默认为True) — 是否将图像居中裁剪到指定的crop_size。可以被preprocess方法中的do_center_crop参数覆盖。

  • crop_size (Dict[str, int]，可选，默认为{"height" -- 448, "width": 448})：应用中心裁剪后的图像大小。可以被preprocess方法中的crop_size参数覆盖。

  • do_rescale (bool，可选，默认为True) — 是否按指定比例rescale_factor重新缩放图像。可以被preprocess方法中的do_rescale参数覆盖。

  • rescale_factor (int或float，可选，默认为1/255) — 定义如果重新缩放图像要使用的比例因子。可以被preprocess方法中的rescale_factor参数覆盖。

  • do_pad (bool，可选，默认为True) — 是否填充图像。可以被preprocess方法中的do_pad参数覆盖。

  • pad_size（Dict[str, int]，可选，默认为{"height" -- 448, "width": 448}）：应用填充后图像的大小。可以被preprocess方法中的pad_size参数覆盖。

  • constant_values（Union[float, Iterable[float]]，可选，默认为 0）— 在填充图像时使用的填充值。

  • pad_mode（PaddingMode，可选，默认为PaddingMode.CONSTANT）— 在填充中使用什么样的模式。

  • do_normalize（bool，可选，默认为True）— 是否对图像进行归一化。可以被preprocess方法中的do_normalize参数覆盖。

  • do_flip_channel_order（bool，可选，默认为True）— 是否将颜色通道从 RGB 翻转为 BGR。可以被preprocess方法中的do_flip_channel_order参数覆盖。

  • image_mean（float或List[float]，可选，默认为IMAGENET_STANDARD_MEAN）— 如果对图像进行归一化，则使用的均值。这是一个浮点数或与图像通道数相同长度的浮点数列表。可以被preprocess方法中的image_mean参数覆盖。

  • image_std（float或List[float]，可选，默认为IMAGENET_STANDARD_STD）— 如果对图像进行归一化，则使用的标准差。这是一个浮点数或与图像通道数相同长度的浮点数列表。可以被preprocess方法中的image_std参数覆盖。

构造一个 Tvp 图像处理器。

preprocess

<来源>

( videos: Union do_resize: bool = None size: Dict = None resample: Resampling = None do_center_crop: bool = None crop_size: Dict = None do_rescale: bool = None rescale_factor: float = None do_pad: bool = None pad_size: Dict = None constant_values: Union = None pad_mode: PaddingMode = None do_normalize: bool = None do_flip_channel_order: bool = None image_mean: Union = None image_std: Union = None return_tensors: Union = None data_format: ChannelDimension = <ChannelDimension.FIRST: 'channels_first'> input_data_format: Union = None **kwargs )

参数

  • videos（ImageInput或List[ImageInput]或List[List[ImageInput]]）— 要预处理的帧。

  • do_resize（bool，可选，默认为self.do_resize）— 是否调整图像大小。

  • size（Dict[str, int]，可选，默认为self.size）— 调整大小后图像的大小。

  • resample（PILImageResampling，可选，默认为self.resample）— 如果调整图像大小，则使用的重采样滤波器。这可以是枚举PILImageResampling之一，仅在do_resize设置为True时有效。

  • do_center_crop（bool，可选，默认为self.do_centre_crop）— 是否对图像进行中心裁剪。

  • crop_size（Dict[str, int]，可选，默认为self.crop_size）— 应用中心裁剪后图像的大小。

  • do_rescale（bool，可选，默认为self.do_rescale）— 是否将图像值重新缩放在[0 - 1]之间。

  • rescale_factor（float，可选，默认为self.rescale_factor）— 如果do_rescale设置为True，则重新缩放图像的重新缩放因子。

  • do_pad（bool，可选，默认为True）— 是否填充图像。可以被preprocess方法中的do_pad参数覆盖。

  • pad_size（Dict[str, int]，可选，默认为{"height" -- 448, "width": 448}）：应用填充后图像的大小。可以被preprocess方法中的pad_size参数覆盖。

  • constant_values（Union[float, Iterable[float]]，可选，默认为 0）— 在填充图像时使用的填充值。

  • pad_mode（PaddingMode，可选，默认为“PaddingMode.CONSTANT”）— 在填充中使用什么样的模式。

  • do_normalize（bool，可选，默认为self.do_normalize）— 是否对图像进行归一化。

  • do_flip_channel_order（bool，可选，默认为self.do_flip_channel_order）— 是否翻转图像的通道顺序。

  • image_mean（float或List[float]，可选，默认为self.image_mean）— 图像均值。

  • image_std（float或List[float]，可选，默认为self.image_std）— 图像标准差。

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

    • 取消：返回一个np.ndarray列表。

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

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

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

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

  • data_format (ChannelDimension 或 str，可选，默认为 ChannelDimension.FIRST) — 输出图像的通道维度格式。可以是以下之一：

    • ChannelDimension.FIRST：图像以 (num_channels, height, width) 格式。

    • ChannelDimension.LAST：图像以 (height, width, num_channels) 格式。

    • 未设置：使用输入图像的推断通道维度格式。

  • 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) 格式。

预处理图像或图像批次。

TvpProcessor

class transformers.TvpProcessor

< source >

( image_processor = None tokenizer = None **kwargs )

参数

  • image_processor (TvpImageProcessor, 可选) — 图像处理器是必需的输入。

  • tokenizer (BertTokenizerFast, 可选) — tokenizer 是必需的输入。

构建一个 TVP 处理器，将 TVP 图像处理器和 Bert tokenizer 包装成一个单一处理器。

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

__call__

< source >

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

参数

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

  • videos (List[PIL.Image.Image], List[np.ndarray], List[torch.Tensor], List[List[PIL.Image.Image]], List[List[np.ndarrray]], — List[List[torch.Tensor]]): 要准备的视频或视频批次。每个视频应该是一个帧列表，可以是 PIL 图像或 NumPy 数组。对于 NumPy 数组/PyTorch 张量，每个帧应该是形状为 (H, W, C) 的，其中 H 和 W 是帧的高度和宽度，C 是通道数。

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

    • '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 — 要馈送给模型的像素值。当videos不为None时返回。

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

TvpModel

class transformers.TvpModel

< source >

( config )

参数

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

裸 Tvp 模型输出 BaseModelOutputWithPooling 对象，没有特定的头部。此模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

< source >

( input_ids: Optional = None pixel_values: Optional = None attention_mask: Optional = None head_mask: 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)) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。什么是输入 ID？

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

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

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

    • 0 表示被掩盖的标记。什么是注意力掩码？

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

    • 1 表示头部未被掩盖，

    • 0 表示头部被掩盖。

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

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

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

返回

transformers.modeling_outputs.BaseModelOutputWithPooling 或torch.FloatTensor元组

一个 transformers.modeling_outputs.BaseModelOutputWithPooling 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含根据配置（<class 'transformers.models.tvp.configuration_tvp.TvpConfig'>）和输入的各种元素。

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

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

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

示例：

>>> import torch
>>> from transformers import AutoConfig, AutoTokenizer, TvpModel

>>> model = TvpModel.from_pretrained("Jiqing/tiny-random-tvp")

>>> tokenizer = AutoTokenizer.from_pretrained("Jiqing/tiny-random-tvp")

>>> pixel_values = torch.rand(1, 1, 3, 448, 448)
>>> text_inputs = tokenizer("This is an example input", return_tensors="pt")
>>> output = model(text_inputs.input_ids, pixel_values, text_inputs.attention_mask)

TvpForVideoGrounding

class transformers.TvpForVideoGrounding

<来源>

( config )

参数

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

具有视频定位头的 Tvp 模型，计算 IoU、距离和持续时间损失。

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

forward

<来源>

( input_ids: Optional = None pixel_values: Optional = None attention_mask: Optional = None labels: Tuple = None head_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.tvp.modeling_tvp.TvpVideoGroundingOutput or tuple(torch.FloatTensor)

参数

  • input_ids（形状为(batch_size, sequence_length)的torch.LongTensor） — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。什么是输入 ID？

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

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

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

    • 对于被屏蔽的标记返回 0。什么是注意力掩码？

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

  • labels（形状为(batch_size, 3)的torch.FloatTensor，可选） — 标签包含视频的持续时间、开始时间和结束时间，与文本对应。

返回值

transformers.models.tvp.modeling_tvp.TvpVideoGroundingOutput或tuple(torch.FloatTensor)

一个transformers.models.tvp.modeling_tvp.TvpVideoGroundingOutput或一个torch.FloatTensor元组（如果传递了return_dict=False或config.return_dict=False时）包含根据配置（<class 'transformers.models.tvp.configuration_tvp.TvpConfig'>）和输入的不同元素。

  • loss（形状为(1,)的torch.FloatTensor，可选，当return_loss为True时返回） — 视频定位的时间距离 IoU 损失。

  • logits（形状为(batch_size, 2)的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元组（每层一个）。

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

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

示例：

>>> import torch
>>> from transformers import AutoConfig, AutoTokenizer, TvpForVideoGrounding

>>> model = TvpForVideoGrounding.from_pretrained("Jiqing/tiny-random-tvp")

>>> tokenizer = AutoTokenizer.from_pretrained("Jiqing/tiny-random-tvp")

>>> pixel_values = torch.rand(1, 1, 3, 448, 448)
>>> text_inputs = tokenizer("This is an example input", return_tensors="pt")
>>> output = model(text_inputs.input_ids, pixel_values, text_inputs.attention_mask)

ViLT

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

概述

ViLT 模型是由 Wonjae Kim、Bokyung Son、Ildoo Kim 在ViLT: Vision-and-Language Transformer Without Convolution or Region Supervision中提出的。ViLT 将文本嵌入集成到 Vision Transformer（ViT）中，使其在视觉和语言预训练（VLP）中具有最小设计。

论文摘要如下：

视觉和语言预训练（VLP）在各种联合视觉和语言下游任务上提高了性能。当前的 VLP 方法主要依赖于图像特征提取过程，其中大部分涉及区域监督（例如目标检测）和卷积架构（例如 ResNet）。尽管文献中忽略了这一点，但我们发现这在效率/速度方面存在问题，仅仅提取输入特征就需要比多模态交互步骤更多的计算量；以及表达能力方面，因为它受到视觉嵌入器及其预定义视觉词汇表表达能力的上限。在本文中，我们提出了一个最小的 VLP 模型，Vision-and-Language Transformer（ViLT），在处理视觉输入方面与处理文本输入的无卷积方式相同，从而使其成为一个整体。我们展示 ViLT 比以前的 VLP 模型快数十倍，但在下游任务性能上具有竞争力或更好。

ViLT 架构。取自原始论文。

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

使用提示

  • 开始使用 ViLT 的最快方法是查看示例笔记本（展示了对自定义数据的推理和微调）。

  • ViLT 是一个同时接受pixel_values和input_ids作为输入的模型。可以使用 ViltProcessor 为模型准备数据。该处理器将图像处理器（用于图像模态）和标记器（用于语言模态）封装在一起。

  • ViLT 使用各种尺寸的图像进行训练：作者将输入图像的较短边调整为 384，并将较长边限制在 640 以下，同时保持纵横比。为了使图像的批处理成为可能，作者使用一个pixel_mask指示哪些像素值是真实的，哪些是填充的。ViltProcessor 会自动为您创建这个。

  • ViLT 的设计与标准 Vision Transformer（ViT）非常相似。唯一的区别是该模型包括用于语言模态的额外嵌入层。

  • 此模型的 PyTorch 版本仅在 torch 1.10 及更高版本中可用。

ViltConfig

class transformers.ViltConfig

<来源>

( vocab_size = 30522 type_vocab_size = 2 modality_type_vocab_size = 2 max_position_embeddings = 40 hidden_size = 768 num_hidden_layers = 12 num_attention_heads = 12 intermediate_size = 3072 hidden_act = 'gelu' hidden_dropout_prob = 0.0 attention_probs_dropout_prob = 0.0 initializer_range = 0.02 layer_norm_eps = 1e-12 image_size = 384 patch_size = 32 num_channels = 3 qkv_bias = True max_image_length = -1 tie_word_embeddings = False num_images = -1 **kwargs )

参数

  • vocab_size（int，可选，默认为 30522）—模型文本部分的词汇量。定义了在调用 ViltModel 时可以表示的不同标记数量。

  • type_vocab_size（int，可选，默认为 2）—在调用 ViltModel 时传递的token_type_ids的词汇量。在编码文本时使用。

  • modality_type_vocab_size (int, optional, defaults to 2) — 在调用 ViltModel 时传递的模态词汇表大小。在连接文本和图像模态的嵌入后使用。

  • max_position_embeddings (int, optional, defaults to 40) — 该模型可能使用的最大序列长度。

  • 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"、"selu"和"gelu_new"。

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

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

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

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

  • image_size (int, optional, defaults to 384) — 每张图片的大小（分辨率）。

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

  • num_channels (int, optional, defaults to 3) — 输入通道数。

  • qkv_bias (bool, optional, defaults to True) — 是否为查询、键和值添加偏置。

  • max_image_length (int, optional, defaults to -1) — 用于 Transformer 编码器的输入最大补丁数。如果设置为正整数，编码器将最多采样max_image_length个补丁。如果设置为-1，则不会考虑。

  • num_images (int, optional, defaults to -1) — 用于自然语言视觉推理的图像数量。如果设置为正整数，将被 ViltForImagesAndTextClassification 用于定义分类器头。

这是用于存储ViLTModel配置的配置类。根据指定的参数实例化 ViLT 模型，定义模型架构。使用默认值实例化配置将产生类似于 ViLTdandelin/vilt-b32-mlm架构的配置。

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

示例：

>>> from transformers import ViLTModel, ViLTConfig

>>> # Initializing a ViLT dandelin/vilt-b32-mlm style configuration
>>> configuration = ViLTConfig()

>>> # Initializing a model from the dandelin/vilt-b32-mlm style configuration
>>> model = ViLTModel(configuration)

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

ViltFeatureExtractor

class transformers.ViltFeatureExtractor

<来源>

( *args **kwargs )

__call__

<来源>

( images **kwargs )

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

ViltImageProcessor

class transformers.ViltImageProcessor

<来源>

( do_resize: bool = True size: Dict = None size_divisor: int = 32 resample: Resampling = <Resampling.BICUBIC: 3> do_rescale: bool = True rescale_factor: Union = 0.00392156862745098 do_normalize: bool = True image_mean: Union = None image_std: Union = None do_pad: bool = True **kwargs )

参数

  • do_resize (bool, optional, defaults to True) — 是否将图像的（高度，宽度）尺寸调整为指定的 size。可以被 preprocess 方法中的 do_resize 参数覆盖。

  • size (Dict[str, int] optional, defaults to {"shortest_edge" -- 384}): 调整输入的较短边到 size["shortest_edge"]。较长边将被限制在 int((1333 / 800) * size["shortest_edge"]) 以下，同时保持纵横比。仅在 do_resize 设置为 True 时有效。可以被 preprocess 方法中的 size 参数覆盖。

  • size_divisor (int, optional, defaults to 32) — 用于确保高度和宽度都可以被整除的大小。仅在 do_resize 设置为 True 时有效。可以被 preprocess 方法中的 size_divisor 参数覆盖。

  • resample (PILImageResampling, optional, defaults to Resampling.BICUBIC) — 如果调整图像大小，则使用的重采样滤波器。仅在 do_resize 设置为 True 时有效。可以被 preprocess 方法中的 resample 参数覆盖。

  • do_rescale (bool, optional, defaults to True) — 是否按指定比例 rescale_factor 重新缩放图像。可以被 preprocess 方法中的 do_rescale 参数覆盖。

  • rescale_factor (int or float, optional, defaults to 1/255) — 如果重新缩放图像，则使用的缩放因子。仅在 do_rescale 设置为 True 时有效。可以被 preprocess 方法中的 rescale_factor 参数覆盖。

  • do_normalize (bool, optional, defaults to True) — 是否对图像进行归一化。可以被 preprocess 方法中的 do_normalize 参数覆盖。

  • image_mean (float or List[float], optional, defaults to IMAGENET_STANDARD_MEAN) — 如果对图像进行归一化，则使用的均值。这是一个浮点数或与图像通道数相同长度的浮点数列表。可以被 preprocess 方法中的 image_mean 参数覆盖。

  • image_std (float or List[float], optional, defaults to IMAGENET_STANDARD_STD) — 如果对图像进行归一化，则使用的标准差。这是一个浮点数或与图像通道数相同长度的浮点数列表。可以被 preprocess 方法中的 image_std 参数覆盖。

  • do_pad (bool, optional, defaults to True) — 是否将图像填充到批次中图像的（最大高度，最大宽度）。可以被 preprocess 方法中的 do_pad 参数覆盖。

构建一个 ViLT 图像处理器。

preprocess

< source >

( images: Union do_resize: Optional = None size: Optional = None size_divisor: Optional = None resample: Resampling = None do_rescale: Optional = None rescale_factor: Optional = None do_normalize: Optional = None image_mean: Union = None image_std: Union = None do_pad: Optional = None return_tensors: Union = None data_format: ChannelDimension = <ChannelDimension.FIRST: 'channels_first'> input_data_format: Union = None **kwargs )

参数

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

  • do_resize (bool, optional, defaults to self.do_resize) — 是否调整图像大小。

  • size (Dict[str, int], optional, defaults to self.size) — 控制 resize 后图像的大小。图像的最短边被调整为 size["shortest_edge"]，同时保持纵横比。如果调整后图像的最长边 > int(size["shortest_edge"] * (1333 / 800))，则再次调整图像，使最长边等于 int(size["shortest_edge"] * (1333 / 800))。

  • size_divisor (int, optional, defaults to self.size_divisor) — 图像被调整为该值的倍数。

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

  • do_rescale（bool，可选，默认为self.do_rescale）— 是否将图像值重新缩放在[0 - 1]之间。

  • rescale_factor（float，可选，默认为self.rescale_factor）— 如果do_rescale设置为True，用于重新缩放图像的重新缩放因子。

  • do_normalize（bool，可选，默认为self.do_normalize）— 是否对图像进行归一化。

  • image_mean（float或List[float]，可选，默认为self.image_mean）— 如果do_normalize设置为True，用于归一化图像的图像均值。

  • image_std（float或List[float]，可选，默认为self.image_std）— 如果do_normalize设置为True，用于归一化图像的图像标准差。

  • do_pad（bool，可选，默认为self.do_pad）— 是否将图像填充到批处理中的（max_height，max_width）。如果为True，还会创建并返回像素掩码。

  • 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：图像以（通道数，高度，宽度）格式。

    • ChannelDimension.LAST：图像以（高度，宽度，通道数）格式。

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

    • "channels_first"或ChannelDimension.FIRST：图像以（通道数，高度，宽度）格式。

    • "channels_last"或ChannelDimension.LAST：图像以（高度，宽度，通道数）格式。

    • "none"或ChannelDimension.NONE：图像以（高度，宽度）格式。

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

ViltProcessor

class transformers.ViltProcessor

<来源>

( image_processor = None tokenizer = None **kwargs )

参数

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

  • tokenizer（BertTokenizerFast，可选）— 一个[‘BertTokenizerFast`]的实例。分词器是必需的输入。

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

ViltProcessor 提供了 ViltImageProcessor 和 BertTokenizerFast 的所有功能。有关更多信息，请参阅call()和decode()的文档字符串。

__call__

<来源>

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

此方法使用 ViltImageProcessor.call()方法准备模型的图像，并使用 BertTokenizerFast.call()准备模型的文本。

有关更多信息，请参阅上述两种方法的文档字符串。

ViltModel

class transformers.ViltModel

<来源>

( config add_pooling_layer = True )

参数

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

裸 ViLT 模型变压器输出原始隐藏状态，没有特定的头部。此模型是 PyTorch torch.nn.Module <https://pytorch.org/docs/stable/nn.html#torch.nn.Module>_ 子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

< source >

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

参数

  • input_ids (torch.LongTensor of shape ({0})) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

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

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

    • 0 表示被“遮蔽”的标记。什么是注意力掩码？

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

    • 0 对应于 句子 A 标记，

    • 1 对应于 句子 B 标记。什么是标记类型 ID？

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

  • pixel_mask (torch.LongTensor of shape (batch_size, height, width), optional) — 用于避免在填充像素值上执行注意力的掩码。掩码值在 [0, 1] 中选择：

    • 1 表示真实的像素（即未被遮蔽），

    • 0 表示填充的像素（即“遮蔽”）。什么是注意力掩码？<../glossary.html#attention-mask>__

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

    • 1 表示头部未被遮蔽，

    • 0 表示头部被“遮蔽”。

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

  • image_embeds (torch.FloatTensor of shape (batch_size, num_patches, hidden_size), optional) — 可选地，您可以选择直接传递嵌入表示，而不是传递 pixel_values。如果您想要更多控制如何将 pixel_values 转换为补丁嵌入，这将非常有用。

  • 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时），包括根据配置(ViltConfig)和输入的各种元素。

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

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

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

示例：

>>> from transformers import ViltProcessor, ViltModel
>>> from PIL import Image
>>> import requests

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

>>> processor = ViltProcessor.from_pretrained("dandelin/vilt-b32-mlm")
>>> model = ViltModel.from_pretrained("dandelin/vilt-b32-mlm")

>>> inputs = processor(image, text, return_tensors="pt")
>>> outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_state

ViltForMaskedLM

class transformers.ViltForMaskedLM

< source >

( config )

参数

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

在预训练期间，ViLT 模型在顶部带有一个语言建模头。

这个模型是 PyTorch 的torch.nn.Module <https://pytorch.org/docs/stable/nn.html#torch.nn.Module>_ 子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

< source >

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None pixel_values: Optional = None pixel_mask: Optional = None head_mask: Optional = None inputs_embeds: Optional = None image_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.MaskedLMOutput or tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor，形状为 (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。什么是输入 ID？

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

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

  • pixel_mask (torch.LongTensor，形状为 (batch_size, height, width)，可选) — 用于避免在填充像素值上执行注意力的掩码。掩码值选在 [0, 1]：

    • 1 表示像素是真实的（即 未掩码），

    • 0 表示填充的像素（即 被掩码）。什么是注意力掩码？ <../glossary.html#attention-mask>__

  • 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 索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。

  • image_embeds (torch.FloatTensor，形状为 (batch_size, num_patches, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递 pixel_values。如果您想要更多控制权来将 pixel_values 转换为补丁嵌入，这将非常有用。

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

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

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

  • labels（torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 用于计算掩码语言建模损失的标签。索引应在 [-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 时）包含根据配置（ViltConfig）和输入的不同元素。

  • loss (torch.FloatTensor，形状为 (1,)，可选，当提供 labels 时返回) — 掩码语言建模（MLM）损失。

  • logits (torch.FloatTensor，形状为 (batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（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 之后的注意力权重。

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

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

示例：

>>> from transformers import ViltProcessor, ViltForMaskedLM
>>> import requests
>>> from PIL import Image
>>> import re
>>> import torch

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> text = "a bunch of [MASK] laying on a [MASK]."

>>> processor = ViltProcessor.from_pretrained("dandelin/vilt-b32-mlm")
>>> model = ViltForMaskedLM.from_pretrained("dandelin/vilt-b32-mlm")

>>> # prepare inputs
>>> encoding = processor(image, text, return_tensors="pt")

>>> # forward pass
>>> outputs = model(**encoding)

>>> tl = len(re.findall("\[MASK\]", text))
>>> inferred_token = [text]

>>> # gradually fill in the MASK tokens, one by one
>>> with torch.no_grad():
...     for i in range(tl):
...         encoded = processor.tokenizer(inferred_token)
...         input_ids = torch.tensor(encoded.input_ids)
...         encoded = encoded["input_ids"][0][1:-1]
...         outputs = model(input_ids=input_ids, pixel_values=encoding.pixel_values)
...         mlm_logits = outputs.logits[0]  # shape (seq_len, vocab_size)
...         # only take into account text features (minus CLS and SEP token)
...         mlm_logits = mlm_logits[1 : input_ids.shape[1] - 1, :]
...         mlm_values, mlm_ids = mlm_logits.softmax(dim=-1).max(dim=-1)
...         # only take into account text
...         mlm_values[torch.tensor(encoded) != 103] = 0
...         select = mlm_values.argmax().item()
...         encoded[select] = mlm_ids[select].item()
...         inferred_token = [processor.decode(encoded)]

>>> selected_token = ""
>>> encoded = processor.tokenizer(inferred_token)
>>> output = processor.decode(encoded.input_ids[0], skip_special_tokens=True)
>>> print(output)
a bunch of cats laying on a couch.

ViltForQuestionAnswering

class transformers.ViltForQuestionAnswering

<来源>

( config )

参数

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

Vilt 模型变压器，顶部带有分类器头（在 [CLS] 标记的最终隐藏状态之上的线性层），用于视觉问答，例如用于 VQAv2。

这个模型是 PyTorch 的 torch.nn.Module <https://pytorch.org/docs/stable/nn.html#torch.nn.Module>_ 子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有事项。

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None pixel_values: Optional = None pixel_mask: Optional = None head_mask: Optional = None inputs_embeds: Optional = None image_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，形状为 ({0})) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。查看 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 获取详细信息。什么是输入 ID？

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

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

    • 对于被掩码的标记为 0。什么是注意力掩码？

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

    • 0 对应于句子 A的标记，

    • 1 对应于句子 B的标记。什么是标记类型 ID？

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

  • pixel_mask（形状为(batch_size, height, width)的torch.LongTensor，可选）— 用于避免对填充像素值执行注意力的掩码。掩码值选定在[0, 1]之间：

    • 像素为 1 表示是真实像素（即未被掩码），

    • 对于填充像素（即masked）的像素为 0。什么是注意力掩码？<../glossary.html#attention-mask>__

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

    • 1 表示头部未被掩码，

    • 0 表示头部被掩码。

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

  • image_embeds（形状为(batch_size, num_patches, hidden_size)的torch.FloatTensor，可选）— 可选地，您可以选择直接传递嵌入表示，而不是传递pixel_values。如果您想要更多控制如何将pixel_values转换为补丁嵌入，这将非常有用。

  • output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。查看返回的张量中的attentions以获取更多细节。

  • output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。查看返回的张量中的hidden_states以获取更多细节。

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

  • labels（形状为(batch_size, num_labels)的torch.FloatTensor，可选）— 用于计算视觉问答损失的标签。此张量必须是给定示例批次中适用的所有答案的独热编码，或者指示哪些答案适用的软编码，其中 1.0 是最高分。

返回

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

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

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

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

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

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

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

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

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

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

示例：

>>> from transformers import ViltProcessor, ViltForQuestionAnswering
>>> import requests
>>> from PIL import Image

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> text = "How many cats are there?"

>>> processor = ViltProcessor.from_pretrained("dandelin/vilt-b32-finetuned-vqa")
>>> model = ViltForQuestionAnswering.from_pretrained("dandelin/vilt-b32-finetuned-vqa")

>>> # prepare inputs
>>> encoding = processor(image, text, return_tensors="pt")

>>> # forward pass
>>> outputs = model(**encoding)
>>> logits = outputs.logits
>>> idx = logits.argmax(-1).item()
>>> print("Predicted answer:", model.config.id2label[idx])
Predicted answer: 2

ViltForImagesAndTextClassification

transformers.ViltForImagesAndTextClassification 类

< source >

( config )

参数

  • input_ids (torch.LongTensor，形状为 ({0})) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。什么是输入 ID？

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

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

    • 0 表示被掩码的标记。什么是注意力掩码？

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

    • 0 对应于 句子 A 的标记，

    • 1 对应于 句子 B 的标记。什么是标记类型 ID？

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

  • pixel_mask (torch.LongTensor，形状为 (batch_size, num_images, height, width)，可选) — 用于避免在填充像素值上执行注意力的掩码。掩码值在 [0, 1] 中选择：

    • 1 表示真实的像素（即 未被掩码），

    • 0 表示填充的像素（即 被掩码）。什么是注意力掩码？ <../glossary.html#attention-mask>__

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

    • 1 表示头部是 未被掩码，

    • 0 表示头部是 被掩码。

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

  • image_embeds (torch.FloatTensor of shape (batch_size, num_images, num_patches, hidden_size), optional) — 可选地，您可以选择直接传递嵌入表示，而不是传递pixel_values。如果您想要更多控制如何将pixel_values转换为补丁嵌入，这将非常有用。

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

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

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

Vilt 模型变压器，顶部带有自然语言视觉推理的分类器头部，例如 NLVR2。

forward

< source >

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None pixel_values: Optional = None pixel_mask: Optional = None head_mask: Optional = None inputs_embeds: Optional = None image_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.vilt.modeling_vilt.ViltForImagesAndTextClassificationOutput or tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor of shape ({0})) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。什么是输入 ID？

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

    • 1 表示未被masked的标记，

    • 0 表示被masked的标记。什么是注意力掩码？

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

    • 0 对应于句子 A标记，

    • 1 对应于句子 B标记。什么是标记类型 ID？

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

  • pixel_mask (torch.LongTensor of shape (batch_size, height, width), optional) — 用于避免在填充像素值上执行注意力的掩码。掩码值在[0, 1]中选择：

    • 1 表示真实的像素（即not masked），

    • 0 表示填充像素（即masked）。什么是注意力掩码？<../glossary.html#attention-mask>__

  • 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 ({0}, hidden_size), optional) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，这将非常有用，而不是使用模型的内部嵌入查找矩阵。

  • image_embeds (torch.FloatTensor of shape (batch_size, num_patches, hidden_size), optional) — 可选地，您可以选择直接传递嵌入表示，而不是传递pixel_values。如果您想要更多控制如何将pixel_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,), optional) — 二元分类标签。

返回

transformers.models.vilt.modeling_vilt.ViltForImagesAndTextClassificationOutput 或 tuple(torch.FloatTensor)

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

  • 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 (List[tuple(torch.FloatTensor)], optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 一个元组列表，每个元组包含每个图像-文本对的torch.FloatTensor输出（每个元组包含嵌入的输出和每个层的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每个层的输出处的隐藏状态加上初始嵌入输出。

  • attentions (List[tuple(torch.FloatTensor)], optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 一个元组列表，每个元组包含形状为(batch_size, num_heads, sequence_length, sequence_length)的注意力权重的torch.FloatTensor（每个图像-文本对一个元组）。注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import ViltProcessor, ViltForImagesAndTextClassification
>>> import requests
>>> from PIL import Image

>>> image1 = Image.open(requests.get("https://lil.nlp.cornell.edu/nlvr/exs/ex0_0.jpg", stream=True).raw)
>>> image2 = Image.open(requests.get("https://lil.nlp.cornell.edu/nlvr/exs/ex0_1.jpg", stream=True).raw)
>>> text = "The left image contains twice the number of dogs as the right image."

>>> processor = ViltProcessor.from_pretrained("dandelin/vilt-b32-finetuned-nlvr2")
>>> model = ViltForImagesAndTextClassification.from_pretrained("dandelin/vilt-b32-finetuned-nlvr2")

>>> # prepare inputs
>>> encoding = processor([image1, image2], text, return_tensors="pt")

>>> # forward pass
>>> outputs = model(input_ids=encoding.input_ids, pixel_values=encoding.pixel_values.unsqueeze(0))
>>> logits = outputs.logits
>>> idx = logits.argmax(-1).item()
>>> print("Predicted answer:", model.config.id2label[idx])
Predicted answer: True

ViltForImageAndTextRetrieval

class transformers.ViltForImageAndTextRetrieval

<来源>

( config )

参数

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

Vilt 模型变压器，顶部带有分类器头（在[CLS]标记的最终隐藏状态之上的线性层），用于图像到文本或文本到图像检索，例如 MSCOCO 和 F30K。

这个模型是一个 PyTorch torch.nn.Module <https://pytorch.org/docs/stable/nn.html#torch.nn.Module>_ 的子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有内容。

forward

< source >

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

参数

  • input_ids (torch.LongTensor of shape ({0})) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。什么是输入 ID？

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

    • 1 表示 未掩码 的标记，

    • 0 表示被 掩码 的标记。什么是注意力掩码？

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

    • 0 对应于 句子 A 标记，

    • 1 对应于 句子 B 标记。什么是标记类型 ID？

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

  • pixel_mask (torch.LongTensor of shape (batch_size, height, width), optional) — 用于避免在填充像素值上执行注意力的掩码。掩码值在 [0, 1] 中选择：

    • 1 表示真实的像素（即 未掩码），

    • 0 表示填充的像素（即 掩码）。什么是注意力掩码？ <../glossary.html#attention-mask>__

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

    • 1 表示头部 未掩码，

    • 0 表示头部 掩码。

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

  • image_embeds (torch.FloatTensor of shape (batch_size, num_patches, hidden_size), optional) — 可选地，您可以选择直接传递嵌入表示，而不是传递 pixel_values。如果您想要更多控制如何将 pixel_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,), optional) — 目前不支持标签。

返回

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

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

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

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

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

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

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

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

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

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

示例：

>>> from transformers import ViltProcessor, ViltForImageAndTextRetrieval
>>> import requests
>>> from PIL import Image

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> texts = ["An image of two cats chilling on a couch", "A football player scoring a goal"]

>>> processor = ViltProcessor.from_pretrained("dandelin/vilt-b32-finetuned-coco")
>>> model = ViltForImageAndTextRetrieval.from_pretrained("dandelin/vilt-b32-finetuned-coco")

>>> # forward pass
>>> scores = dict()
>>> for text in texts:
...     # prepare inputs
...     encoding = processor(image, text, return_tensors="pt")
...     outputs = model(**encoding)
...     scores[text] = outputs.logits[0, :].item()

ViltForTokenClassification

class transformers.ViltForTokenClassification

<来源>

( config )

参数

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

ViLT 模型在顶部有一个标记分类头（文本标记的最终隐藏状态上的线性层），例如用于命名实体识别（NER）任务。

这个模型是 PyTorch 的torch.nn.Module <https://pytorch.org/docs/stable/nn.html#torch.nn.Module>_ 子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有信息。

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None pixel_values: Optional = None pixel_mask: Optional = None head_mask: Optional = None inputs_embeds: Optional = None image_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（形状为({0})的torch.LongTensor）- 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。什么是输入 ID？

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

    • 1 表示未被遮罩的标记，

    • 0 表示被遮罩的标记。什么是注意力遮罩？

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

    • 0 对应于句子 A标记，

    • 1 对应于句子 B标记。什么是标记类型 ID？

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

  • pixel_mask（形状为(batch_size, height, width)的torch.LongTensor，可选）—用于避免在填充像素值上执行注意力的遮罩。选择的遮罩值在[0, 1]中：

    • 1 表示真实的像素（即未被遮罩），

    • 0 表示填充的像素（即被遮罩）。什么是注意力遮罩？<../glossary.html#attention-mask>__

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

    • 1 表示头部未被遮罩，

    • 0 表示头部被遮罩。

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

  • image_embeds（形状为(batch_size, num_patches, hidden_size)的torch.FloatTensor，可选）—可选地，可以直接传递嵌入表示，而不是传递pixel_values。如果您想要更多控制如何将pixel_values转换为补丁嵌入，这将非常有用。

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

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

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

  • labels（形状为(batch_size, text_sequence_length)的torch.LongTensor，可选）—用于计算标记分类损失的标签。索引应在[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时）包括各种元素，取决于配置（ViltConfig）和输入。

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

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

  • hidden_states (tuple(torch.FloatTensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — Tuple of torch.FloatTensor (one for the output of the embeddings, if the model has an embedding layer, + one for the output of each layer) of shape (batch_size, sequence_length, hidden_size)。

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

  • attentions (tuple(torch.FloatTensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — Tuple of torch.FloatTensor (one for each layer) of shape (batch_size, num_heads, sequence_length, sequence_length)。

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

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

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

posted @ 2024-06-22 14:24  绝不原创的飞龙  阅读(47)  评论(0)  编辑  收藏  举报