原文:
huggingface.co/docs/transformers/v4.37.2/en/model_doc/deplot
DePlot 是由 Fangyu Liu, Julian Martin Eisenschlos, Francesco Piccinno, Syrine Krichene, Chenxi Pang, Kenton Lee, Mandar Joshi, Wenhu Chen, Nigel Collier, Yasemin Altun 在论文DePlot: One-shot visual language reasoning by plot-to-table translation中提出的。
该论文的摘要如下:
图表等视觉语言在人类世界中无处不在。理解图表和图表需要强大的推理能力。先前的最先进(SOTA)模型至少需要数万个训练示例,它们的推理能力仍然非常有限,特别是对于复杂的人类编写的查询。本文提出了视觉语言推理的第一个一次性解决方案。我们将视觉语言推理的挑战分解为两个步骤:(1)图表到文本的翻译,以及(2)对翻译文本进行推理。该方法的关键是一个名为 DePlot 的模态转换模块,它将图表或图表的图像转换为线性化表格。然后可以直接使用 DePlot 的输出来提示预训练的大型语言模型(LLM),利用 LLM 的少量推理能力。为了获得 DePlot,我们通过建立统一的任务格式和度量标准,对绘图到表格任务进行了标准化,并在此任务上端到端地训练 DePlot。然后可以将 DePlot 与 LLM 一起以即插即用的方式使用。与在超过 28k 数据点上微调的 SOTA 模型相比,DePlot+LLM 仅通过一次提示就实现了对人类编写查询的图表 QA 任务的微调 SOTA 的 24.0%的改进。
DePlot 是使用Pix2Struct
架构训练的模型。您可以在Pix2Struct 文档中找到有关Pix2Struct
的更多信息。DePlot 是Pix2Struct
架构的视觉问答子集。它在图像上呈现输入问题并预测答案。
目前 DePlot 有一个检查点可用:
google/deplot
:在 ChartQA 数据集上微调的 DePlotfrom transformers import AutoProcessor, Pix2StructForConditionalGeneration
import requests
from PIL import Image
model = Pix2StructForConditionalGeneration.from_pretrained("google/deplot")
processor = AutoProcessor.from_pretrained("google/deplot")
url = "https://raw.githubusercontent.com/vis-nlp/ChartQA/main/ChartQA%20Dataset/val/png/5090.png"
image = Image.open(requests.get(url, stream=True).raw)
inputs = processor(images=image, text="Generate underlying data table of the figure below:", return_tensors="pt")
predictions = model.generate(**inputs, max_new_tokens=512)
print(processor.decode(predictions[0], skip_special_tokens=True))
要微调 DePlot,请参考 pix2struct 的fine-tuning 笔记本。对于Pix2Struct
模型,我们发现使用 Adafactor 和余弦学习率调度程序对模型进行微调可以实现更快的收敛:
from transformers.optimization import Adafactor, get_cosine_schedule_with_warmup
optimizer = Adafactor(self.parameters(), scale_parameter=False, relative_step=False, lr=0.01, weight_decay=1e-05)
scheduler = get_cosine_schedule_with_warmup(optimizer, num_warmup_steps=1000, num_training_steps=40000)
DePlot 是使用Pix2Struct
架构训练的模型。有关 API 参考,请参阅Pix2Struct
文档。
原文链接:
huggingface.co/docs/transformers/v4.37.2/en/model_doc/donut
Donut 模型是由 Geewook Kim、Teakgyu Hong、Moonbin Yim、Jeongyeon Nam、Jinyoung Park、Jinyeong Yim、Wonseok Hwang、Sangdoo Yun、Dongyoon Han、Seunghyun Park 提出的,用于执行文档理解任务,如文档图像分类、表单理解和视觉问答的图像变压器编码器和自回归文本变压器解码器。
该论文的摘要如下:
理解文档图像(例如发票)是一项核心但具有挑战性的任务,因为它需要复杂的功能,如阅读文本和对文档的整体理解。当前的视觉文档理解(VDU)方法将阅读文本的任务外包给现成的光学字符识别(OCR)引擎,并专注于使用 OCR 输出进行理解任务。尽管这种基于 OCR 的方法表现出有希望的性能,但它们存在以下问题:1)使用 OCR 的计算成本高;2)OCR 模型在语言或文档类型上的不灵活性;3)OCR 错误传播到后续过程。为了解决这些问题,在本文中,我们介绍了一种名为 Donut 的新型无 OCR VDU 模型,代表文档理解变压器。作为无 OCR VDU 研究的第一步,我们提出了一个简单的架构(即变压器)和一个预训练目标(即交叉熵损失)。Donut 在概念上简单而有效。通过大量实验和分析,我们展示了一个简单的无 OCR VDU 模型 Donut,在速度和准确性方面在各种 VDU 任务上取得了最先进的性能。此外,我们提供了一个合成数据生成器,帮助模型在各种语言和领域中进行灵活的预训练。
Donut 高层概述。摘自原始论文。
Donut 的VisionEncoderDecoder
模型接受图像作为输入,并利用 generate()来自动生成给定输入图像的文本。
DonutImageProcessor 类负责预处理输入图像,[XLMRobertaTokenizer
/XLMRobertaTokenizerFast
]解码生成的目标标记为目标字符串。DonutProcessor 将 DonutImageProcessor 和[XLMRobertaTokenizer
/XLMRobertaTokenizerFast
]包装成一个单一实例,既提取输入特征又解码预测的标记 ID。
>>> import re
>>> from transformers import DonutProcessor, VisionEncoderDecoderModel
>>> from datasets import load_dataset
>>> import torch
>>> processor = DonutProcessor.from_pretrained("naver-clova-ix/donut-base-finetuned-rvlcdip")
>>> model = VisionEncoderDecoderModel.from_pretrained("naver-clova-ix/donut-base-finetuned-rvlcdip")
>>> device = "cuda" if torch.cuda.is_available() else "cpu"
>>> model.to(device)
>>> # load document image
>>> dataset = load_dataset("hf-internal-testing/example-documents", split="test")
>>> image = dataset[1]["image"]
>>> # prepare decoder inputs
>>> task_prompt = "<s_rvlcdip>"
>>> decoder_input_ids = processor.tokenizer(task_prompt, add_special_tokens=False, return_tensors="pt").input_ids
>>> pixel_values = processor(image, return_tensors="pt").pixel_values
>>> outputs = model.generate(
... pixel_values.to(device),
... decoder_input_ids=decoder_input_ids.to(device),
... max_length=model.decoder.config.max_position_embeddings,
... pad_token_id=processor.tokenizer.pad_token_id,
... eos_token_id=processor.tokenizer.eos_token_id,
... use_cache=True,
... bad_words_ids=[[processor.tokenizer.unk_token_id]],
... return_dict_in_generate=True,
... )
>>> sequence = processor.batch_decode(outputs.sequences)[0]
>>> sequence = sequence.replace(processor.tokenizer.eos_token, "").replace(processor.tokenizer.pad_token, "")
>>> sequence = re.sub(r"<.*?>", "", sequence, count=1).strip() # remove first task start token
>>> print(processor.token2json(sequence))
{'class': 'advertisement'}
>>> import re
>>> from transformers import DonutProcessor, VisionEncoderDecoderModel
>>> from datasets import load_dataset
>>> import torch
>>> processor = DonutProcessor.from_pretrained("naver-clova-ix/donut-base-finetuned-cord-v2")
>>> model = VisionEncoderDecoderModel.from_pretrained("naver-clova-ix/donut-base-finetuned-cord-v2")
>>> device = "cuda" if torch.cuda.is_available() else "cpu"
>>> model.to(device)
>>> # load document image
>>> dataset = load_dataset("hf-internal-testing/example-documents", split="test")
>>> image = dataset[2]["image"]
>>> # prepare decoder inputs
>>> task_prompt = "<s_cord-v2>"
>>> decoder_input_ids = processor.tokenizer(task_prompt, add_special_tokens=False, return_tensors="pt").input_ids
>>> pixel_values = processor(image, return_tensors="pt").pixel_values
>>> outputs = model.generate(
... pixel_values.to(device),
... decoder_input_ids=decoder_input_ids.to(device),
... max_length=model.decoder.config.max_position_embeddings,
... pad_token_id=processor.tokenizer.pad_token_id,
... eos_token_id=processor.tokenizer.eos_token_id,
... use_cache=True,
... bad_words_ids=[[processor.tokenizer.unk_token_id]],
... return_dict_in_generate=True,
... )
>>> sequence = processor.batch_decode(outputs.sequences)[0]
>>> sequence = sequence.replace(processor.tokenizer.eos_token, "").replace(processor.tokenizer.pad_token, "")
>>> sequence = re.sub(r"<.*?>", "", sequence, count=1).strip() # remove first task start token
>>> print(processor.token2json(sequence))
{'menu': {'nm': 'CINNAMON SUGAR', 'unitprice': '17,000', 'cnt': '1 x', 'price': '17,000'}, 'sub_total': {'subtotal_price': '17,000'}, 'total': {'total_price': '17,000', 'cashprice': '20,000', 'changeprice': '3,000'}}
>>> import re
>>> from transformers import DonutProcessor, VisionEncoderDecoderModel
>>> from datasets import load_dataset
>>> import torch
>>> processor = DonutProcessor.from_pretrained("naver-clova-ix/donut-base-finetuned-docvqa")
>>> model = VisionEncoderDecoderModel.from_pretrained("naver-clova-ix/donut-base-finetuned-docvqa")
>>> device = "cuda" if torch.cuda.is_available() else "cpu"
>>> model.to(device)
>>> # load document image from the DocVQA dataset
>>> dataset = load_dataset("hf-internal-testing/example-documents", split="test")
>>> image = dataset[0]["image"]
>>> # prepare decoder inputs
>>> task_prompt = "<s_docvqa><s_question>{user_input}</s_question><s_answer>"
>>> question = "When is the coffee break?"
>>> prompt = task_prompt.replace("{user_input}", question)
>>> decoder_input_ids = processor.tokenizer(prompt, add_special_tokens=False, return_tensors="pt").input_ids
>>> pixel_values = processor(image, return_tensors="pt").pixel_values
>>> outputs = model.generate(
... pixel_values.to(device),
... decoder_input_ids=decoder_input_ids.to(device),
... max_length=model.decoder.config.max_position_embeddings,
... pad_token_id=processor.tokenizer.pad_token_id,
... eos_token_id=processor.tokenizer.eos_token_id,
... use_cache=True,
... bad_words_ids=[[processor.tokenizer.unk_token_id]],
... return_dict_in_generate=True,
... )
>>> sequence = processor.batch_decode(outputs.sequences)[0]
>>> sequence = sequence.replace(processor.tokenizer.eos_token, "").replace(processor.tokenizer.pad_token, "")
>>> sequence = re.sub(r"<.*?>", "", sequence, count=1).strip() # remove first task start token
>>> print(processor.token2json(sequence))
{'question': 'When is the coffee break?', 'answer': '11-14 to 11:39 a.m.'}
查看model hub以查找 Donut 检查点。
请参阅教程笔记本。
class transformers.DonutSwinConfig
( image_size = 224 patch_size = 4 num_channels = 3 embed_dim = 96 depths = [2, 2, 6, 2] num_heads = [3, 6, 12, 24] window_size = 7 mlp_ratio = 4.0 qkv_bias = True hidden_dropout_prob = 0.0 attention_probs_dropout_prob = 0.0 drop_path_rate = 0.1 hidden_act = 'gelu' use_absolute_embeddings = False initializer_range = 0.02 layer_norm_eps = 1e-05 **kwargs )
参数
image_size
(int
, optional, defaults to 224) — 每个图像的大小(分辨率)。
patch_size
(int
, optional, defaults to 4) — 每个补丁的大小(分辨率)。
num_channels
(int
, optional, defaults to 3) — 输入通道数。
embed_dim
(int
, optional, defaults to 96) — 补丁嵌入的维度。
depths
(list(int)
, optional, defaults to [2, 2, 6, 2]
) — Transformer 编码器中每层的深度。
num_heads
(list(int)
, optional, defaults to [3, 6, 12, 24]
) — Transformer 编码器每层的注意力头数。
window_size
(int
, optional, defaults to 7) — 窗口大小。
mlp_ratio
(float
, optional, defaults to 4.0) — MLP 隐藏维度与嵌入维度的比率。
qkv_bias
(bool
, optional, defaults to True
) — 是否为查询、键和值添加可学习的偏置。
hidden_dropout_prob
(float
, optional, defaults to 0.0) — 嵌入层和编码器中所有全连接层的 dropout 概率。
attention_probs_dropout_prob
(float
, optional, defaults to 0.0) — 注意力概率的 dropout 比率。
drop_path_rate
(float
, optional, defaults to 0.1) — 随机深度率。
hidden_act
(str
or function
, optional, defaults to "gelu"
) — 编码器中的非线性激活函数(函数或字符串)。如果是字符串,支持"gelu"
、"relu"
、"selu"
和"gelu_new"
。
use_absolute_embeddings
(bool
, optional, defaults to False
) — 是否将绝对位置嵌入添加到补丁嵌入中。
initializer_range
(float
, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
layer_norm_eps
(float
, optional, defaults to 1e-05) — 层归一化层使用的 epsilon。
这是用于存储 DonutSwinModel 配置的配置类。根据指定的参数实例化一个 Donut 模型,定义模型架构。使用默认值实例化配置将产生类似于 Donut naver-clova-ix/donut-base架构的配置。
配置对象继承自 PretrainedConfig,可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。
示例:
>>> from transformers import DonutSwinConfig, DonutSwinModel
>>> # Initializing a Donut naver-clova-ix/donut-base style configuration
>>> configuration = DonutSwinConfig()
>>> # Randomly initializing a model from the naver-clova-ix/donut-base style configuration
>>> model = DonutSwinModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
class transformers.DonutImageProcessor
( do_resize: bool = True size: Dict = None resample: Resampling = <Resampling.BILINEAR: 2> do_thumbnail: bool = True do_align_long_axis: bool = False do_pad: bool = True do_rescale: bool = True rescale_factor: Union = 0.00392156862745098 do_normalize: bool = True image_mean: Union = None image_std: Union = None **kwargs )
参数
do_resize
(bool
, optional, defaults to True
) — 是否将图像的(高度,宽度)尺寸调整为指定的size
。可以被preprocess
方法中的do_resize
覆盖。
size
(Dict[str, int]
optional, defaults to {"shortest_edge" -- 224}
): 调整大小后的图像尺寸。图像的最短边被调整为 size[“shortest_edge”],最长边被调整以保持输入的长宽比。可以被preprocess
方法中的size
覆盖。
resample
(PILImageResampling
, optional, defaults to Resampling.BILINEAR
) — 如果调整图像大小,要使用的重采样滤波器。可以被preprocess
方法中的resample
覆盖。
do_thumbnail
(bool
, optional, defaults to True
) — 是否使用缩略图方法调整图像大小。
do_align_long_axis
(bool
,可选,默认为 False
) — 是否通过旋转 90 度来使图像的长轴与 size
的长轴对齐。
do_pad
(bool
,可选,默认为 True
) — 是否填充图像。如果在 preprocess
中将 random_padding
设置为 True
,则每个图像都会在每一侧填充随机数量的填充,直到批次中最大的图像尺寸。否则,所有图像都会填充到批次中最大的图像尺寸。
do_rescale
(bool
,可选,默认为 True
) — 是否按照指定的比例因子 rescale_factor
重新调整图像。可以被 preprocess
方法中的 do_rescale
覆盖。
rescale_factor
(int
或 float
,可选,默认为 1/255
) — 如果重新调整图像,则使用的比例因子。可以被 preprocess
方法中的 rescale_factor
覆盖。
do_normalize
(bool
,可选,默认为 True
) — 是否对图像进行归一化。可以被 preprocess
方法中的 do_normalize
覆盖。
image_mean
(float
或 List[float]
,可选,默认为 IMAGENET_STANDARD_MEAN
) — 如果对图像进行归一化,则使用的均值。这是一个浮点数或与图像通道数相同长度的浮点数列表。可以被 preprocess
方法中的 image_mean
参数覆盖。
image_std
(float
或 List[float]
,可选,默认为 IMAGENET_STANDARD_STD
) — 图像标准差。
构建一个 Donut 图像处理器。
preprocess
( images: Union do_resize: bool = None size: Dict = None resample: Resampling = None do_thumbnail: bool = None do_align_long_axis: bool = None do_pad: bool = None random_padding: bool = False 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
) — 调整大小后的图像尺寸。图像的最短边被调整为 min(size[“height”], size[“width”]),最长边被调整以保持输入的长宽比。
resample
(int
,可选,默认为 self.resample
) — 如果调整图像大小,则使用的重采样滤波器。这可以是 PILImageResampling
枚举值之一。仅当 do_resize
设置为 True
时才会生效。
do_thumbnail
(bool
,可选,默认为 self.do_thumbnail
) — 是否使用缩略图方法调整图像大小。
do_align_long_axis
(bool
,可选,默认为 self.do_align_long_axis
) — 是否通过旋转 90 度来使图像的长轴与 size
的长轴对齐。
do_pad
(bool
,可选,默认为 self.do_pad
) — 是否填充图像。如果在 preprocess
中将 random_padding
设置为 True
,则每个图像都会在每一侧填充随机数量的填充,直到批次中最大的图像尺寸。否则,所有图像都会填充到批次中最大的图像尺寸。
random_padding
(bool
,可选,默认为 self.random_padding
) — 在填充图像时是否使用随机填充。如果为 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
) — 用于归一化的图像均值。
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
:图片格式为(通道数,高度,宽度)。
ChannelDimension.LAST
:图片格式为(高度,宽度,通道数)。
input_data_format
(ChannelDimension
或str
,可选)— 输入图片的通道维度格式。如果未设置,将从输入图片中推断通道维度格式。可以是以下之一:
"channels_first"
或ChannelDimension.FIRST
:图片格式为(通道数,高度,宽度)。
"channels_last"
或ChannelDimension.LAST
:图片格式为(高度,宽度,通道数)。
"none"
或ChannelDimension.NONE
:图片格式为(高度,宽度)。
预处理一张图片或一批图片。
class transformers.DonutFeatureExtractor
( *args **kwargs )
__call__
( images **kwargs )
预处理一张图片或一批图片。
class transformers.DonutProcessor
( image_processor = None tokenizer = None **kwargs )
参数
image_processor
(DonutImageProcessor,可选)— DonutImageProcessor 的实例。图像处理器是必需的输入。
tokenizer
([XLMRobertaTokenizer
/XLMRobertaTokenizerFast
],可选)— [XLMRobertaTokenizer
/XLMRobertaTokenizerFast
]的实例。分词器是必需的输入。
构建一个 Donut 处理器,将一个 Donut 图像处理器和一个 XLMRoBERTa 分词器包装成一个单一处理器。
DonutProcessor 提供了 DonutImageProcessor 和[XLMRobertaTokenizer
/XLMRobertaTokenizerFast
]的所有功能。查看更多信息,请参阅call()和 decode()。
__call__
( *args **kwargs )
在正常模式下使用时,此方法将所有参数转发到 AutoImageProcessor 的__call__()
并返回其输出。如果在上下文as_target_processor()
中使用,则此方法将所有参数转发到 DonutTokenizer 的~DonutTokenizer.__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
)— 这可以是:
bert-base-uncased
,或者在用户或组织名称下进行命名空间化,如dbmdz/bert-base-german-cased
。
./my_model_directory/
。
./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_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()。更多信息请参考上述方法的文档字符串。
批量解码
( *args **kwargs )
这个方法将所有参数转发给 DonutTokenizer 的 batch_decode()。更多信息请参考此方法的文档字符串。
解码
( *args **kwargs )
这个方法将所有参数转发给 DonutTokenizer 的 decode()。更多信息请参考此方法的文档字符串。
class transformers.DonutSwinModel
( config add_pooling_layer = True use_mask_token = False )
参数
config
(DonutSwinConfig)— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。裸 Donut Swin 模型变压器输出原始隐藏状态,没有特定的头部在顶部。该模型是 PyTorch torch.nn.Module子类。将其用作常规的 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。
前向
( pixel_values: Optional = None bool_masked_pos: Optional = None head_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.donut.modeling_donut_swin.DonutSwinModelOutput or tuple(torch.FloatTensor)
参数
pixel_values
(形状为(batch_size, num_channels, height, width)
的torch.FloatTensor
)— 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息,请参阅 DonutImageProcessor.call
()。
head_mask
(形状为(num_heads,)
或(num_layers, num_heads)
的torch.FloatTensor
,可选)— 用于使自注意力模块中选择的头部失效的掩码。掩码值在[0, 1]
中选择:
output_attentions
(bool
,可选)— 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions
。
output_hidden_states
(bool
,可选)— 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
。
return_dict
(bool
,可选)— 是否返回 ModelOutput 而不是普通元组。
bool_masked_pos
(形状为(batch_size, num_patches)
的torch.BoolTensor
)— 布尔掩码位置。指示哪些补丁被屏蔽(1)哪些没有(0)。
返回值
transformers.models.donut.modeling_donut_swin.DonutSwinModelOutput
或tuple(torch.FloatTensor)
一个transformers.models.donut.modeling_donut_swin.DonutSwinModelOutput
或一个torch.FloatTensor
元组(如果传递return_dict=False
或config.return_dict=False
)包含根据配置(DonutSwinConfig)和输入的各种元素。
last_hidden_state
(形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
)— 模型最后一层的隐藏状态序列。
pooler_output
(形状为(batch_size, hidden_size)
的torch.FloatTensor
,可选,当传递add_pooling_layer=True
时返回)— 最后一层隐藏状态的平均池化。
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 之后的注意力权重,用于计算自注意力头中的加权平均值。
reshaped_hidden_states
(tuple(torch.FloatTensor)
, optional, 当传递 output_hidden_states=True
或当 config.output_hidden_states=True
时返回) — 形状为 (batch_size, hidden_size, height, width)
的 torch.FloatTensor
元组(一个用于嵌入的输出 + 一个用于每个阶段的输出)。
模型在每一层输出的隐藏状态以及包括空间维度的初始嵌入输出进行了重塑。
DonutSwinModel 的前向方法,覆盖了 __call__
特殊方法。
虽然前向传递的步骤需要在这个函数内定义,但应该在之后调用 Module
实例,而不是这个函数,因为前者会处理运行前后的处理步骤,而后者会默默地忽略它们。
示例:
>>> from transformers import AutoImageProcessor, DonutSwinModel
>>> import torch
>>> from datasets import load_dataset
>>> dataset = load_dataset("huggingface/cats-image")
>>> image = dataset["test"]["image"][0]
>>> image_processor = AutoImageProcessor.from_pretrained("https://huggingface.co/naver-clova-ix/donut-base")
>>> model = DonutSwinModel.from_pretrained("https://huggingface.co/naver-clova-ix/donut-base")
>>> inputs = image_processor(image, return_tensors="pt")
>>> with torch.no_grad():
... outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 49, 768]
原文链接:
huggingface.co/docs/transformers/v4.37.2/en/model_doc/flava
FLAVA 模型在FLAVA: A Foundational Language And Vision Alignment Model中由 Amanpreet Singh, Ronghang Hu, Vedanuj Goswami, Guillaume Couairon, Wojciech Galuba, Marcus Rohrbach 和 Douwe Kiela 提出,并已被 CVPR 2022 接受。
该论文旨在创建一个统一的基础模型,可以跨越视觉、语言以及视觉-语言多模态任务。
论文摘要如下:
最先进的视觉和视觉-语言模型依赖于大规模视觉-语言预训练,以在各种下游任务上获得良好的性能。通常,这些模型通常是跨模态(对比)或多模态(具有早期融合),但不是两者兼具;它们通常只针对特定的模态或任务。一个有前途的方向是使用一个单一的整体通用模型,作为“基础”,一次性针对所有模态 —— 一个真正的视觉和语言基础模型应该擅长视觉任务、语言任务以及视觉和语言任务。我们介绍 FLAVA 作为这样一个模型,并展示了在涵盖这些目标模态的 35 个任务范围内的出色性能。
class transformers.FlavaConfig
( image_config: Dict = None text_config: Dict = None multimodal_config: Dict = None image_codebook_config: Dict = None hidden_size: int = 768 layer_norm_eps: float = 1e-12 projection_dim: int = 768 init_codebook: bool = True logit_scale_init_value: float = 2.6592 initializer_range: float = 0.02 ce_ignore_index: int = -100 mim_weight: float = 1.0 mlm_weight: float = 1.0 global_contrastive_weight: float = 1.0 itm_weight: float = 1.0 mmm_image_weight: float = 1.0 mmm_text_weight: float = 1.0 global_backprop_contrastive: bool = True skip_unmasked_multimodal_encoder: bool = True return_loss: bool = True **kwargs )
参数
text_config
(dict
, optional) — 用于初始化 FlavaTextConfig 的配置选项字典。
image_config
(dict
, optional) — 用于初始化 FlavaImageConfig 的配置选项字典。
multimodal_config
(dict
, optional) — 用于初始化 FlavaMultimodalConfig 的配置选项字典。
hidden_size
(int
, optional, 默认为 768) — 编码器层和池化层的维度。
layer_norm_eps
(float
, optional, 默认为 1e-12) — 层归一化层使用的 epsilon 值。
projection_dim
(int
, optional, 默认为 512) — 文本和图像投影层的维度。
logit_scale_init_value
(float
, optional, 默认为 2.6592) — logit_scale参数的初始值。默认值与原始 FLAVA/CLIP 实现相同。
initializer_range
(float
, optional, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
ce_ignore_index
(int
, optional, 默认为-100) — 用于忽略的交叉熵索引。
mim_weight
(float
, optional, 默认为 1.0) — 分配给 MIM(Masked Image Modeling)单模态损失的权重。
mlm_weight
(float
, optional, 默认为 1.0) — 分配给 MLM(Masked Language Modeling)单模态损失的权重。
global_contrastive_weight
(float
, optional, 默认为 1.0) — 分配给全局对比度交叉对齐损失的权重。
itm_weight
(float
, optional, 默认为 1.0) — 分配给图像-文本匹配多模态损失的权重。
mmm_image_weight
(float
, optional, 默认为 1.0) — 分配给 MMM 损失图像部分的权重。
mmm_text_weight
(float
, optional, 默认为 1.0) — 分配给 MMM 损失文本部分的权重。
global_backprop_contrastive
(bool
, optional, 默认为True
) — 是否在对比损失中通过所有工作器进行全局反向传播。
skip_unmasked_multimodal_encoder
(bool
,可选,默认为True
)— 是否跳过运行未屏蔽的多模态编码器,其输出不被 FLAVA 损失使用。
return_loss
(bool
,可选,默认为True
)— 是否返回损失或不返回
kwargs
(可选)— 关键字参数的字典。
FlavaConfig 是用于存储 FlavaModel 配置的配置类。根据指定的参数实例化 FLAVA 模型,定义文本模型、图像模型、图像码书和多模态模型配置。使用默认值实例化配置将产生类似于 FLAVA facebook/flava-full架构的配置。
配置对象继承自 PretrainedConfig,可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。
示例:
>>> from transformers import FlavaConfig, FlavaModel, FlavaForPreTraining
>>> # Initializing a FlavaConfig with style configuration
>>> configuration = FlavaConfig()
>>> # Initializing a FlavaModel and FlavaForPreTraining model (with random weights) from the style configuration
>>> model = FlavaModel(configuration)
>>> model_pre = FlavaForPreTraining(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
>>> configuration_pre = model_pre.config
from_configs
( image_config: FlavaImageConfig text_config: FlavaTextConfig multimodal_config: FlavaMultimodalConfig image_codebook_config: FlavaImageCodebookConfig **kwargs ) → export const metadata = 'undefined';FlavaConfig
返回
FlavaConfig
配置对象的实例
从 flava 文本模型配置、flava 图像模型配置、flava 多模态模型和 flava 码书模型配置中实例化一个 FlavaConfig(或派生类)。
class transformers.FlavaTextConfig
( vocab_size: int = 30522 type_vocab_size: int = 2 max_position_embeddings: int = 512 position_embedding_type: str = 'absolute' hidden_size: int = 768 num_hidden_layers: int = 12 num_attention_heads: int = 12 intermediate_size: int = 3072 hidden_act: str = 'gelu' hidden_dropout_prob: float = 0.0 attention_probs_dropout_prob: float = 0.0 initializer_range: float = 0.02 layer_norm_eps: float = 1e-12 pad_token_id: int = 0 qkv_bias: bool = True **kwargs )
参数
vocab_size
(int
,可选,默认为 30522)— BERT 模型的词汇量。定义在调用 FlavaTextModel 时可以表示的不同标记数量。
type_vocab_size
(int
,可选,默认为 2)— 在调用 FlavaTextModel 时传递的token_type_ids
的词汇量大小。请注意,即使文本编码器允许token_type_ids
的值为 2,但对于仅文本的预训练和微调,类似于 RoBERTa,只使用 1。
max_position_embeddings
(int
,可选,默认为 512)— 模型可能使用的最大序列长度。通常设置为较大的值以防万一(例如 512、1024 或 2048)。对于 VL,传递给模型的 max_length 为 77。
position_embedding_type
(str
,可选,默认为"absolute"
)— 位置嵌入的类型。选择"absolute"
、"relative_key"
、"relative_key_query"
中的一个。对于位置嵌入,请使用"absolute"
。有关"relative_key"
的更多信息,请参考Self-Attention with Relative Position Representations (Shaw et al.)。有关"relative_key_query"
的更多信息,请参考Improve Transformer Models with Better Relative Position Embeddings (Huang et al.)中的Method 4。
hidden_size
(int
,可选,默认为 768)— 编码器层和池化层的维度。
num_hidden_layers
(int
,可选,默认为 12)— Transformer 编码器中的隐藏层数。
num_attention_heads
(int
,可选,默认为 12)— Transformer 编码器中每个注意力层的注意力头数。
intermediate_size
(int
,可选,默认为 3072)— Transformer 编码器中“中间”(即前馈)层的维度。
hidden_act
(str
or function
, optional, defaults to "gelu"
) — 编码器和池化器中的非线性激活函数(函数或字符串)。如果是字符串,支持"gelu"
、"relu"
、"selu"
和"gelu_new"
。
hidden_dropout_prob
(float
, optional, defaults to 0.1) — 嵌入层、编码器和池化器中所有全连接层的 dropout 概率。
attention_probs_dropout_prob
(float
, optional, defaults to 0.1) — 注意力概率的 dropout 比率。
initializer_range
(float
, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
layer_norm_eps
(float
, optional, defaults to 1e-12) — 层归一化层使用的 epsilon。
image_size
(int
, optional, defaults to 224) — 每个图像的大小(分辨率)。
patch_size
(int
, optional, defaults to 16) — 每个补丁的大小(分辨率)。
num_channels
(int
, optional, defaults to 3) — 输入通道的数量。
qkv_bias
(bool
, optional, defaults to True
) — 是否为查询、键和值添加偏置。
这是用于存储 FlavaTextModel 配置的配置类。根据指定的参数实例化 FLAVA 模型,定义模型架构。
使用默认值实例化配置将产生类似于 FLAVA facebook/flava-full架构的配置。
配置对象继承自 PretrainedConfig,可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。
示例:
>>> from transformers import FlavaTextConfig, FlavaTextModel
>>> # Initializing a FlavaTextModel with style configuration
>>> configuration = FlavaTextConfig()
>>> # Initializing a FlavaTextModel model (with random weights) from the style configuration
>>> model = FlavaTextModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
class transformers.FlavaImageConfig
( hidden_size: int = 768 num_hidden_layers: int = 12 num_attention_heads: int = 12 intermediate_size: int = 3072 hidden_act: int = 'gelu' hidden_dropout_prob: float = 0.0 attention_probs_dropout_prob: float = 0.0 initializer_range: float = 0.02 layer_norm_eps: float = 1e-12 image_size: int = 224 patch_size: int = 16 num_channels: int = 3 qkv_bias: bool = True mask_token: bool = True vocab_size: int = 8192 **kwargs )
参数
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) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
layer_norm_eps
(float
, optional, defaults to 1e-12) — 层归一化层使用的 epsilon。
image_size
(int
, optional, defaults to 224) — 每个图像的大小(分辨率)。
patch_size
(int
, optional, defaults to 16) — 每个补丁的大小(分辨率)。
num_channels
(int
, optional, defaults to 3) — 输入通道的数量。
qkv_bias
(bool
, optional, defaults to True
) — 是否为查询、键和值添加偏置。
mask_token
(bool
, optional, defaults to True
) — 是否使用掩码标记。用于 FLAVA 的 MIM(Masked Image Modeling)损失。
vocab_size
(int
,可选,默认为 8192) — 与 FlavaImageModel 一起用于 FLAVA 的 MIM(Masked Image Modeling)损失的 FlavaImageCodebook 的词汇表大小。
这是用于存储 FlavaImageModel 配置的配置类。根据指定的参数实例化 FLAVA 模型,定义模型架构。
使用默认值实例化配置将产生类似于 FLAVA facebook/flava-full 架构的配置。
配置对象继承自 PretrainedConfig,可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。
示例:
>>> from transformers import FlavaImageConfig, FlavaImageModel
>>> # Initializing a FlavaImageModel with style configuration
>>> configuration = FlavaImageConfig()
>>> # Initializing a FlavaImageModel model (with random weights) from the style configuration
>>> model = FlavaImageModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
class transformers.FlavaMultimodalConfig
( hidden_size: int = 768 num_hidden_layers: int = 6 num_attention_heads: int = 12 intermediate_size: int = 3072 hidden_act: int = 'gelu' hidden_dropout_prob: int = 0.0 attention_probs_dropout_prob: int = 0.0 initializer_range: float = 0.02 layer_norm_eps: float = 1e-12 qkv_bias: bool = True use_cls_token: bool = True **kwargs )
参数
hidden_size
(int
,可选,默认为 768) — 编码器层和池化层的维度。
num_hidden_layers
(int
,可选,默认为 6) — 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) — 嵌入层、编码器和池化器中所有全连接层的 dropout 概率。
attention_probs_dropout_prob
(float
,可选,默认为 0.0) — 注意力概率的 dropout 比率。
initializer_range
(float
,可选,默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
layer_norm_eps
(float
,可选,默认为 1e-12) — 层归一化层使用的 epsilon。
qkv_bias
(bool
,可选,默认为True
) — 是否向查询、键和值添加偏置。
use_cls_token
(bool
,可选,默认为True
) — 是否在多模态设置中使用额外的 CLS 标记。通常由 FLAVA 模型需要。
这是用于存储 FlavaMultimodalModel 配置的配置类。根据指定的参数实例化 FLAVA 模型,定义模型架构。
使用默认值实例化配置将产生类似于 FLAVA facebook/flava-full 架构的配置。
配置对象继承自 PretrainedConfig,可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。
示例:
>>> from transformers import FlavaMultimodalConfig, FlavaMultimodalModel
>>> # Initializing a FlavaMultimodalModel with style configuration
>>> configuration = FlavaMultimodalConfig()
>>> # Initializing a FlavaMultimodalModel model (with random weights) from the style configuration
>>> model = FlavaMultimodalModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
class transformers.FlavaImageCodebookConfig
( num_groups: int = 4 input_channels: int = 3 num_blocks_per_group: int = 2 hidden_size: int = 256 vocab_size: int = 8192 freeze: int = True initializer_range: float = 0.02 **kwargs )
class transformers.FlavaProcessor
( image_processor = None tokenizer = None **kwargs )
参数
image_processor
(FlavaImageProcessor,可选)— 图像处理器是必需的输入。
tokenizer
(BertTokenizerFast,可选)— Tokenizer 是必需的输入。
构造一个 FLAVA 处理器,将 FLAVA 图像处理器和 FLAVA 标记器包装成单个处理器。
FlavaProcessor 提供了 FlavaImageProcessor 和 BertTokenizerFast 的所有功能。有关更多信息,请参阅__call__()
和 decode()。
batch_decode
( *args **kwargs )
这种方法将其所有参数转发给 BertTokenizerFast 的 batch_decode()。有关更多信息,请参考此方法的文档字符串。
decode
( *args **kwargs )
这种方法将其所有参数转发给 BertTokenizerFast 的 decode()。有关更多信息,请参考此方法的文档字符串。
class transformers.FlavaFeatureExtractor
( *args **kwargs )
class transformers.FlavaImageProcessor
( do_resize: bool = True size: Dict = None resample: Resampling = <Resampling.BICUBIC: 3> 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 = None image_std: Union = None return_image_mask: bool = False input_size_patches: int = 14 total_mask_patches: int = 75 mask_group_min_patches: int = 16 mask_group_max_patches: Optional = None mask_group_min_aspect_ratio: float = 0.3 mask_group_max_aspect_ratio: Optional = None return_codebook_pixels: bool = False codebook_do_resize: bool = True codebook_size: bool = None codebook_resample: int = <Resampling.LANCZOS: 1> codebook_do_center_crop: bool = True codebook_crop_size: int = None codebook_do_rescale: bool = True codebook_rescale_factor: Union = 0.00392156862745098 codebook_do_map_pixels: bool = True codebook_do_normalize: bool = True codebook_image_mean: Union = None codebook_image_std: Union = None **kwargs )
参数
do_resize
(bool
,可选,默认为True
)— 是否将图像的(高度,宽度)尺寸调整为指定的size
。可以被preprocess
中的do_resize
参数覆盖。
size
(Dict[str, int]
可选,默认为{"height" -- 224, "width": 224}
):调整大小后的图像尺寸。可以被preprocess
中的size
参数覆盖。
resample
(PILImageResampling
,可选,默认为PILImageResampling.BICUBIC
)— 如果调整图像大小,则要使用的重采样滤镜。可以被preprocess
中的resample
参数覆盖。
do_center_crop
(bool
,可选,默认为True
)— 是否对图像进行中心裁剪。可以被preprocess
中的do_center_crop
参数覆盖。
crop_size
(Dict[str, int]
可选,默认为{"height" -- 224, "width": 224}
):中心裁剪后图像的大小(crop_size["height"], crop_size["width"])
。可以被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]
, optional, 默认为 IMAGENET_STANDARD_MEAN
) — 如果对图像进行标准化,则使用的均值。这是一个浮点数或与图像通道数相同长度的浮点数列表。可以被 preprocess
方法中的 image_mean
参数覆盖。
image_std
(float
或 List[float]
, optional, 默认为 IMAGENET_STANDARD_STD
) — 如果对图像进行标准化,则使用的标准差。这是一个浮点数或与图像通道数相同长度的浮点数列表。可以被 preprocess
方法中的 image_std
参数覆盖。
return_image_mask
(bool
, optional, 默认为 False
) — 是否返回图像掩码。可以被 preprocess
中的 return_image_mask
参数覆盖。
input_size_patches
(int
, optional, 默认为 14) — 图像中高度和宽度方向的补丁数。14x14 = 总共 196 个补丁。可以被 preprocess
中的 input_size_patches
参数覆盖。
total_mask_patches
(int
, optional, 默认为 75) — 应该被遮蔽的总补丁数。可以被 preprocess
中的 total_mask_patches
参数覆盖。
mask_group_min_patches
(int
, optional, 默认为 16) — 应该被遮蔽的最小补丁数。可以被 preprocess
中的 mask_group_min_patches
参数覆盖。
mask_group_max_patches
(int
, optional) — 应该被遮蔽的最大补丁数。可以被 preprocess
中的 mask_group_max_patches
参数覆盖。
mask_group_min_aspect_ratio
(float
, optional, 默认为 0.3) — 掩码窗口的最小长宽比。可以被 preprocess
中的 mask_group_min_aspect_ratio
参数覆盖。
mask_group_max_aspect_ratio
(float
, optional) — 掩码窗口的最大长宽比。可以被 preprocess
中的 mask_group_max_aspect_ratio
参数覆盖。
codebook_do_resize
(bool
, optional, 默认为 True
) — 是否将输入调整大小以适应码书。可以被 preprocess
中的 codebook_size
参数覆盖。
codebook_size
(Dict[str, int]
, optional, 默认为 {"height" -- 224, "width": 224}
): 将输入调整大小以适应码书到指定大小。可以被 preprocess
中的 codebook_size
参数覆盖。
codebook_resample
(PILImageResampling
, optional, 默认为 PILImageResampling.LANCZOS
) — 如果调整码书图像大小,则使用的重采样滤波器。可以被 preprocess
中的 codebook_resample
参数覆盖。
codebook_do_center_crop
(bool
, optional, 默认为 True
) — 是否在码书输入中心裁剪输入。如果输入尺寸沿任何边缘小于 codebook_crop_size
,则图像将填充为 0,然后进行中心裁剪。可以被 preprocess
中的 codebook_do_center_crop
参数覆盖。
codebook_crop_size
(Dict[str, int]
, optional, 默认为 {"height" -- 224, "width": 224}
): 应用中心裁剪时,码书输入的期望输出大小。可以被 preprocess
中的 codebook_crop_size
参数覆盖。
codebook_do_rescale
(bool
, optional, 默认为 True
) — 是否按照指定的比例因子 codebook_rescale_factor
重新缩放码书输入。可以被 preprocess
中的 codebook_do_rescale
参数覆盖。
codebook_rescale_factor
(int
或 float
, optional, 默认为 1/255
) — 如果重新缩放码书图像,则定义要使用的比例因子。可以被 preprocess
中的 codebook_rescale_factor
参数覆盖。
codebook_do_map_pixels
(bool
, optional, 默认为 True
) — 是否将码书输入的像素值映射到 (1 - 2e)x + e。可以被 preprocess
中的 codebook_do_map_pixels
参数覆盖。
codebook_do_normalize
(bool
, optional, 默认为 True
) — 是否对用于 codebook 的输入进行规范化,使用 codebook_image_mean
和 codebook_image_std
。可以被 preprocess
中的 codebook_do_normalize
参数覆盖。
codebook_image_mean
(Optional[Union[float, Iterable[float]]]
, optional, 默认为 [0, 0, 0]
) — 每个通道的均值序列,在为 codebook 规范化图像时使用。可以被 preprocess
中的 codebook_image_mean
参数覆盖。
codebook_image_std
(Optional[Union[float, Iterable[float]]]
, optional, 默认为 [0.5, 0.5, 0.5]
) — 每个通道的标准差序列,在为 codebook 规范化图像时使用。可以被 preprocess
中的 codebook_image_std
参数覆盖。
构建一个 Flava 图像处理器。
preprocess
( images: Union do_resize: Optional = None size: Dict = None resample: Resampling = None do_center_crop: Optional = None crop_size: Optional = None do_rescale: Optional = None rescale_factor: Optional = None do_normalize: Optional = None image_mean: Union = None image_std: Union = None return_image_mask: Optional = None input_size_patches: Optional = None total_mask_patches: Optional = None mask_group_min_patches: Optional = None mask_group_max_patches: Optional = None mask_group_min_aspect_ratio: Optional = None mask_group_max_aspect_ratio: Optional = None return_codebook_pixels: Optional = None codebook_do_resize: Optional = None codebook_size: Optional = None codebook_resample: Optional = None codebook_do_center_crop: Optional = None codebook_crop_size: Optional = None codebook_do_rescale: Optional = None codebook_rescale_factor: Optional = None codebook_do_map_pixels: Optional = None codebook_do_normalize: Optional = None codebook_image_mean: Optional = None codebook_image_std: Optional = None return_tensors: Union = None data_format: ChannelDimension = <ChannelDimension.FIRST: 'channels_first'> input_data_format: Union = None **kwargs )
参数
images
(ImageInput
) — 要预处理的图像。期望单个图像或批量图像,像素值范围为 0 到 255。如果传入像素值在 0 到 1 之间的图像,请设置 do_rescale=False
。
do_resize
(bool
, optional, 默认为 self.do_resize
) — 是否调整图像大小。
size
(Dict[str, int]
, optional, 默认为 self.size
) — 图像的大小。
resample
(int
, optional, 默认为 self.resample
) — 如果调整图像大小,则使用的重采样滤波器。这可以是 PILImageResampling
枚举值之一,仅在 do_resize
设置为 True
时有效。
do_center_crop
(bool
, optional, 默认为 self.do_center_crop
) — 是否对图像进行中心裁剪。
crop_size
(Dict[str, int]
, optional, 默认为 self.crop_size
) — 中心裁剪的大小。仅在 do_center_crop
设置为 True
时有效。
do_rescale
(bool
, optional, 默认为 self.do_rescale
) — 是否将图像值重新缩放在 [0 - 1] 之间。
rescale_factor
(float
, optional, 默认为 self.rescale_factor
) — 如果 do_rescale
设置为 True
,则用于重新缩放图像的重新缩放因子。
do_normalize
(bool
, optional, 默认为 self.do_normalize
) — 是否对图像进行规范化。
image_mean
(float
或 List[float]
, optional, 默认为 self.image_mean
) — 图像均值。
image_std
(float
或 List[float]
, optional, 默认为 self.image_std
) — 图像标准差。
return_image_mask
(bool
, optional, 默认为 self.return_image_mask
) — 是否返回图像掩码。
input_size_patches
(int
, optional, 默认为 self.input_size_patches
) — 从图像中提取的补丁的大小。
total_mask_patches
(int
, optional, 默认为 self.total_mask_patches
) — 从图像中提取的总补丁数。
mask_group_min_patches
(int
, optional, 默认为 self.mask_group_min_patches
) — 从图像中提取的最小补丁数。
mask_group_max_patches
(int
, optional, 默认为 self.mask_group_max_patches
) — 从图像中提取的补丁的最大数量。
mask_group_min_aspect_ratio
(float
, optional, 默认为 self.mask_group_min_aspect_ratio
) — 从图像中提取的补丁的最小长宽比。
mask_group_max_aspect_ratio
(float
, optional, 默认为 self.mask_group_max_aspect_ratio
) — 从图像中提取的补丁的最大长宽比。
return_codebook_pixels
(bool
, optional, 默认为 self.return_codebook_pixels
) — 是否返回 codebook 像素。
codebook_do_resize
(bool
, optional, 默认为 self.codebook_do_resize
) — 是否调整 codebook 像素的大小。
codebook_size
(Dict[str, int]
, optional, 默认为 self.codebook_size
) — codebook 像素的大小。
codebook_resample
(int
, 可选, 默认为 self.codebook_resample
) — 如果调整码书像素大小,则要使用的重采样滤波器。这可以是枚举 PILImageResampling
中的一个。仅在 codebook_do_resize
设置为 True
时有效。
codebook_do_center_crop
(bool
, 可选, 默认为 self.codebook_do_center_crop
) — 是否对码书像素进行中心裁剪。
codebook_crop_size
(Dict[str, int]
, 可选, 默认为 self.codebook_crop_size
) — 码书像素中心裁剪的大小。仅在 codebook_do_center_crop
设置为 True
时有效。
codebook_do_rescale
(bool
, 可选, 默认为 self.codebook_do_rescale
) — 是否将码书像素值重新缩放到 [0 - 1] 之间。
codebook_rescale_factor
(float
, 可选, 默认为 self.codebook_rescale_factor
) — 如果 codebook_do_rescale
设置为 True
,则用于重新缩放码书像素的重新缩放因子。
codebook_do_map_pixels
(bool
, 可选, 默认为 self.codebook_do_map_pixels
) — 是否映射码书像素值。
codebook_do_normalize
(bool
, 可选, 默认为 self.codebook_do_normalize
) — 是否对码书像素进行归一化。
codebook_image_mean
(float
或 List[float]
, 可选, 默认为 self.codebook_image_mean
) — 如果 codebook_do_normalize
设置为 True
,则用于归一化码书像素的码书像素均值。
codebook_image_std
(float
或 List[float]
, 可选, 默认为 self.codebook_image_std
) — 如果 codebook_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
) — 输出图像的通道维度格式。可以是以下之一:
ChannelDimension.FIRST
: 图像以 (通道数、高度、宽度) 格式。
ChannelDimension.LAST
: 图像以 (高度、宽度、通道数) 格式。
input_data_format
(ChannelDimension
或 str
, 可选) — 输入图像的通道维度格式。如果未设置,则从输入图像中推断通道维度格式。可以是以下之一:
"channels_first"
或 ChannelDimension.FIRST
: 图像以 (通道数、高度、宽度) 格式。
"channels_last"
或 ChannelDimension.LAST
: 图像以 (高度、宽度、通道数) 格式。
"none"
或 ChannelDimension.NONE
: 图像以 (高度、宽度) 格式。
预处理图像或图像批次。
class transformers.FlavaForPreTraining
( config: FlavaConfig image_codebook: Optional = None )
参数
config
(FlavaConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只会加载配置。查看 from_pretrained() 方法以加载模型权重。
image_codebook
(nn.Module
) — 如果传入,图像码书将设置为此值。否则,将使用配置中定义的 image_codebook_config 作为第一个参数进行初始化。
用于预训练的 FLAVA 模型,输出损失、嵌入、对数和变换器输出。
这个模型是 PyTorch 的torch.nn.Module子类。将其用作常规的 PyTorch 模块,并参考 PyTorch 文档以获取与一般用法和行为相关的所有事项。
forward
( input_ids: Optional = None input_ids_masked: Optional = None pixel_values: Optional = None codebook_pixel_values: Optional = None attention_mask: Optional = None token_type_ids: Optional = None bool_masked_pos: Optional = None position_ids: Optional = None image_attention_mask: Optional = None skip_unmasked_multimodal_encoder: bool = None mlm_labels: Optional = None mim_labels: Optional = None itm_labels: Optional = None output_attentions: Optional = None output_hidden_states: bool = True return_dict: Optional = None return_loss: Optional = None ) → export const metadata = 'undefined';transformers.models.flava.modeling_flava.FlavaForPreTrainingOutput or tuple(torch.FloatTensor)
参数
input_ids_masked
(形状为(batch_size, text_seq_len)
的torch.LongTensor
)— 词汇表中输入序列标记的索引。这些是原始任务的掩盖版本,用于 MLM。索引可以使用 AutoTokenizer 以及DataCollatorForMaskedLanguageModeling
获取。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call
()。什么是输入 ID?
input_ids
(形状为(batch_size, text_seq_len)
的torch.LongTensor
)— 词汇表中输入序列标记的索引。索引可以使用 AutoTokenizer 获取。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call
()。什么是输入 ID?
token_type_ids
(形状为(batch_size, text_seq_len)
的torch.LongTensor
,可选)— 段标记索引,用于指示输入的第一部分和第二部分。索引在[0, 1]
中选择:
pixel_values
(形状为(batch_size, num_channels, height, width)
的torch.FloatTensor
)— 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息,请参阅 FlavaImageProcessor.call
()。
bool_masked_pos
(形状为(batch_size, image_num_patches)
的torch.BoolTensor
)— 布尔掩码位置。指示哪些补丁被掩盖(1),哪些没有(0)。
interpolate_pos_encoding
(布尔值,可选)— 是否插值预训练位置编码。
image_attention_mask
(形状为(batch_size, image_num_patches)
的torch.FloatTensor
,可选)— 用于避免特定于图像的填充令牌索引执行注意力的掩码。掩码值在[0, 1]
中选择:
未被掩盖
的标记,
掩盖
的标记。什么是注意力掩码?
skip_unmasked_multimodal_encoder
(布尔值,可选)— 跳过未掩盖输入的多模态编码器的任何计算。FLAVA 预训练目前不需要未掩盖的多模态嵌入或输出。
mlm_labels
(形状为(batch_size, text_seq_len)
的torch.LongTensor
,可选)— 用于计算从左到右的语言和多模态掩码建模损失(下一个词预测)的标签。索引应在[-100, 0, ..., text_config.vocab_size - 1]
中(参见input_ids
文档字符串)。索引设置为-100
的标记将被忽略(掩盖),损失仅计算具有标签在[0, ..., text_config.vocab_size - 1]
中的标记。
mim_labels
(形状为(batch_size, image_num_patches)
的torch.LongTensor
,可选)- 用于计算图像和多模态掩码建模损失的标签。索引应在[-100, 0, ..., image_config.vocab_size - 1]
中。将索引设置为-100
的标记将被忽略(masked),仅对具有标签在[0, ..., image_config.vocab_size - 1]
中的标记计算损失。如果未传递,则它们将使用分配给模型的图像码书自动生成。默认情况下,它使用 FlavaImageCodebook。请参阅 FlavaImageCodebook 以了解如何生成 mim_labels。
itm_labels
(形状为(batch_size, 1)
的torch.LongTensor
,可选)- 用于计算图像文本匹配损失的标签。0 表示配对不匹配,1 表示匹配。标签为 0 的配对也将被跳过用于计算 MMM 和全局对比损失。
return_loss
(bool
,可选,默认为 None)- 是否返回计算的损失。
attention_mask
(形状为(batch_size, text_seq_len)
的torch.FloatTensor
,可选)- 用于避免在填充标记索引上执行注意力的掩码。掩码值选定在[0, 1]
中:
masked
的标记,
masked
的标记。什么是注意力掩码?
head_mask
(形状为(num_heads,)
或(num_layers, num_heads)
的torch.FloatTensor
,可选)- 用于使自注意力模块的选定头部失效的掩码。掩码值选定在[0, 1]
中:
masked
,
masked
。
output_attentions
(bool
,可选)- 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions
。
output_hidden_states
(bool
,可选)- 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
。
return_dict
(bool
,可选)- 是否返回 ModelOutput 而不是普通元组。
示例 -
返回
transformers.models.flava.modeling_flava.FlavaForPreTrainingOutput
或tuple(torch.FloatTensor)
一个transformers.models.flava.modeling_flava.FlavaForPreTrainingOutput
或一个torch.FloatTensor
元组(如果传递了return_dict=False
或当config.return_dict=False
时)包括根据配置(<class 'transformers.models.flava.configuration_flava.FlavaConfig'>
)和输入的不同元素。
loss
(torch.FloatTensor
,可选,当return_loss
为 True 时返回)- 为此模型计算的总损失。
loss_info
(FlavaLosses
)- FLAVA 预训练损失的详细信息。检查FlavaLosses
类描述以获取关键信息。
image_embeddings
(形状为(batch_size, output_dim)
的torch.FloatTensor
,可选,当存在pixel_values
时返回)- 这些基本上是 FlavaImageModel 的汇总输出的图像嵌入。
image_output
(BaseModelOutputWithPooling
,可选,当存在pixel_values
时返回)- FlavaImageModel 的输出。
text_embeddings
(形状为(batch_size, output_dim)
的torch.FloatTensor
,可选,当存在input_ids
时返回)- 这些基本上是 FlavaTextModel 的汇总输出的文本嵌入。
text_output
(BaseModelOutputWithPooling
,可选,当存在input_ids
时返回)- FlavaTextModel 的输出。
multimodal_embeddings
(torch.FloatTensor
,形状为(batch_size, output_dim)
,可选,当input_ids
和pixel_values
存在且skip_unmasked_multimodal_encoder
为None
或False
时返回)- 这些多模态嵌入基本上是 FlavaTextModel 的汇总输出。
multimodal_output
(BaseModelOutputWithPooling
,当input_ids
和pixel_values
存在且skip_unmasked_multimodal_encoder
为None
或False
时返回)- FlavaMultimodalModel 的输出。
image_masked_embeddings
(torch.FloatTensor
,形状为(batch_size, output_dim)
,可选,当pixel_values
存在时返回)- 这些图像嵌入基本上是 FlavaImageModel 的汇总输出。使用bool_masked_pos
来创建被屏蔽的图像。
image_masked_output
(BaseModelOutputWithPooling
,可选,当pixel_values
存在时返回)- FlavaImageModel 的输出。使用bool_masked_pos
来创建被屏蔽的图像。
text_masked_embeddings
(torch.FloatTensor
,形状为(batch_size, output_dim)
,可选,当input_ids_masked
存在时返回)- 这些文本嵌入基本上是 FlavaTextModel 的汇总输出。
text_masked_output
(BaseModelOutputWithPooling
,可选,当input_ids_masked
存在时返回)- FlavaTextModel 的输出。
multimodal_masked_embeddings
(torch.FloatTensor
,形状为(batch_size, output_dim)
,可选,当input_ids
和pixel_values
存在时返回)- 这些多模态嵌入基本上是 FlavaTextModel 的汇总输出。
multimodal_masked_output
(BaseModelOutputWithPooling
,当input_ids_masked
和pixel_values
存在时返回)- FlavaMultimodalModel 的输出。
mim_logits
(torch.FloatTensor
,形状为(batch_size, num_image_patches, image_vocab_size)
或形状为(total_masked_patches, image_vocab_size)
,可选,当pixel_values
存在且input_ids_masked
不存在时返回)- MIM 单模态损失的 logits。使用book_masked_pos
来获取被屏蔽的补丁。当bool_masked_pos
中有一些补丁被屏蔽时,返回扁平化的输出。
mlm_logits
(torch.FloatTensor
,形状为(batch_size, text_seq_length, text_vocab_size)
或形状为(total_masked_seq_length, text_vocab_size)
,可选,当input_ids_masked
存在且pixel_values
不存在时返回)- MLM 单模态损失的 logits。当input_ids_masked
中有一些标记被屏蔽时,返回扁平化的输出。
itm_logits
(torch.FloatTensor
,形状为(batch_size, 2)
,可选,当input_ids_masked
和pixel_values
存在时返回)- ITM 损失的 logits。请注意,ITM 损失是在 FLAVA 中对被屏蔽的配对进行计算的。
mmm_image_logits
(torch.FloatTensor
,形状为(batch_size, num_image_patches, image_vocab_size)
或形状为(total_masked_patches, image_vocab_size)
,可选,当pixel_values
和input_ids_masked
存在时返回)- MMM 图像多模态损失的 logits。使用book_masked_pos
来获取被屏蔽的补丁。当bool_masked_pos
中有一些补丁被屏蔽时,返回扁平化的输出。
mmm_text_logits
(形状为(batch_size, text_seq_length, text_vocab_size)
或形状为(total_masked_seq_length, text_vocab_size)
的torch.FloatTensor
,可选,当pixel_values
和input_ids_masked
存在时返回)- 用于 MMM 文本多模态损失的 logits。当input_ids_masked
中有一些标记被屏蔽时,返回扁平化的输出。
contrastive_logits_per_image
(形状为(image_batch_size, text_batch_size)
的torch.FloatTensor
)- image_embeddings
和text_embeddings
之间的缩放点积分数,但分别通过 FLAVA 的image_projection
和text_projection
层。这代表了图像文本相似性得分。这是在未屏蔽的图像和文本上计算的。
contrastive_logits_per_text
(形状为(text_batch_size, image_batch_size)
的torch.FloatTensor
)- text_embeddings
和image_embeddings
之间的缩放点积分数,但分别通过 FLAVA 的text_projection
和image_projection
层。这是在未屏蔽的图像和文本上计算的。
FlavaForPreTraining 的前向方法,覆盖了__call__
特殊方法。
虽然前向传递的配方需要在此函数内定义,但应该在此之后调用Module
实例,而不是在此处调用,因为前者会负责运行前处理和后处理步骤,而后者会默默地忽略它们。
class transformers.FlavaModel
( config: FlavaConfig )
参数
config
(FlavaConfig)- 模型配置类,包含模型的所有参数。使用配置文件初始化不会加载与模型相关的权重,只会加载配置。查看 from_pretrained()方法以加载模型权重。裸的 FLAVA 模型变压器输出原始隐藏状态,没有特定的头部。这个模型是 PyTorch 的torch.nn.Module子类。将其用作常规的 PyTorch 模块,并参考 PyTorch 文档以获取与一般用法和行为相关的所有事项。
forward
( input_ids: Optional = None pixel_values: Optional = None attention_mask: Optional = None token_type_ids: Optional = None bool_masked_pos: Optional = None position_ids: Optional = None image_attention_mask: Optional = None skip_multimodal_encoder: Optional = None output_attentions: Optional = None output_hidden_states: bool = True return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.flava.modeling_flava.FlavaModelOutput or tuple(torch.FloatTensor)
参数
pixel_values
(形状为(batch_size, num_channels, height, width)
的torch.FloatTensor
)- 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息,请参阅 FlavaImageProcessor.call
()。
bool_masked_pos
(形状为(batch_size, image_num_patches)
的torch.BoolTensor
)- 布尔掩码位置。指示哪些补丁被屏蔽(1),哪些没有(0)。
interpolate_pos_encoding
(bool
,可选)- 是否插值预训练位置编码。
input_ids
(形状为(batch_size, image_num_patches + text_seq_len)
的torch.LongTensor
)- 词汇表中输入序列标记的索引。索引可以使用 AutoTokenizer 获取。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call
()。什么是输入 ID?
token_type_ids
(torch.LongTensor
,形状为 (batch_size, image_num_patches + text_seq_len)
,可选) — 段令牌索引,指示输入的第一部分和第二部分。 索引在 [0, 1]
中选择:
attention_mask
(torch.FloatTensor
,形状为 (batch_size, image_num_patches + text_seq_len)
,可选) — 用于避免在填充令牌索引上执行注意力的掩码。 选择的掩码值为 [0, 1]
:
head_mask
(torch.FloatTensor
,形状为 (num_heads,)
或 (num_layers, num_heads)
,可选) — 用于使自注意力模块的选定头部无效的掩码。 选择的掩码值在 [0, 1]
中:
output_attentions
(bool
,可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回张量下的 attentions
。
output_hidden_states
(bool
,可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量下的 hidden_states
。
return_dict
(bool
,可选) — 是否返回 ModelOutput 而不是普通元组。
skip_multimodal_encoder
(bool,可选) — 跳过多模态编码的任何计算。 如果不打算使用多模态编码,则此选项很有用。
返回
transformers.models.flava.modeling_flava.FlavaModelOutput
或 tuple(torch.FloatTensor)
一个 transformers.models.flava.modeling_flava.FlavaModelOutput
或一个 torch.FloatTensor
元组(如果传递了 return_dict=False
或当 config.return_dict=False
时),包括根据配置 (<class 'transformers.models.flava.configuration_flava.FlavaConfig'>
) 和输入而异的各种元素。
image_embeddings
(torch.FloatTensor
,形状为 (batch_size, output_dim)
,可选,当 pixel_values
存在时返回) — 基本上是 FlavaImageModel 的汇总输出的图像嵌入。
image_output
(BaseModelOutputWithPooling
,可选,当 pixel_values
存在时返回) — FlavaImageModel 的输出。
text_embeddings
(torch.FloatTensor
,形状为 (batch_size, output_dim)
,可选,当 input_ids
存在时返回) — 基本上是 FlavaTextModel 的汇总输出的文本嵌入。
text_output
(BaseModelOutputWithPooling
,可选,当 input_ids
存在时返回) — FlavaTextModel 的输出。
multimodal_embeddings
(torch.FloatTensor
,形状为 (batch_size, output_dim)
,可选,当 input_ids
和 pixel_values
存在且 skip_multimodal_encoder
为 None
或 False
时返回) — 基本上是 FlavaTextModel 的汇总输出的多模态嵌入。
multimodal_output
(BaseModelOutputWithPooling
,当 input_ids
和 pixel_values
存在且 skip_multimodal_encoder
为 None
或 False
时返回) — FlavaMultimodalModel 的输出。
FlavaModel 的前向方法,覆盖了 __call__
特殊方法。
尽管前向传递的配方需要在此函数内定义,但应该在此之后调用Module
实例,而不是在此处调用,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, FlavaModel
>>> model = FlavaModel.from_pretrained("facebook/flava-full")
>>> processor = AutoProcessor.from_pretrained("facebook/flava-full")
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> inputs = processor(text=["a photo of a cat"], images=image, return_tensors="pt", padding=True)
>>> outputs = model(**inputs)
>>> image_embeddings = outputs.image_embeddings
>>> text_embeddings = outputs.text_embeddings
>>> multimodal_embeddings = outputs.multimodal_embeddings
>>> outputs.image_embeddings.shape
torch.Size([1, 197, 768])
>>> text_embeddings.shape
torch.Size([1, 7, 768])
>>> multimodal_embeddings.shape
torch.Size([1, 205, 768])
get_text_features
( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None )
参数
input_ids
(形状为(batch_size, text_seq_length)
的torch.LongTensor
)— 输入序列标记在词汇表中的索引。可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call
()。什么是输入 ID?
token_type_ids
(形状为(batch_size, text_seq_length)
的torch.LongTensor
,可选)— 段标记索引,指示输入的第一部分和第二部分。索引选择在[0, 1]
中:
attention_mask
(形状为(batch_size, text_seq_length)
的torch.FloatTensor
,可选)— 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]
之间:
masked
掉的标记,值为 0。什么是注意力掩码?
head_mask
(形状为(num_heads,)
或(num_layers, num_heads)
的torch.FloatTensor
,可选)— 用于使自注意力模块的选定头部失效的掩码。掩码值选择在[0, 1]
中:
masked
。
output_attentions
(bool
,可选)— 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回的张量下的attentions
。
output_hidden_states
(bool
,可选)— 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回的张量下的hidden_states
。
return_dict
(bool
,可选)— 是否返回 ModelOutput 而不是普通元组。
FlavaModel 的前向方法,覆盖了__call__
特殊方法。
尽管前向传递的配方需要在此函数内定义,但应该在此之后调用Module
实例,而不是在此处调用,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
get_image_features
( pixel_values: Optional = None bool_masked_pos: Optional = None interpolate_pos_encoding: Optional = None attention_mask: Optional = None head_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None )
参数
pixel_values
(形状为(batch_size, num_channels, height, width)
的torch.FloatTensor
)— 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息,请参阅 FlavaImageProcessor.call
()。
bool_masked_pos
(形状为(batch_size, image_num_patches)
的torch.BoolTensor
)— 布尔掩码位置。指示哪些补丁被掩盖(1),哪些没有(0)。
interpolate_pos_encoding
(bool
,可选)— 是否插值预训练位置编码。
attention_mask
(形状为(batch_size, image_num_patches)
的torch.FloatTensor
,可选)— 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]
之间:
masked
掉的标记,值为 0。什么是注意力掩码?
head_mask
(torch.FloatTensor
of shape (num_heads,)
or (num_layers, num_heads)
, optional) — 用于使自注意力模块中选择的头部失效的掩码。掩码值选在[0, 1]
之间:
未被掩盖
,
被掩盖
。
output_attentions
(bool
, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions
。
output_hidden_states
(bool
, optional) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
。
return_dict
(bool
, optional) — 是否返回 ModelOutput 而不是普通元组。
FlavaModel 的前向方法,覆盖了__call__
特殊方法。
尽管前向传递的步骤需要在此函数内定义,但应该在此之后调用Module
实例,而不是在此处调用,因为前者会负责运行预处理和后处理步骤,而后者会默默地忽略它们。
class transformers.FlavaImageCodebook
( config: FlavaImageCodebookConfig **kwargs: Any )
参数
config
(FlavaImageCodebookConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只会加载配置。查看 from_pretrained()方法以加载模型权重。FLAVA 的图像代码簿模型受到 DALL-E 原始编码器的启发。输出原始隐藏状态,可用于根据 DALL-E 的词汇为基于图像的 MIM 生成图像标记。用于为 MIM 生成图像的图像标记,请使用get_codebook_indices
。
此模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取与一般用法和行为相关的所有事项。
forward
( pixel_values: FloatTensor )
get_codebook_indices
( pixel_values: Tensor )
get_codebook_probs
( pixel_values: Tensor )
class transformers.FlavaTextModel
( config: FlavaTextConfig add_pooling_layer: bool = True )
参数
config
(FlavaTextConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只会加载配置。查看 from_pretrained()方法以加载模型权重。裸的 FLAVA 文本模型变压器输出原始隐藏状态,没有特定的头部。此模型是 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 output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutputWithPooling or tuple(torch.FloatTensor)
参数
input_ids
(torch.LongTensor
of shape (batch_size, text_seq_length)
) — Indices of input sequence tokens in the vocabulary. Indices can be obtained using AutoTokenizer. See PreTrainedTokenizer.encode() and PreTrainedTokenizer.call
() for details. What are input IDs?
token_type_ids
(torch.LongTensor
of shape (batch_size, text_seq_length)
, optional) — 段标记索引,用于指示输入的第一部分和第二部分。索引选定在[0, 1]
之间:
attention_mask
(torch.FloatTensor
of shape (batch_size, text_seq_length)
, optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选定在[0, 1]
之间:
head_mask
(torch.FloatTensor
of shape (num_heads,)
or (num_layers, num_heads)
, optional) — 用于使自注意力模块中的选定头部失效的掩码。掩码值选定在[0, 1]
之间:
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
时),包括根据配置(FlavaTextConfig)和输入的不同元素。
last_hidden_state
(torch.FloatTensor
of shape (batch_size, sequence_length, hidden_size)
) — 模型最后一层的隐藏状态的序列。
pooler_output
(torch.FloatTensor
of shape (batch_size, hidden_size)
) — Last layer hidden-state of the first token of the sequence (classification token) after further processing through the layers used for the auxiliary pretraining task. E.g. for BERT-family of models, this returns the classification token after processing through a linear layer and a tanh activation function. The linear layer weights are trained from the next sentence prediction (classification) objective during pretraining.
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)
,可选,当传递output_attentions=True
或当config.output_attentions=True
时返回)— 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。
在注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。
FlavaTextModel 的前向方法,覆盖了__call__
特殊方法。
尽管前向传递的步骤需要在此函数内定义,但应该在此之后调用Module
实例,而不是在此处调用,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
>>> from transformers import AutoTokenizer, FlavaTextModel
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/flava-full")
>>> model = FlavaTextModel.from_pretrained("facebook/flava-full")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_state
class transformers.FlavaImageModel
( config: FlavaImageConfig add_pooling_layer: bool = True )
参数
config
(FlavaImageConfig)— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。裸的 FLAVA 图像模型变换器输出没有特定头部的原始隐藏状态。此模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。
forward
( pixel_values: Optional = None bool_masked_pos: Optional = None interpolate_pos_encoding: 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)
参数
pixel_values
(形状为(batch_size, num_channels, height, width)
的torch.FloatTensor
)— 像素值。像素值可以使用 AutoImageProcessor 获取。有关详细信息,请参阅 FlavaImageProcessor.call
()。
bool_masked_pos
(形状为(batch_size, image_num_patches)
的torch.BoolTensor
)— 布尔掩码位置。指示哪些补丁被掩盖(1),哪些没有(0)。
interpolate_pos_encoding
(bool
,可选)— 是否插值预训练位置编码。
attention_mask
(torch.FloatTensor
,形状为(batch_size, image_num_patches)
,可选)— 用于避免在填充令牌索引上执行注意力的掩码。掩码值选定在[0, 1]
之间:
masked
的令牌,
masked
的令牌。什么是注意力掩码?
head_mask
(torch.FloatTensor
,形状为(num_heads,)
或(num_layers, num_heads)
,可选)— 用于使自注意力模块中的选定头部失效的掩码。掩码值选定在[0, 1]
之间:
masked
。
masked
。
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
)包含各种元素,具体取决于配置(FlavaImageConfig)和输入。
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 之后的注意力权重,用于计算自注意力头中的加权平均值。
FlavaImageModel 的前向方法,覆盖了__call__
特殊方法。
尽管前向传递的配方需要在此函数内定义,但应该在此之后调用Module
实例,而不是这个,因为前者负责运行预处理和后处理步骤,而后者则默默地忽略它们。
示例:
>>> from transformers import AutoImageProcessor, FlavaImageModel
>>> import torch
>>> from datasets import load_dataset
>>> dataset = load_dataset("huggingface/cats-image")
>>> image = dataset["test"]["image"][0]
>>> image_processor = AutoImageProcessor.from_pretrained("facebook/flava-full")
>>> model = FlavaImageModel.from_pretrained("facebook/flava-full")
>>> inputs = image_processor(image, return_tensors="pt")
>>> with torch.no_grad():
... outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 197, 768]
class transformers.FlavaMultimodalModel
( config: FlavaMultimodalConfig add_pooling_layer = True )
参数
config
(FlavaMultimodalConfig)— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。裸的 FLAVA 多模型变压器输出原始隐藏状态,没有特定的头部。此模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取与一般用法和行为相关的所有信息。
forward
( hidden_states: Tensor 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)
参数
hidden_states
(形状为(batch_size, image_num_patches + text_seq_len, hidden_size)
的torch.FloatTensor
)— 单模编码器的连接隐藏状态。
attention_mask
(形状为(batch_size, image_num_patches + text_seq_len)
的torch.FloatTensor
,可选)— 用于避免在填充标记索引上执行注意力的掩码。掩码值选在[0, 1]
之间:
未被掩码
的标记,
masked
的标记为 0。什么是注意力掩码?
head_mask
(形状为(num_heads,)
或(num_layers, num_heads)
的torch.FloatTensor
,可选) — 用于使自注意力模块中选择的头部失效的掩码。在[0, 1]
中选择的掩码值:
masked
,
masked
。
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
时)包含根据配置(FlavaMultimodalConfig)和输入而异的各种元素。
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 后的注意力权重,用于计算自注意力头中的加权平均值。
FlavaMultimodalModel 的前向方法,覆盖了__call__
特殊方法。
尽管前向传递的配方需要在此函数内定义,但应该在此之后调用Module
实例,而不是这个,因为前者负责运行预处理和后处理步骤,而后者则默默地忽略它们。
示例:
>>> from transformers import AutoTokenizer, FlavaMultimodalModel
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/flava-full")
>>> model = FlavaMultimodalModel.from_pretrained("facebook/flava-full")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_state
原始文本:
huggingface.co/docs/transformers/v4.37.2/en/model_doc/git
GIT 模型是由 Jianfeng Wang、Zhengyuan Yang、Xiaowei Hu、Linjie Li、Kevin Lin、Zhe Gan、Zicheng Liu、Ce Liu、Lijuan Wang 在《GIT: A Generative Image-to-text Transformer for Vision and Language》中提出的。GIT 是一种仅解码的 Transformer,利用 CLIP 的视觉编码器来除了文本外还对模型进行视觉输入的条件。该模型在图像字幕和视觉问答基准上取得了最先进的结果。
论文摘要如下:
在本文中,我们设计并训练了一个生成式图像文本 Transformer,GIT,以统一图像/视频字幕和问题回答等视觉-语言任务。虽然生成模型在预训练和微调之间提供了一致的网络架构,但现有工作通常包含复杂的结构(单/多模态编码器/解码器)并依赖于外部模块,如目标检测器/标记器和光学字符识别(OCR)。在 GIT 中,我们简化了架构,将其作为一个图像编码器和一个文本解码器在单一语言建模任务下。我们还扩大了预训练数据和模型规模以提高模型性能。没有花哨的东西,我们的 GIT 在 12 个具有挑战性的基准上建立了新的最先进技术,差距很大。例如,我们的模型首次在 TextCaps 上超越了人类表现(CIDEr 中的 138.2 vs. 125.5)。此外,我们提出了一种新的基于生成的图像分类和场景文本识别方案,在标准基准上取得了不错的表现。
GIT 架构。摘自原始论文。
pixel_values
的影响。官方 Hugging Face 和社区(由🌎表示)资源列表,可帮助您开始使用 GIT。
如果您有兴趣提交资源以包含在此处,请随时提交拉取请求,我们将进行审查。资源应该理想地展示一些新内容,而不是重复现有资源。
class transformers.GitVisionConfig
( hidden_size = 768 intermediate_size = 3072 num_hidden_layers = 12 num_attention_heads = 12 num_channels = 3 image_size = 224 patch_size = 16 hidden_act = 'quick_gelu' layer_norm_eps = 1e-05 attention_dropout = 0.0 initializer_range = 0.02 **kwargs )
参数
hidden_size
(int
,可选,默认为 768)— 编码器层和池化器层的维度。
intermediate_size
(int
,可选,默认为 3072)— Transformer 编码器中“中间”(即前馈)层的维度。
num_hidden_layers
(int
,可选,默认为 12)— Transformer 编码器中的隐藏层数。
num_attention_heads
(int
,可选,默认为 12)— Transformer 编码器中每个注意力层的注意力头数。
image_size
(int
,可选,默认为 224)— 每个图像的大小(分辨率)。
patch_size
(int
,可选,默认为 16)— 每个补丁的大小(分辨率)。
hidden_act
(str
或function
,可选,默认为"quick_gelu"
)— 编码器和池化器中的非线性激活函数(函数或字符串)。如果是字符串,支持"gelu"
、"relu"
、"selu"
和"gelu_new"
以及"quick_gelu"
。
layer_norm_eps
(float
,可选,默认为 1e-5) — 层归一化层使用的 epsilon。
attention_dropout
(float
,可选,默认为 0.0) — 注意力概率的丢弃比率。
initializer_range
(float
,可选,默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
这是用于存储 GitVisionModel 配置的配置类。根据指定的参数实例化 GIT 视觉编码器,定义模型架构。使用默认值实例化配置将产生类似于 GIT microsoft/git-base架构的视觉编码器的配置。
配置对象继承自 PretrainedConfig,可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。
示例:
>>> from transformers import GitVisionConfig, GitVisionModel
>>> # Initializing a GitVisionConfig with microsoft/git-base style configuration
>>> configuration = GitVisionConfig()
>>> # Initializing a GitVisionModel (with random weights) from the microsoft/git-base style configuration
>>> model = GitVisionModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
class transformers.GitVisionModel
( config: GitVisionConfig )
参数
config
(GitConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。CLIP 中使用的视觉模型,在 GIT 中没有顶部的头部或投影。
此模型继承自 PreTrainedModel。检查超类文档以获取库为所有模型实现的通用方法(例如下载或保存、调整输入嵌入、修剪头等)。
此模型还是一个 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。
forward
( pixel_values: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutput or tuple(torch.FloatTensor)
参数
pixel_values
(torch.FloatTensor
,形状为(batch_size, num_channels, height, width)
) — 像素值。默认情况下会忽略填充。可以使用 AutoImageProcessor 获取像素值。有关详细信息,请参阅 CLIPImageProcessor.call
()。
output_attentions
(bool
,可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions
。
output_hidden_states
(bool
,可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
。
return_dict
(bool
,可选) — 是否返回 ModelOutput 而不是普通元组。
返回
transformers.modeling_outputs.BaseModelOutput 或tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.BaseModelOutput 或一个 torch.FloatTensor
元组(如果传递了 return_dict=False
或当 config.return_dict=False
时)包含根据配置(<class 'transformers.models.git.configuration_git.GitVisionConfig'>
)和输入的不同元素。
last_hidden_state
(torch.FloatTensor
,形状为 (batch_size, sequence_length, hidden_size)
) — 模型最后一层的隐藏状态序列。
hidden_states
(tuple(torch.FloatTensor)
,可选,当传递 output_hidden_states=True
或当 config.output_hidden_states=True
时返回) — 形状为 (batch_size, sequence_length, hidden_size)
的 torch.FloatTensor
元组(一个用于嵌入层的输出,如果模型有嵌入层,+ 一个用于每一层的输出)。
模型在每一层输出的隐藏状态以及可选的初始嵌入输出。
attentions
(tuple(torch.FloatTensor)
,可选,当传递 output_attentions=True
或当 config.output_attentions=True
时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length)
的 torch.FloatTensor
元组(每层一个)。
注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
GitVisionModel 的前向方法,覆盖了 __call__
特殊方法。
虽然前向传递的方法需要在此函数内定义,但应该在此之后调用 Module
实例,而不是在此处调用,因为前者会负责运行前处理和后处理步骤,而后者会默默地忽略它们。
示例:
>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, GitVisionModel
>>> processor = AutoProcessor.from_pretrained("microsoft/git-base")
>>> model = GitVisionModel.from_pretrained("microsoft/git-base")
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> inputs = processor(images=image, return_tensors="pt")
>>> outputs = model(**inputs)
>>> last_hidden_state = outputs.last_hidden_state
class transformers.GitConfig
( vision_config = None vocab_size = 30522 hidden_size = 768 num_hidden_layers = 6 num_attention_heads = 12 intermediate_size = 3072 hidden_act = 'gelu' hidden_dropout_prob = 0.1 attention_probs_dropout_prob = 0.1 max_position_embeddings = 1024 initializer_range = 0.02 layer_norm_eps = 1e-12 pad_token_id = 0 position_embedding_type = 'absolute' use_cache = True tie_word_embeddings = False bos_token_id = 101 eos_token_id = 102 num_image_with_embedding = None **kwargs )
参数
vision_config
(dict
,可选) — 用于初始化 GitVisionConfig 的配置选项字典。
vocab_size
(int
,可选,默认为 30522) — GIT 模型的词汇量大小。定义了在调用 GitModel 时可以由 inputs_ids
表示的不同标记数量。
hidden_size
(int
,可选,默认为 768) — 编码器层和池化器层的维度。
num_hidden_layers
(int
,可选,默认为 6) — Transformer 编码器中的隐藏层数量。
num_attention_heads
(int
,可选,默认为 12) — Transformer 编码器中每个注意力层的注意力头数量。
intermediate_size
(int
,可选,默认为 3072) — Transformer 编码器中“中间”(通常称为前馈)层的维度。
hidden_act
(str
或 Callable
,可选,默认为 "gelu"
) — 编码器和池化器中的非线性激活函数(函数或字符串)。如果是字符串,支持 "gelu"
, "relu"
, "silu"
和 "gelu_new"
。
hidden_dropout_prob
(float
,可选,默认为 0.1) — 嵌入层、编码器和池化器中所有全连接层的丢弃概率。
attention_probs_dropout_prob
(float
,可选,默认为 0.1) — 注意力概率的丢弃比率。
max_position_embeddings
(int
,可选,默认为 1024) — 此模型可能会使用的最大序列长度。通常将其设置为一个较大的值以防万一(例如,512 或 1024 或 2048)。
initializer_range
(float
,可选,默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
layer_norm_eps
(float
,可选,默认为 1e-12) — 层归一化层使用的 epsilon。
position_embedding_type
(str
, optional, defaults to "absolute"
) — 位置嵌入的类型。选择 "absolute"
、"relative_key"
、"relative_key_query"
中的一个。对于位置嵌入,请使用 "absolute"
。有关 "relative_key"
的更多信息,请参阅 Self-Attention with Relative Position Representations (Shaw et al.)。有关 "relative_key_query"
的更多信息,请参阅 [Improve Transformer Models with Better Relative Position Embeddings (Huang et al.)] 中的 Method 4 (https://arxiv.org/abs/2009.13658)。
use_cache
(bool
, optional, defaults to True
) — 模型是否应返回最后的键/值注意力(并非所有模型都使用)。
num_image_with_embedding
(int
, optional) — 要添加的时间嵌入数量,如果模型用于视频字幕/VQA。
这是用于存储 GitModel 配置的配置类。它用于根据指定的参数实例化 GIT 模型,定义模型架构。使用默认值实例化配置将产生类似于 GIT microsoft/git-base 架构的配置。
配置对象继承自 PretrainedConfig,可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。
示例:
>>> from transformers import GitConfig, GitModel
>>> # Initializing a GIT microsoft/git-base style configuration
>>> configuration = GitConfig()
>>> # Initializing a model (with random weights) from the microsoft/git-base style configuration
>>> model = GitModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
class transformers.GitProcessor
( image_processor tokenizer )
参数
image_processor
(AutoImageProcessor) — 图像处理器是必需的输入。
tokenizer
(AutoTokenizer) — Tokenizer 是必需的输入。
构建一个 GIT 处理器,将 CLIP 图像处理器和 BERT 分词器包装成单个处理器。
GitProcessor 提供了 CLIPImageProcessor 和 BertTokenizerFast 的所有功能。查看 call() 和 decode()
以获取更多信息。
__call__
( text = None images = None return_tensors = None **kwargs ) → export const metadata = 'undefined';BatchEncoding
参数
text
(str
, List[str]
, List[List[str]]
) — 要编码的序列或序列批次。每个序列可以是字符串或字符串列表(预分词字符串)。如果序列以字符串列表(预分词)的形式提供,则必须设置 is_split_into_words=True
(以消除与序列批次的歧义)。
images
(PIL.Image.Image
, np.ndarray
, torch.Tensor
, List[PIL.Image.Image]
, List[np.ndarray]
, List[torch.Tensor]
) — 要准备的图像或图像批次。每个图像可以是 PIL 图像、NumPy 数组或 PyTorch 张量。如果是 NumPy 数组/PyTorch 张量,则每个图像应为形状 (C, H, W),其中 C 是通道数,H 和 W 是图像高度和宽度。
return_tensors
(str
或 TensorType, optional) — 如果设置,将返回特定框架的张量。可接受的值为:
'tf'
: 返回 TensorFlow tf.constant
对象。
'pt'
: 返回 PyTorch torch.Tensor
对象。
'np'
: 返回 NumPy np.ndarray
对象。
'jax'
: 返回 JAX jnp.ndarray
对象。
返回
BatchEncoding
一个带有以下字段的 BatchEncoding:
input_ids
— 要提供给模型的标记 id 列表。当text
不为None
时返回。
attention_mask
— 指定哪些标记应该被模型关注的索引列表(当return_attention_mask=True
或者*attention_mask
*在self.model_input_names
中,且text
不为None
时)。
pixel_values
— 要提供给模型的像素值。当images
不为None
时返回。
为模型准备一个或多个序列和图像的主要方法。如果text
不为None
,则此方法将text
和kwargs
参数转发给 BertTokenizerFast 的call()以对文本进行编码。为准备图像,如果images
不为None
,则此方法将images
和kwrags
参数转发给 CLIPImageProcessor 的call()。请参考上述两种方法的文档以获取更多信息。
class transformers.GitModel
( config )
参数
config
(GitConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只会加载配置。查看 from_pretrained()方法以加载模型权重。由 CLIP 图像编码器和文本解码器组成的基本 GIT 模型变压器,输出原始隐藏状态,没有特定的头部。
此模型继承自 PreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法(如下载或保存、调整输入嵌入、修剪头等)。
此模型还是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取与一般用法和行为相关的所有信息。
forward
( input_ids: Optional = None attention_mask: Optional = None position_ids: Optional = None pixel_values: Optional = None head_mask: Optional = None inputs_embeds: Optional = None past_key_values: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutputWithPooling or tuple(torch.FloatTensor)
参数
input_ids
(形状为(batch_size, sequence_length)
的torch.LongTensor
) — 词汇表中输入序列标记的索引。
可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call
()。
什么是输入 ID?
attention_mask
(形状为(batch_size, sequence_length)
的torch.FloatTensor
,可选) — 避免在填充标记索引上执行注意力的掩码。选择在[0, 1]
中的掩码值:
什么是注意力掩码?
position_ids
(形状为(batch_size, sequence_length)
的torch.LongTensor
,可选) — 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]
中选择。
什么是位置 ID?
pixel_values
(torch.FloatTensor
of shape (batch_size, num_channels, height, width)
) — 像素值。可以使用 AutoImageProcessor 获取像素值。有关详细信息,请参阅 CLIPImageProcessor.call
()。
head_mask
(torch.FloatTensor
of shape (num_heads,)
or (num_layers, num_heads)
, optional) — 用于使自注意力模块的选定头部失效的掩码。掩码值选定在[0, 1]
之间:
masked
,
masked
。
inputs_embeds
(torch.FloatTensor
of shape (batch_size, sequence_length, hidden_size)
, optional) — 可选地,可以直接传递嵌入表示,而不是传递input_ids
。如果您想要更多控制如何将input_ids
索引转换为相关向量,而不是使用模型的内部嵌入查找矩阵,则这很有用。
output_attentions
(bool
, optional) — 是否返回所有注意力层的注意力张量。有关更多细节,请参阅返回张量中的attentions
。
output_hidden_states
(bool
, optional) — 是否返回所有层的隐藏状态。有关更多细节,请参阅返回张量中的hidden_states
。
return_dict
(bool
, optional) — 是否返回 ModelOutput 而不是普通元组。
past_key_values
(tuple(tuple(torch.FloatTensor))
,长度为config.n_layers
,每个元组包含 4 个形状为(batch_size, num_heads, sequence_length - 1, embed_size_per_head)
的张量) — 包含注意力块的预计算的键和值隐藏状态。可用于加速解码。
如果使用了past_key_values
,用户可以选择仅输入最后的decoder_input_ids
(即没有将其过去的键值状态提供给此模型的那些)的形状为(batch_size, 1)
的张量,而不是形状为(batch_size, sequence_length)
的所有decoder_input_ids
。
use_cache
(bool
, optional) — 如果设置为True
,将返回past_key_values
键值状态,并可用于加速解码(参见past_key_values
)。
返回
transformers.modeling_outputs.BaseModelOutputWithPooling 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.BaseModelOutputWithPooling 或一个torch.FloatTensor
元组(如果传递了return_dict=False
或config.return_dict=False
时)包含各种元素,取决于配置(GitConfig)和输入。
last_hidden_state
(torch.FloatTensor
of shape (batch_size, sequence_length, hidden_size)
) — 模型最后一层的隐藏状态序列。
pooler_output
(torch.FloatTensor
of shape (batch_size, hidden_size)
) — 序列的第一个标记(分类标记)的最后一层隐藏状态(经过用于辅助预训练任务的层进一步处理后)。例如,对于 BERT 系列模型,这返回经过线性层和 tanh 激活函数处理后的分类标记。线性层的权重是从预训练期间的下一个句子预测(分类)目标中训练的。
hidden_states
(tuple(torch.FloatTensor)
, optional, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(如果模型具有嵌入层的输出,则为嵌入的输出+每个层的输出)。
模型在每一层输出的隐藏状态以及可选的初始嵌入输出。
attentions
(tuple(torch.FloatTensor)
, optional, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组。
在注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。
GitModel 的前向方法,覆盖了__call__
特殊方法。
虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用Module
实例,而不是在此处调用,因为前者会处理运行前后处理步骤,而后者会默默地忽略它们。
示例:
>>> from transformers import AutoProcessor, AutoModel
>>> import requests
>>> from PIL import Image
>>> processor = AutoProcessor.from_pretrained("microsoft/git-base")
>>> model = AutoModel.from_pretrained("microsoft/git-base")
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> text = "this is an image of two cats"
>>> inputs = processor(text, images=image, return_tensors="pt")
>>> outputs = model(**inputs)
>>> last_hidden_state = outputs.last_hidden_state
class transformers.GitForCausalLM
( config )
参数
config
(GitConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。带有语言建模
头部的 GIT 模型,用于自回归语言建模。
此模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法(如下载或保存、调整输入嵌入、修剪头等)。
此模型也是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。
forward
( input_ids: Optional = None attention_mask: Optional = None position_ids: Optional = None pixel_values: Optional = None head_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None past_key_values: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.CausalLMOutputWithPast or tuple(torch.FloatTensor)
参数
input_ids
(torch.LongTensor
of shape (batch_size, sequence_length)
) — 词汇表中输入序列标记的索引。
可以使用 AutoTokenizer 获取索引。查看 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call
()获取详细信息。
什么是输入 ID?
attention_mask
(torch.FloatTensor
of shape (batch_size, sequence_length)
, optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]
之间:
未被掩码
的标记,
被掩码
的标记。
什么是注意力掩码?
position_ids
(torch.LongTensor
of shape (batch_size, sequence_length)
, optional) — 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]
中选择。
什么是位置 ID?
pixel_values
(torch.FloatTensor
of shape (batch_size, num_channels, height, width)
) — 像素值。可以使用 AutoImageProcessor 获取像素值。查看 CLIPImageProcessor.call
()获取详细信息。
head_mask
(形状为(num_heads,)
或(num_layers, num_heads)
的torch.FloatTensor
,可选)— 用于使自注意力模块中选择的头部失效的掩码。掩码值在[0, 1]
中选择:
inputs_embeds
(形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
,可选)— 可选地,您可以选择直接传递嵌入表示,而不是传递input_ids
。如果您希望更多地控制如何将input_ids
索引转换为相关向量,而不是模型的内部嵌入查找矩阵,则这很有用。
output_attentions
(bool
,可选)— 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回张量下的attentions
。
output_hidden_states
(bool
,可选)— 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量下的hidden_states
。
return_dict
(bool
,可选)— 是否返回 ModelOutput 而不是普通元组。
labels
(形状为(batch_size, sequence_length)
的torch.LongTensor
,可选)— 用于计算从左到右的语言建模损失(下一个单词预测)的标签。索引应在[-100, 0, ..., config.vocab_size]
中(请参见input_ids
文档字符串)。索引设置为-100
的标记将被忽略(掩盖),仅对具有标签 n [0, ..., config.vocab_size]
的标记计算损失
past_key_values
(长度为config.n_layers
的tuple(tuple(torch.FloatTensor))
,每个元组包含形状为(batch_size, num_heads, sequence_length - 1, embed_size_per_head)
的 4 个张量)— 包含注意力块的预计算键和值隐藏状态。可用于加速解码。
如果使用了past_key_values
,用户可以选择仅输入最后的decoder_input_ids
(这些不具有其过去键值状态的模型)的形状为(batch_size, 1)
的张量,而不是形状为(batch_size, sequence_length)
的所有decoder_input_ids
。
use_cache
(bool
,可选)— 如果设置为True
,则返回past_key_values
键值状态,并可用于加速解码(请参见past_key_values
)。
返回
transformers.modeling_outputs.CausalLMOutputWithPast 或tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.CausalLMOutputWithPast 或一个torch.FloatTensor
元组(如果传递了return_dict=False
或config.return_dict=False
时)包含根据配置(GitConfig)和输入的各种元素。
loss
(形状为(1,)
的torch.FloatTensor
,可选,在提供labels
时返回)— 语言建模损失(用于下一个标记预测)。
logits
(形状为(batch_size, sequence_length, config.vocab_size)
的torch.FloatTensor
)— 语言建模头的预测分数(SoftMax 之前每个词汇标记的分数)。
past_key_values
(可选,在传递use_cache=True
或config.use_cache=True
时返回)— 长度为config.n_layers
的tuple(tuple(torch.FloatTensor))
元组,每个元组包含形状为(batch_size, num_heads, sequence_length, embed_size_per_head)
的 2 个张量)
包含预计算的隐藏状态(自注意块中的键和值)可用于加速顺序解码(请参见past_key_values
输入)。
hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(一个用于嵌入层的输出,如果模型有嵌入层,+ 一个用于每一层的输出)。
模型在每一层输出处的隐藏状态以及可选的初始嵌入输出。
attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每一层一个)。
注意力权重在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
GitForCausalLM 的前向方法,覆盖了__call__
特殊方法。
虽然前向传递的步骤需要在这个函数内定义,但应该在此之后调用Module
实例,而不是这个函数,因为前者会处理运行前后的处理步骤,而后者会默默地忽略它们。
示例:
图像字幕示例:
>>> from transformers import AutoProcessor, AutoModelForCausalLM
>>> import requests
>>> from PIL import Image
>>> processor = AutoProcessor.from_pretrained("microsoft/git-base-coco")
>>> model = AutoModelForCausalLM.from_pretrained("microsoft/git-base-coco")
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> pixel_values = processor(images=image, return_tensors="pt").pixel_values
>>> generated_ids = model.generate(pixel_values=pixel_values, max_length=50)
>>> generated_caption = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
>>> print(generated_caption)
two cats sleeping on a pink blanket next to remotes.
视觉问答(VQA)示例:
>>> from transformers import AutoProcessor, AutoModelForCausalLM
>>> from huggingface_hub import hf_hub_download
>>> from PIL import Image
>>> processor = AutoProcessor.from_pretrained("microsoft/git-base-textvqa")
>>> model = AutoModelForCausalLM.from_pretrained("microsoft/git-base-textvqa")
>>> file_path = hf_hub_download(repo_id="nielsr/textvqa-sample", filename="bus.png", repo_type="dataset")
>>> image = Image.open(file_path).convert("RGB")
>>> pixel_values = processor(images=image, return_tensors="pt").pixel_values
>>> question = "what does the front of the bus say at the top?"
>>> input_ids = processor(text=question, add_special_tokens=False).input_ids
>>> input_ids = [processor.tokenizer.cls_token_id] + input_ids
>>> input_ids = torch.tensor(input_ids).unsqueeze(0)
>>> generated_ids = model.generate(pixel_values=pixel_values, input_ids=input_ids, max_length=50)
>>> print(processor.batch_decode(generated_ids, skip_special_tokens=True))
['what does the front of the bus say at the top? special']
视频字幕示例:
>>> import av
>>> import numpy as np
>>> from PIL import Image
>>> from huggingface_hub import hf_hub_download
>>> from transformers import AutoProcessor, AutoModelForCausalLM
>>> processor = AutoProcessor.from_pretrained("microsoft/git-base-vatex")
>>> model = AutoModelForCausalLM.from_pretrained("microsoft/git-base-vatex")
>>> # set seed for reproducability
>>> np.random.seed(45)
>>> def read_video_pyav(container, indices):
... '''
... Decode the video with PyAV decoder.
... Args:
... container (`av.container.input.InputContainer`): PyAV container.
... indices (`List[int]`): List of frame indices to decode.
... Returns:
... result (np.ndarray): np array of decoded frames of shape (num_frames, height, width, 3).
... '''
... frames = []
... container.seek(0)
... start_index = indices[0]
... end_index = indices[-1]
... for i, frame in enumerate(container.decode(video=0)):
... if i > end_index:
... break
... if i >= start_index and i in indices:
... frames.append(frame)
... return np.stack([x.to_ndarray(format="rgb24") for x in frames])
>>> def sample_frame_indices(clip_len, frame_sample_rate, seg_len):
... '''
... Sample a given number of frame indices from the video.
... Args:
... clip_len (`int`): Total number of frames to sample.
... frame_sample_rate (`int`): Sample every n-th frame.
... seg_len (`int`): Maximum allowed index of sample's last frame.
... Returns:
... indices (`List[int]`): List of sampled frame indices
... '''
... converted_len = int(clip_len * frame_sample_rate)
... end_idx = np.random.randint(converted_len, seg_len)
... start_idx = end_idx - converted_len
... indices = np.linspace(start_idx, end_idx, num=clip_len)
... indices = np.clip(indices, start_idx, end_idx - 1).astype(np.int64)
... return indices
>>> # load video
>>> file_path = hf_hub_download(
... repo_id="nielsr/video-demo", filename="eating_spaghetti.mp4", repo_type="dataset"
... )
>>> container = av.open(file_path)
>>> # sample frames
>>> num_frames = model.config.num_image_with_embedding
>>> indices = sample_frame_indices(
... clip_len=num_frames, frame_sample_rate=4, seg_len=container.streams.video[0].frames
... )
>>> frames = read_video_pyav(container, indices)
>>> pixel_values = processor(images=list(frames), return_tensors="pt").pixel_values
>>> generated_ids = model.generate(pixel_values=pixel_values, max_length=50)
>>> print("Generated caption:", processor.batch_decode(generated_ids, skip_special_tokens=True))
Generated caption: ['a woman is sitting at a table and she is talking about the food she is holding.']
he video with PyAV decoder.
… Args:
… container (av.container.input.InputContainer
): PyAV container.
… indices (List[int]
): List of frame indices to decode.
… Returns:
… result (np.ndarray): np array of decoded frames of shape (num_frames, height, width, 3).
… ‘’’
… frames = []
… container.seek(0)
… start_index = indices[0]
… end_index = indices[-1]
… for i, frame in enumerate(container.decode(video=0)):
… if i > end_index:
… break
… if i >= start_index and i in indices:
… frames.append(frame)
… return np.stack([x.to_ndarray(format=“rgb24”) for x in frames])
def sample_frame_indices(clip_len, frame_sample_rate, seg_len): … ‘’’ … Sample a given number of frame indices from the video. … Args: … clip_len (
int
): Total number of frames to sample. … frame_sample_rate (int
): Sample every n-th frame. … seg_len (int
): Maximum allowed index of sample’s last frame. … Returns: … indices (List[int]
): List of sampled frame indices … ‘’’ … converted_len = int(clip_len * frame_sample_rate) … end_idx = np.random.randint(converted_len, seg_len) … start_idx = end_idx - converted_len … indices = np.linspace(start_idx, end_idx, num=clip_len) … indices = np.clip(indices, start_idx, end_idx - 1).astype(np.int64) … return indicesload video file_path = hf_hub_download( … repo_id=“nielsr/video-demo”, filename=“eating_spaghetti.mp4”, repo_type=“dataset” … ) container = av.open(file_path)
sample frames num_frames = model.config.num_image_with_embedding indices = sample_frame_indices( … clip_len=num_frames, frame_sample_rate=4, seg_len=container.streams.video[0].frames … ) frames = read_video_pyav(container, indices)
pixel_values = processor(images=list(frames), return_tensors=“pt”).pixel_values
generated_ids = model.generate(pixel_values=pixel_values, max_length=50)
print(“Generated caption:”, processor.batch_decode(generated_ids, skip_special_tokens=True)) Generated caption: [‘a woman is sitting at a table and she is talking about the food she is holding.’]