BLIP
概述
BLIP模型由李俊楠、李东旭、向春泥、候斯廷在《BLIP: 针对统一视觉-语言理解和生成的自举式语言-图像预训练》(https://arxiv.org/abs/2201.12086)中提出。
BLIP是一种能够执行包括以下多种多模态任务的模型
- 视觉问答
- 图像-文本检索(图像-文本匹配)
- 图像字幕化
论文的摘要如下
视觉-语言预训练(VLP)已经推进了许多视觉-语言任务的性能。然而,大多数现有的预训练模型只在基于理解的任务或基于生成的任务中表现出色。此外,性能的提升主要通过对从网络收集的含噪图像-文本对进行数据集的扩展而实现,这并非最理想的监督来源。在本文中,我们提出了BLIP,一个新的VLP框架,它可以灵活地转移到视觉-语言理解和生成任务中。BLIP通过自举式地生成和过滤标题来有效地利用含噪的网页数据,其中标题生成器生成合成标题,过滤器则消除含噪标题。我们在广泛的视觉-语言任务上取得了最先进的成果,如图像-文本检索(平均召回率@1提高了+2.7%),图像字幕化(CIDEr提高了+2.8%),以及VQA(VQA分数提高了+1.6%)。此外,BLIP在直接迁移到零样本方式下的视频-语言任务中表现出强大的泛化能力。代码、模型和数据集现已发布。
资源
BlipConfig
类 transformers.BlipConfig
< 源代码 >( text_config = None vision_config = None projection_dim = 512 logit_scale_init_value = 2.6592 image_text_hidden_size = 256 label_smoothing = 0.0 **kwargs )
参数
- vision_config (
dict
, 可选) — 初始化 BlipVisionConfig 所使用的配置选项的字典。 - projection_dim (
int
, 可选, 默认为 512) — 文本和视觉投影层的维度。 - logit_scale_init_value (
float
, 可选, 默认为 2.6592) — logit_scale 参数的初始值。默认值根据原始 BLIP 实现。 - image_text_hidden_size (
int
, 可选, 默认为 256) — 图文融合层隐藏状态的维度。 - label_smoothing (浮点数,可选,可选,默认为 0.0) — 一个位于 [0.0, 1.0] 之间的浮点数。指定计算损失时平滑的数量,其中 0.0 表示不进行平滑。目标成为原始真实值和均匀分布的混合,具体描述见
Rethinking the Inception Architecture for Computer Vision <https://arxiv.org/abs/1512.00567>
。默认::math:0.0
。 - kwargs (可选) — 关键字参数字典。
BlipConfig 是用于存储 BlipModel 配置的配置类。它用于根据指定的参数实例化一个 BLIP 模型,定义文本模型和视觉模型配置。使用默认值实例化配置将产生与 BLIP-base Salesforce/blip-vqa-base 架构类似的配置。
配置对象继承自 PretrainedConfig 并可用于控制模型输出。有关更多信息,请参阅 PretrainedConfig 的文档。
示例
>>> from transformers import BlipConfig, BlipModel
>>> # Initializing a BlipConfig with Salesforce/blip-vqa-base style configuration
>>> configuration = BlipConfig()
>>> # Initializing a BlipPModel (with random weights) from the Salesforce/blip-vqa-base style configuration
>>> model = BlipModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
>>> # We can also initialize a BlipConfig from a BlipTextConfig and a BlipVisionConfig
>>> # Initializing a BLIPText and BLIPVision configuration
>>> config_text = BlipTextConfig()
>>> config_vision = BlipVisionConfig()
>>> config = BlipConfig.from_text_vision_configs(config_text, config_vision)
from_text_vision_configs
< 源 >( text_config: BlipTextConfig vision_config: BlipVisionConfig **kwargs ) → BlipConfig
从 blip 文本模型配置和 blip 视觉模型配置中实例化一个 BlipConfig(或其派生类)。
BlipTextConfig
类 transformers.BlipTextConfig
< 来源 >( 词汇大小 = 30524 隐藏层大小 = 768 编码器隐藏层大小 = 768 中间层大小 = 3072 投影维度 = 768 隐藏层数量 = 12 注意力头数量 = 8 最大位置嵌入 = 512 隐藏层激活函数 = 'gelu' 层归一化epsilon = 1e-12 隐藏层dropout概率 = 0.0 注意力概率dropout概率 = 0.0 初始化范围 = 0.02 bos标记id = 30522 eos标记id = 2 pad标记id = 0 sep标记id = 102 是否为解码器 = True 使用缓存 = True 标签平滑 = 0.0 kwargs )
参数
- vocab_size (
int
,可选,默认为30524)——Blip
文本模型的词汇量。定义了在调用 BlipModel 时通过inputs_ids
传入的不同标记的数量。 - hidden_size (
int
,可选,默认为768)—— 编码器层和池化层的维度。 - encoder_hidden_size (
int
,可选,默认为768)—— 视觉模型编码器层的维度。 - intermediate_size (
int
, 可选,默认3072) — Transformer编码器中“中间”层(即前馈层)的维度。 - num_hidden_layers (
int
, 可选,默认12) — Transformer编码器中的隐藏层数。 - num_attention_heads (
int
, 可选,默认8) — Transformer编码器中每个注意力层使用的注意力头数。 - hidden_dropout_prob (
float
, 可选, 默认为 0.0) — 嵌入层、编码器和池器中所有全连接层的dropout概率。 - attention_dropout (
float
, 可选, 默认为 0.0) — 注意力概率的dropout比例。 - initializer_range (
float
, 可选, 默认为 0.02) — 所有权重矩阵初始化时truncated_normal_initializer的标准差。 - bos_token_id (
int
, 可选, 默认值为 30522) — 代码序列开始标记的 id。 - eos_token_id (
int
, 可选, 默认值为 2) — 代码序列结束标记的 id。 - pad_token_id (
int
, 可选, 默认值为 0) — 填充标记的 id。 - sep_token_id (
int
, 可选, 默认值为 102) — 分隔标记的 id。 - is_decoder (
bool
, 可选, 默认为True
) — 模型是否作为解码器使用。 - use_cache (
bool
, 可选, 默认为True
) — 模型是否返回最后的键/值注意力(并非所有模型都使用)。 - label_smoothing (float, 可选) — 一个位于 [0.0, 1.0] 之间的浮点数。指定在计算损失时的平滑量,其中 0.0 表示没有平滑。目标将变为原始真实值和均匀分布的混合,如《重新思考计算机视觉的 Inception 架构》[https://arxiv.org/abs/1512.00567] 中所述。默认值::math:
0.0
。
这是一个配置类,用于存储 BlipTextModel 的配置。它根据指定的参数实例化 BLIP 文本模型,定义模型架构。使用默认值实例化配置将得到与 基本架构 中使用的 BlipText
相似的配置。
配置对象继承自 PretrainedConfig 并可用于控制模型输出。有关更多信息,请参阅 PretrainedConfig 的文档。
示例
>>> from transformers import BlipTextConfig, BlipTextModel
>>> # Initializing a BlipTextConfig with Salesforce/blip-vqa-base style configuration
>>> configuration = BlipTextConfig()
>>> # Initializing a BlipTextModel (with random weights) from the Salesforce/blip-vqa-base style configuration
>>> model = BlipTextModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
BlipVisionConfig
类 transformers.BlipVisionConfig
< source >( hidden_size = 768 intermediate_size = 3072 projection_dim = 512 num_hidden_layers = 12 num_attention_heads = 12 image_size = 384 patch_size = 16 hidden_act = 'gelu' layer_norm_eps = 1e-05 attention_dropout = 0.0 initializer_range = 1e-10 **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
,可选,默认为384) — 每个图像的大小(分辨率)。 - patch_size (
int
,可选,默认为16) — 每个补丁的大小(分辨率)。 - hidden_act (
str
或function
,可选,默认为"gelu"
) — 编码器和解码器中的非线性激活函数(函数或字符串)。如果是字符串,支持"gelu"
、"relu"
、"selu"
和"gelu_new"
。 - layer_norm_eps (
float
,可选,默认为 1e-5) — 层归一化层使用的 ε。 - attention_dropout (
float
,可选,默认为 0.0) — 注意力概率的 dropout 比率。 - initializer_range (
float
, 可选,默认为 1e-10) — 所有权重矩阵初始化时的截断正态分布的均值标准差。
这是一个存储 BlipVisionModel 配置的配置类。它用于根据指定的参数实例化一个 BLIP 视觉模型,定义模型架构。默认配置的实例化将产生与 Blip-base Salesforce/blip-vqa-base 架构相似的配置。
配置对象继承自 PretrainedConfig 并可用于控制模型输出。有关更多信息,请参阅 PretrainedConfig 的文档。
示例
>>> from transformers import BlipVisionConfig, BlipVisionModel
>>> # Initializing a BlipVisionConfig with Salesforce/blip-vqa-base style configuration
>>> configuration = BlipVisionConfig()
>>> # Initializing a BlipVisionModel (with random weights) from the Salesforce/blip-vqa-base style configuration
>>> model = BlipVisionModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
BlipProcessor
类 transformers.BlipProcessor
< source >( image_processor tokenizer **kwargs )
参数
- image_processor (
BlipImageProcessor
) — 一个 BlipImageProcessor 实例。图像处理器是必须输入。 - tokenizer (
BertTokenizerFast
) — 一个 [‘BertTokenizerFast`] 实例。分词器是必须输入。
构建一个包含 BERT 分词器和 BLIP 图像处理器的 BLIP 处理器。
BlipProcessor 提供了 BlipImageProcessor 和 BertTokenizerFast 所有的功能。请参阅 __call__()
和 decode() 方法以获取更多信息。
此方法将所有其参数传递给 BertTokenizerFast 的 batch_decode()。请参阅该方法的文档字符串以获取更多信息。
BlipImageProcessor
类 transformers.BlipImageProcessor
< 源 >( 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 do_convert_rgb: bool = True **kwargs )
参数
- do_resize (
bool
,可选,默认为True
)—是否调整图像的(高度,宽度)尺寸到指定的size
。可以在preprocess
方法中的do_resize
参数中进行覆盖。 - size (
dict
,可选,默认为{ "height": 384, "width": 384 }
):调整大小后的输出图像尺寸。可以在preprocess
方法中的size
参数中进行覆盖。 - resample (
PILImageResampling
, 可选,默认为Resampling.BICUBIC
) — 图像缩放时使用的重采样滤波器。只有在do_resize
设置为True
时才有效。可以通过preprocess
方法中的resample
参数进行重写。 - do_rescale (
bool
, 可选,默认为True
) — 是否通过指定的缩放系数rescale_factor
缩放图像。可以通过preprocess
方法中的do_rescale
参数进行重写。 - rescale_factor (
int
或float
, 可选,默认为1/255
) — 图像缩放时使用的缩放系数。只有在do_rescale
设置为True
时才有效。可以通过preprocess
方法中的rescale_factor
参数进行重写。 - do_normalize (
bool
, optional, defaults toTrue
) — 是否对图像进行归一化。可以通过preprocess
方法中的do_normalize
参数进行覆盖。也可以通过preprocess
方法中的do_normalize
参数进行覆盖。 - image_mean (
float
orList[float]
, optional, defaults toIMAGENET_STANDARD_MEAN
) — 如果对图像进行归一化,所使用的均值。它是一个浮点数或浮点数列表,其长度对应于图像通道数。可以通过preprocess
方法中的image_mean
参数进行覆盖。也可以通过preprocess
方法中的image_mean
参数进行覆盖。 - image_std (
float
orList[float]
, optional, defaults toIMAGENET_STANDARD_STD
) — 如果对图像进行归一化,所使用的标准差。它是一个浮点数或浮点数列表,其长度对应于图像通道数。可以通过preprocess
方法中的image_std
参数进行覆盖。也可以通过preprocess
方法中的image_std
参数进行覆盖。 - — do_convert_rgb (bool, 可选,默认为 True) — 是否将图像转换为 RGB。
构建 BLIP 图像处理器。
预处理
< 源代码 >( images: 并集 do_resize: 可选 = None size: 可选 = None resample: 重采样 = None do_rescale: 可选 = None rescale_factor: 可选 = None do_normalize: 可选 = None image_mean: 并集 = None image_std: 并集 = None return_tensors: 并集 = None do_convert_rgb: bool = None data_format: ChannelDimension = <ChannelDimension.FIRST: 'channels_first'> input_data_format: 并集 = None )
参数
- images (
ImageInput
) — 预处理图像。期望单个或批量的图像,像素值范围为0到255。如果传入像素值在0到1之间的图像,设置do_rescale=False
。 - do_resize (
bool
, 可选self.do_resize) — 是否调整图像大小。 - size(
Dict[str, int]
,可选,默认为self.size
) — 控制resize
后的图像大小。保持长宽比,将图像最短的边调整到size["shortest_edge"]
。如果调整后的图像最长边大于int(size["shortest_edge"] * (1333 / 800))
,则再次调整图像,使最长边等于int(size["shortest_edge"] * (1333 / 800))
。 - resample(
PILImageResampling
,可选,默认为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_convert_rgb (
bool
, 可选,默认为self.do_convert_rgb
) — 是否将图像转换为 RGB。 - 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
的批次。
- 未设置:返回
- (HTML 标签开始)data_format(
ChannelDimension
或str
,可选,默认为ChannelDimension.FIRST
)——输出图像的通道维度格式。可以是以下之一:"channels_first"
或ChannelDimension.FIRST
:图像格式为 (num_channels, height, width)。"channels_last"
或ChannelDimension.LAST
:图像格式为 (height, width, num_channels)。- 未设置:使用输入图像的通道维度格式。
- (HTML 标签开始)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)。
预处理图像或图像批处理。
BlipModel
BlipModel
在未来的版本中将不再被支持,请根据您的使用情况使用 BlipForConditionalGeneration
、BlipForImageTextRetrieval
或 BlipForQuestionAnswering
。
类 transformers.BlipModel
< source >( config: BlipConfig )
参数
- config (BlipConfig) — 模型配置类,包含所有模型参数。使用配置文件进行初始化不会加载与模型关联的权重,只有配置。请查看 from_pretrained() 方法以加载模型权重。
此模型将在未来的版本中被弃用。请根据您的使用场景使用 BlipForConditionalGeneration
、BlipForQuestionAnswering
或 BlipForImageTextRetrieval
。
此模型继承了 PreTrainedModel。请查看超类文档,了解库为所有模型实现的通用方法(如下载或保存、调整输入嵌入的大小、剪枝头部等)。
此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档获取关于一般使用和行为的所有相关信息。
forward
< source >( 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 interpolate_pos_encoding: bool = False ) → transformers.models.blip.modeling_blip.BlipOutput
or tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor
of shape(batch_size, sequence_length)
) — 序列中的词汇索引。如果提供填充,默认会忽略填充部分。索引可以通过 AutoProcessor 获取。详情请见
BlipProcessor.__call__()`
。 - return_loss (
bool
, 可选) — 是否返回对比损失。 - output_attentions (
bool
, 可选) — 是否返回所有注意力层的注意力张量。请详见返回张量下的`attentions`。 - output_hidden_states (
bool
, 可选) — 是否返回所有层的隐藏状态。请详见返回张量下的`hidden_states`。 - return_dict (
bool
, 可选) — 是否返回ModelOutput对象而不是普通元组。 - interpolate_pos_encoding (
bool
, 可选, 默认为False
) — 是否插值预训练的位置编码。
返回
transformers.models.blip.modeling_blip.BlipOutput
或 tuple(torch.FloatTensor)
A transformers.models.blip.modeling_blip.BlipOutput
或一个包含 torch.FloatTensor
的元组(如果传递了 return_dict=False
或当 config.return_dict=False
),这取决于配置(<class 'transformers.models.blip.configuration_blip.BlipConfig'>
)和输入。
- 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
) — 应用 BlipTextModel 的池化输出后的投影层得到文本嵌入。 - image_embeds(
torch.FloatTensor
形状为(batch_size, output_dim
) — 应用 BlipVisionModel 的池化输出后的投影层得到图像嵌入。 - text_model_output(
BaseModelOutputWithPooling
): BlipTextModel 的输出。 - vision_model_output(
BaseModelOutputWithPooling
): BlipVisionModel 的输出。
BlipModel 的前进方法,重写了 __call__
特殊方法。
尽管需要在此函数中定义前进传递的配方,但之后应调用该 Module
实例,而不是此实例,因为前者负责执行预和后处理步骤,而后者则默默忽略它们。
示例
>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, BlipModel
>>> model = BlipModel.from_pretrained("Salesforce/blip-image-captioning-base")
>>> processor = AutoProcessor.from_pretrained("Salesforce/blip-image-captioning-base")
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> inputs = processor(
... text=["a photo of a cat", "a photo of a dog"], images=image, return_tensors="pt", padding=True
... )
>>> outputs = model(**inputs)
>>> logits_per_image = outputs.logits_per_image # this is the image-text similarity score
>>> probs = logits_per_image.softmax(dim=1) # we can take the softmax to get the label probabilities
get_text_features
参数
- attention_mask (
torch.Tensor
of shape(batch_size, sequence_length)
, 可选) — 避免对填充标记索引执行注意力的掩码。选定的掩码值在[0, 1]
范围内:- 1 表示 未屏蔽 的标记;
- 0 表示 屏蔽 的标记。
- position_ids (
torch.LongTensor
of shape(batch_size, sequence_length)
, 可选) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]
。 - output_attentions (
bool
, 可选) — 是否返回所有注意层 attention 张量。请参考返回的张量中的attentions
获取更多详细内容。 output_hidden_states ( bool
, 可选) — 是否返回所有层的隐藏状态。有关详细信息,请参阅返回的张量下的hidden_states
。ActionListenerEnd-
return_dict ( bool
, 可选) — 是否返回ModelOutput而不是普通元组。
返回
text_features (torch.FloatTensor
of shape (batch_size, output_dim
)
通过在BlipTextModel
的池化输出上应用投影层得到的文本嵌入。
BlipModel 的前进方法,重写了 __call__
特殊方法。
尽管需要在此函数中定义前进传递的配方,但之后应调用该 Module
实例,而不是此实例,因为前者负责执行预和后处理步骤,而后者则默默忽略它们。
示例
>>> from transformers import AutoProcessor, BlipModel
>>> model = BlipModel.from_pretrained("Salesforce/blip-image-captioning-base")
>>> processor = AutoProcessor.from_pretrained("Salesforce/blip-image-captioning-base")
>>> inputs = processor(text=["a photo of a cat", "a photo of a dog"], padding=True, return_tensors="pt")
>>> text_features = model.get_text_features(**inputs)
get_image_features
< source >( pixel_values: Optional = None return_dict: Optional = None interpolate_pos_encoding: bool = False ) → ActionListenerStart>image_features (torch.FloatTensor
of shape (batch_size, output_dim
)
参数
- pixel_values (
torch.FloatTensor
of shape(batch_size, num_channels, height, width)
) — 像素值。如果提供填充,则默认忽略填充。可以使用 BlipImageProcessor 获取像素值。有关详细信息,请参阅 BlipImageProcessor.call()。 - output_attentions (
bool
, 可选) — 是否返回所有注意力层的注意力张量。有关详细信息,请参阅返回张量下的attentions
。 - output_hidden_states (
bool
, 可选) — 是否返回所有层的隐藏状态。有关详细信息,请参阅返回张量下的hidden_states
。 - return_dict (
bool
, 可选) — 是否返回一个transformers.utils.ModelOutput
对象,而不是一个普通的元组。
注意:此处为代码格式化后的输出,未进行完全翻译,具体内容请以实际文档为准。 - interpolate_pos_encoding (
bool
, 可选, 默认为false
) — 是否对预训练的位置编码进行插值。
注意:此处为代码格式化后的输出,未进行完全翻译,具体内容请以实际文档为准。
返回
image_features (torch.FloatTensor
形状:(batch_size, output_dim)
)
通过对BlipVisionModel的输出进行投影层计算获取到的图像嵌入。
BlipModel 的前进方法,重写了 __call__
特殊方法。
尽管需要在此函数中定义前进传递的配方,但之后应调用该 Module
实例,而不是此实例,因为前者负责执行预和后处理步骤,而后者则默默忽略它们。
示例
>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, BlipModel
>>> model = BlipModel.from_pretrained("Salesforce/blip-image-captioning-base")
>>> processor = AutoProcessor.from_pretrained("Salesforce/blip-image-captioning-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")
>>> image_features = model.get_image_features(**inputs)
BlipTextModel
该模型既可以作为编码器(仅自注意力)使用,也可以作为解码器使用。在这种情况下,在每个自注意力层之间添加一层交叉注意力层,其架构遵循由Ashish Vaswani、Noam Shazeer、Niki Parmar、Jakob Uszkoreit、Llion Jones、Aidan N. Gomez、Lukasz Kaiser和Illia Polosukhin描述的《注意力就是你需要的所有》。将is_decoder
设置为True
;正向传输时则期望输入encoder_hidden_states
。
forward
< source >( input_ids: 可选 = None attention_mask: 可选 = None position_ids: 可选 = None head_mask: 可选 = None inputs_embeds: 可选 = None encoder_embeds: 可选 = None encoder_hidden_states: 可选 = None encoder_attention_mask: 可选 = None past_key_values: 可选 = None use_cache: 可选 = None output_attentions: 可选 = None output_hidden_states: 可选 = None return_dict: 可选 = None is_decoder: 可选 = False )
encoder_hidden_states (torch.FloatTensor
, 可选): 编码器最后一个层的隐藏状态的序列。如果在配置为解码器时使用,将用于跨注意力。encoder_attention_mask (torch.FloatTensor
, 可选): 避免对编码器输入中填充token索引执行注意力的掩码。如果在配置为解码器时使用,将用于跨注意力。掩码值选在[0, 1]
- 1 表示 未掩码 的tokens,
- 0 表示 掩码 的tokens。past_key_values (
tuple(tuple(torch.FloatTensor))
, 可选): 包含注意力块预计算的键和值隐藏状态。可用于加速解码。如果使用past_key_values
,则用户可以可选地仅输入最后一个decoder_input_ids
(那些没有给此模型提供过去键值状态的)的形状为(batch_size, 1)
,而不是所有decoder_input_ids
的形状为(batch_size, sequence_length)
。use_cache (bool
, 可选): 如果设置为True
,则返回past_key_values
键值状态,并且可以用于加速解码(参见past_key_values
)。
BlipVisionModel
forward
< source >( pixel_values: 可选 = None output_attentions: 可选 = None output_hidden_states: 可选 = None return_dict: 可选 = None interpolate_pos_encoding: 布尔 = False ) → transformers.modeling_outputs.BaseModelOutputWithPooling or tuple(torch.FloatTensor)
参数
- pixel_values (
torch.FloatTensor
形状(batch_size, num_channels, height, width)
) — 像素值。提供填充时默认会忽略。像素值可以使用 BlipImageProcessor 获取。有关详细信息,请参阅BlipImageProcessor.call()`。 - output_attentions (
bool
, 可选) — 是否返回所有注意力层的注意力张量。有关更多详情,请参阅返回的张量下的attentions
。 - output_hidden_states (
bool
, 可选) — 是否返回所有层的隐藏状态。有关返回张量的更多信息,请参阅hidden_states
。 - return_dict (
bool
, 可选) — 是否返回ModelOutput而不是普通元组。 - interpolate_pos_encoding (
bool
, 可选,默认值false
) — 是否对预训练的位置编码进行插值。
返回
transformers.modeling_outputs.BaseModelOutputWithPooling或tuple(torch.FloatTensor)
A transformers.modeling_outputs.BaseModelOutputWithPooling或一个由torch.FloatTensor
元组成的内容,具体取决于配置(<class 'transformers.models.blip.configuration_blip.BlipVisionConfig'>
)和输入(如果传递了return_dict=False
或当config.return_dict=False
)。
-
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后的注意力权重,用于计算自注意力头中的加权和。
BlipVisionModel 前向方法覆盖了 __call__
特殊方法。
尽管需要在此函数中定义前进传递的配方,但之后应调用该 Module
实例,而不是此实例,因为前者负责执行预和后处理步骤,而后者则默默忽略它们。
BlipForConditionalGeneration
类 transformers.BlipForConditionalGeneration
< 源代码 >( config: BlipConfig )
参数
- config (BlipConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载模型相关的权重,只加载配置。查看 from_pretrained() 方法来加载模型权重。
BLIP 图像标题模型。该模型由视觉编码器和文本解码器组成。可以可选地传入 input_ids
到模型中,作为文本提示,以便让文本解码器继续提示。否则,解码器将从 [BOS](序列开头)标记开始生成文本。将从文本输入开始生成标题。如果没有提供文本输入,解码器将只使用 [BOS] 标记开始。
此模型继承了 PreTrainedModel。请查看超类文档,了解库为所有模型实现的通用方法(如下载或保存、调整输入嵌入的大小、剪枝头部等)。
此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档获取关于一般使用和行为的所有相关信息。
forward
< 来源 >( pixel_values: FloatTensor input_ids: Optional = None attention_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None labels: Optional = None return_dict: Optional = None interpolate_pos_encoding: bool = False ) → transformers.models.blip.modeling_blip.BlipForConditionalGenerationModelOutput
或 tuple(torch.FloatTensor)
参数
- pixel_values (
torch.FloatTensor
形状为(batch_size, num_channels, height, width)
) — 像素值。如果提供了填充值,默认会忽略。可以使用 BlipImageProcessor 获取像素值。有关详细信息,请参阅 BlipImageProcessor.call()。 - output_attentions (
bool
,可选)— 是否返回所有注意力层的注意力张量。有关返回张量中的更详细信息,请参阅attentions
。 - output_hidden_states (bool, 可选) — 是否返回所有层的隐含状态。请参阅返回张量下的 hidden_states 以获取更多详细信息。
- return_dict (bool, 可选) — 是否返回 ModelOutput 实例而不是常规元组。
- interpolate_pos_encoding (bool, 可选,默认为 False) — 是否插值预训练的位置编码。
返回
transformers.models.blip.modeling_blip.BlipForConditionalGenerationModelOutput
或 tuple(torch.FloatTensor)
一个 transformers.models.blip.modeling_blip.BlipForConditionalGenerationModelOutput
或一个元组,包含的元素取决于配置(<class 'transformers.models.blip.configuration_blip.BlipVisionConfig'>
)和输入(如果 return_dict=False
被传递或当 config.return_dict=False
时)。
-
loss (
torch.FloatTensor
,可选,当提供labels
时返回,其形状为(1,)
) — 文本解码器的语言模型损失。 -
logits (
torch.FloatTensor
形状为(batch_size, sequence_length, config.vocab_size)
,可选) — 文本解码器模型语言模型头的预测分数。 -
image_embeds (
torch.FloatTensor
形状为(batch_size, output_dim)
,可选) — 在对输入图像应用视觉 Transformer 模型后获得图像嵌入。 -
last_hidden_state (形状为
(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
,可选) — 模型的最后一层的输出处的隐藏状态序列。 -
hidden_states (
tuple(torch.FloatTensor)
,可选,在output_hidden_states=True
时返回) — 由形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
组成的元组(如果模型有嵌入层,则为嵌入层的输出 + 每层的输出)。每个层的模型输出隐藏状态以及可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
的元组(每个用于每一层)。注意力softmax后的注意力权重,用于计算自注意力头中的加权和。
BlipForConditionalGeneration 的 forward 方法覆盖了 __call__
特殊方法。
尽管需要在此函数中定义前进传递的配方,但之后应调用该 Module
实例,而不是此实例,因为前者负责执行预和后处理步骤,而后者则默默忽略它们。
示例
>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, BlipForConditionalGeneration
>>> processor = AutoProcessor.from_pretrained("Salesforce/blip-image-captioning-base")
>>> model = BlipForConditionalGeneration.from_pretrained("Salesforce/blip-image-captioning-base")
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> text = "A picture of"
>>> inputs = processor(images=image, text=text, return_tensors="pt")
>>> outputs = model(**inputs)
BlipForImageTextRetrieval
class transformers.BlipForImageTextRetrieval
< source >( config: BlipConfig )
参数
- config (BlipConfig) — 模型配置类,包含模型的所有参数。使用配置文件初始化不会加载模型关联的权重,只会加载配置。查看 from_pretrained() 方法以加载模型权重。
具有视觉和文本投影仪以及顶部分类头的BLIP模型。该模型用于图像-文本检索的上下文中。给定一张图片和一段文本,模型返回文本与图片相关性的概率。
此模型继承了 PreTrainedModel。请查看超类文档,了解库为所有模型实现的通用方法(如下载或保存、调整输入嵌入的大小、剪枝头部等)。
此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档获取关于一般使用和行为的所有相关信息。
forward
< source >( input_ids: LongTensor pixel_values: FloatTensor use_itm_head: Optional = True attention_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None interpolate_pos_encoding: bool = False ) → transformers.models.blip.modeling_blip.BlipTextVisionModelOutput
或 tuple(torch.FloatTensor)
参数
- pixel_values (
torch.FloatTensor
for shape(batch_size, num_channels, height, width)
) — 像素值。如果提供了填充,默认会忽略它。可以使用 BlipImageProcessor 获取像素值。有关详情,请参阅 BlipImageProcessor.call() - output_attentions (
bool
, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions
- output_hidden_states (
bool
, 可选) — 是否返回所有层的隐藏状态。更多的细节请查看返回值张量下的
。hidden_states
- return_dict (
bool
, 可选) — 是否以ModelOutput形式返回,而不是原始元组。 - interpolate_pos_encoding (
bool
, 可选, 默认为False
) — 是否对预训练的位置编码进行插值。
返回
模型输出:transformers.models.blip.modeling_blip.BlipTextVisionModelOutput
或者 tuple(torch.FloatTensor)
一个 transformers.models.blip.modeling_blip.BlipTextVisionModelOutput
或者一个由 torch.FloatTensor
组成的元组(如果传递了 return_dict=False
或当配置文件 config.return_dict=False
时),根据配置(例如<class 'transformers.models.blip.configuration_blip.BlipVisionConfig'>
)和输入变量包含不同的元素。
-
loss (
torch.FloatTensor
形状为(1,)
,可选,当提供了labels
时返回) — 从文本解码器的语言模型损失。 -
image_embeds (
torch.FloatTensor
形状为(batch_size, output_dim)
,可选,当模型初始化为with_projection=True
时返回) — 通过对池化输出应用投影层获得的图像嵌入。 -
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后的注意力权重,用于计算自注意力头中的加权和。
BlipForImageTextRetrieval 前向方法,重写了 __call__
特殊方法。
尽管需要在此函数中定义前进传递的配方,但之后应调用该 Module
实例,而不是此实例,因为前者负责执行预和后处理步骤,而后者则默默忽略它们。
示例
>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, BlipForImageTextRetrieval
>>> model = BlipForImageTextRetrieval.from_pretrained("Salesforce/blip-itm-base-coco")
>>> processor = AutoProcessor.from_pretrained("Salesforce/blip-itm-base-coco")
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> text = "an image of a cat"
>>> inputs = processor(images=image, text=text, return_tensors="pt")
>>> outputs = model(**inputs)
BlipForQuestionAnswering
类 transformers.BlipForQuestionAnswering
< 来源 >( config: BlipConfig )
参数
- config(《BlipConfig》)—— 承载所有模型参数的配置类。使用配置文件初始化不会加载与模型关联的权重,只加载配置。请查看`from_pretrained()`方法以加载模型权重。
BLIP 图像问答模型。该模型由图像编码器、文本编码器和文本解码器组成。图像编码器将输入图像进行编码,文本编码器将输入问题及其编码的图像一同编码,文本解码器将输出问题的答案。
此模型继承了 PreTrainedModel。请查看超类文档,了解库为所有模型实现的通用方法(如下载或保存、调整输入嵌入的大小、剪枝头部等)。
此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档获取关于一般使用和行为的所有相关信息。
forward
< source >( input_ids: LongTensor pixel_values: FloatTensor decoder_input_ids: 可选 = None decoder_attention_mask: 可选 = None attention_mask: 可选 = None output_attentions: 可选 = None output_hidden_states: 可选 = None labels: 可选 = None return_dict: 可选 = None interpolate_pos_encoding: bool = False ) → transformers.models.blip.modeling_blip.BlipTextVisionModelOutput
或 tuple(torch.FloatTensor)
参数
- pixel_values(《torch.FloatTensor》形如
(batch_size, num_channels, height, width)
)—— 像素值。提供填充时默认将忽略填充。可以使用 BlipImageProcessor 来获取像素值。详细信息请参见 BlipImageProcessor.call()。 - output_attentions(《bool”,可选)—— 是否返回所有注意力层的数据。详细信息请参见返回的张量下的代码
attentions
。 - output_hidden_states(《bool”,可选)—— 是否返回所有层的隐藏状态。详细信息请参见返回的张量下的代码
hidden_states
。 - return_dict (
bool
, optional) — 是否返回ModelOutput而非普通元组。 - optional) — 是否插值预训练的位置编码,默认为False。 默认值。
返回
模型输出:transformers.models.blip.modeling_blip.BlipTextVisionModelOutput
或者 tuple(torch.FloatTensor)
一个 transformers.models.blip.modeling_blip.BlipTextVisionModelOutput
或者一个由 torch.FloatTensor
组成的元组(如果传递了 return_dict=False
或当配置文件 config.return_dict=False
时),根据配置(例如<class 'transformers.models.blip.configuration_blip.BlipVisionConfig'>
)和输入变量包含不同的元素。
-
loss (
torch.FloatTensor
形状为(1,)
,可选,当提供了labels
时返回) — 从文本解码器的语言模型损失。 -
image_embeds (
torch.FloatTensor
形状为(batch_size, output_dim)
,可选,当模型初始化为with_projection=True
时返回) — 通过对池化输出应用投影层获得的图像嵌入。 -
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后的注意力权重,用于计算自注意力头中的加权和。
《BlipForQuestionAnswering》的`forward`方法覆盖了特殊的`__call__`方法。
尽管需要在此函数中定义前进传递的配方,但之后应调用该 Module
实例,而不是此实例,因为前者负责执行预和后处理步骤,而后者则默默忽略它们。
示例
>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, BlipForQuestionAnswering
>>> model = BlipForQuestionAnswering.from_pretrained("Salesforce/blip-vqa-base")
>>> processor = AutoProcessor.from_pretrained("Salesforce/blip-vqa-base")
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> # training
>>> text = "How many cats are in the picture?"
>>> label = "2"
>>> inputs = processor(images=image, text=text, return_tensors="pt")
>>> labels = processor(text=label, return_tensors="pt").input_ids
>>> inputs["labels"] = labels
>>> outputs = model(**inputs)
>>> loss = outputs.loss
>>> loss.backward()
>>> # inference
>>> text = "How many cats are in the picture?"
>>> inputs = processor(images=image, text=text, return_tensors="pt")
>>> outputs = model.generate(**inputs)
>>> print(processor.decode(outputs[0], skip_special_tokens=True))
2
TFBlipModel
调用
< 源代码 >( input_ids: tf.Tensor | None = None pixel_values: tf.Tensor | None = None attention_mask: tf.Tensor | None = None position_ids: tf.Tensor | None = None return_loss: Optional[bool] = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: Optional[bool] = None ) → transformers.models.blip.modeling_tf_blip.TFBlipOutput
或 tuple(tf.Tensor)
参数
- input_ids (
tf.Tensor
形状为(batch_size, sequence_length)
) — 输入序列中词汇的索引。如果提供了填充,默认会忽略填充。索引可以使用 AutoProcessor 获取。有关详细信息,请参阅
BlipProcessor.__call__()
。 - attention_mask (
tf.Tensor
形状为(batch_size, sequence_length)
,可选) — 避免对填充标记索引执行注意力的掩码。掩码值选择在[0, 1]
:- 1 表示 未掩码 的标记,
- 0 表示 掩码 的标记。
- position_ids (
tf.Tensor
形状为(batch_size, sequence_length)
,可选) — 每个输入序列标记在位置嵌入中的位置索引。在[0, config.max_position_embeddings - 1]
范围内选择。 - pixel_values (
tf.Tensor
形状为(batch_size, num_channels, height, width)
) — 像素值。如果您提供它,默认情况下将忽略填充。可以使用 BlipImageProcessor 获得像素值。有关详细信息,请参阅 BlipImageProcessor.call()。<-- HTML_TAG_END --> - return_loss (
bool
,可选) — 是否返回对比损失。<-- HTML_TAG_END --> - 输出注意力 (
bool
,可选) — 是否返回所有注意力层的注意力张量。详细信息请参阅返回张量下的attentions
。 - 输出隐藏状态 (
bool
,可选) — 是否返回所有层的隐藏状态。详细信息请参阅返回张量下的hidden_states
。 - 返回字典 (
bool
,可选) — 是否返回ModelOutput而不是简单的元组。
返回
transformers.models.blip.modeling_tf_blip.TFBlipOutput
或tuple(tf.Tensor)
一个transformers.models.blip.modeling_tf_blip.TFBlipOutput
或一个包含各种元素的tf.Tensor元组(当传递return_dict=False
或当config.return_dict=False
时),这些元素取决于配置(<class 'transformers.models.blip.configuration_blip.BlipConfig'>
)和输入。
- loss(
shape=(1,)
的tf.Tensor,可选,当return_loss=True
时返回) — 图像-文本相似度的对比损失。 - logits_per_image:代表图像嵌入和文本嵌入之间缩放点积得分的
(image_batch_size, text_batch_size)
形状的tf.Tensor。此代表图像-文本相似度得分。 - logits_per_text:(
tf.Tensor
,形状为(text_batch_size, image_batch_size)
)—— 表示text_embeds
和image_embeds
之间的缩放点积分数。这代表着文本-图像相似度分数。 - text_embeds(
tf.Tensor
,形状为(batch_size, output_dim)
)—— 通过将 BlipTextModel 的池化输出应用投影层而获得文本嵌入。 - image_embeds(
tf.Tensor
,形状为(batch_size, output_dim)
)—— 通过将 BlipVisionModel 的池化输出应用投影层而获得图像嵌入。 - text_model_output(
BaseModelOutputWithPooling
): BlipTextModel 的输出。 - vision_model_output(
BaseModelOutputWithPooling
): BlipVisionModel 的输出。
TFBlipModel 的前向方法重写了 __call__
特殊方法。
尽管需要在此函数中定义前进传递的配方,但之后应调用该 Module
实例,而不是此实例,因为前者负责执行预和后处理步骤,而后者则默默忽略它们。
示例
>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, TFBlipModel
>>> model = TFBlipModel.from_pretrained("Salesforce/blip-image-captioning-base")
>>> processor = AutoProcessor.from_pretrained("Salesforce/blip-image-captioning-base")
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> inputs = processor(
... text=["a photo of a cat", "a photo of a dog"], images=image, return_tensors="tf", padding=True
... )
>>> outputs = model(**inputs)
>>> logits_per_image = outputs.logits_per_image # this is the image-text similarity score
>>> probs = tf.nn.softmax(logits_per_image, axis=1) # we can take the softmax to get the label probabilities
get_text_features
< 源 >( input_ids: tf.Tensor | None = None attention_mask: tf.Tensor | None = None position_ids: tf.Tensor | None = None return_dict: Optional[bool] = None ) → text_features (tf.Tensor
of shape (batch_size, output_dim)
)
参数
- input_ids (
tf.Tensor
形状(batch_size, sequence_length)
) — 词汇表中的输入序列标记索引。如果提供,默认忽略填充的部分。可以使用 AutoProcessor 获取索引。有关详细信息,请参阅
BlipProcessor.__call__()
。 - attention_mask (
tf.Tensor
形状(batch_size, sequence_length)
, 可选) — 避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]
范围内:- 对于 未掩码 的标记,为 1;
- 对于 掩码 的标记,为 0。
- position_ids (
tf.Tensor
形状(batch_size, sequence_length)
, 可选) — 每个输入序列标记在位置嵌入中的位置索引。选择在范围[0, config.max_position_embeddings - 1]
内。 - output_attentions (
bool
, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions
。 - output_hidden_states (
bool
, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
。 - return_dict (
bool
, 可选) — 是否返回 ModelOutput 而不是普通元组。
返回
text_features (tf.Tensor
的形状为 (batch_size, output_dim)
)
将 TFBlipTextModel 的池化输出应用投影层得到的文本嵌入。
TFBlipModel 的前向方法重写了 __call__
特殊方法。
尽管需要在此函数中定义前进传递的配方,但之后应调用该 Module
实例,而不是此实例,因为前者负责执行预和后处理步骤,而后者则默默忽略它们。
示例
>>> from transformers import AutoProcessor, TFBlipModel
>>> model = TFBlipModel.from_pretrained("Salesforce/blip-image-captioning-base")
>>> processor = AutoProcessor.from_pretrained("Salesforce/blip-image-captioning-base")
>>> inputs = processor(text=["a photo of a cat", "a photo of a dog"], padding=True, return_tensors="tf")
>>> text_features = model.get_text_features(**inputs)
get_image_features
< source >( pixel_values: tf.Tensor | None = None return_dict: Optional[bool] = None ) → image_features (tf.Tensor
of shape (batch_size, output_dim
)
参数
- pixel_values (
tf.Tensor
of shape(batch_size, num_channels, height, width)
) — 像素值。提供填充值时默认忽略填充。可使用 BlipImageProcessor 获取像素值。详细信息请见 BlipImageProcessor.call()。 - output_attentions (
bool
, 可选) - 是否返回所有注意力层的注意力张量。关于返回的张量下的更多信息,请见attentions
。 - output_hidden_states (
bool
, 可选) - 是否返回所有层的隐藏状态。关于返回的张量下的更多信息,请见hidden_states
。 - return_dict (
bool
, 可选) - 是否返回 ModelOutput 而不是普通元组。
返回
image_features (tf.Tensor
,形状为 (batch_size, output_dim
)
应用投影层到 TFBlipVisionModel 的池化输出所获得图像嵌入。
TFBlipModel 的前向方法重写了 __call__
特殊方法。
尽管需要在此函数中定义前进传递的配方,但之后应调用该 Module
实例,而不是此实例,因为前者负责执行预和后处理步骤,而后者则默默忽略它们。
示例
>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, TFBlipModel
>>> model = TFBlipModel.from_pretrained("Salesforce/blip-image-captioning-base")
>>> processor = AutoProcessor.from_pretrained("Salesforce/blip-image-captioning-base")
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> inputs = processor(images=image, return_tensors="tf")
>>> image_features = model.get_image_features(**inputs)
TFBlipTextModel
该模型既可以作为编码器(仅自注意力)使用,也可以作为解码器使用。在这种情况下,在每个自注意力层之间添加一层交叉注意力层,其架构遵循由Ashish Vaswani、Noam Shazeer、Niki Parmar、Jakob Uszkoreit、Llion Jones、Aidan N. Gomez、Lukasz Kaiser和Illia Polosukhin描述的《注意力就是你需要的所有》。将is_decoder
设置为True
;正向传输时则期望输入encoder_hidden_states
。
调用
< source >参数
- attention_mask (
tf.Tensor
of shape(batch_size, sequence_length)
, 可选) — 避免对所有填充token索引执行注意力操作的掩码。掩码值在[0, 1]
之间:- 1 对于未掩码的token:
- 0 对于已掩码的token。
- position_ids (
tf.Tensor
of shape(batch_size, sequence_length)
, 可选) — 每个输入序列token位置嵌入的索引。在范围[0, config.max_position_embeddings - 1]
内选择。 - output_attentions (
bool
, 可选) — 是否返回所有注意力层的注意力张量。更多详情请参阅返回张量中的attentions
。 - output_hidden_states (
bool
, 可选) —— 是否返回所有层的隐藏状态。更多信息请参阅返回的的张量下的hidden_states
。 - return_dict (
bool
, 可选) —— 是否返回一个 ModelOutput 而不是一个普通的元组。 - encoder_hidden_states (
tf.Tensor
, 可选) —— 编码器最后一层的隐藏状态的序列。在模型配置为解码器时用于交叉注意力。 - encoder_attention_mask (
tf.Tensor
,可选) — 用于避免对编码器输入中的填充标记索引执行注意力的掩码。如果模型配置为解码器,则会使用此掩码进行交叉注意力。掩码值选中[0, 1]
:- 1 对应于 未掩码 的标记,
- 0 对应于 掩码 的标记。
- past_key_values (
tuple(tuple(tf.Tensor))
,可选) — 包含注意力块预先计算的关键和值隐藏状态。可以用于加速解码。如果使用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
)。
TFBlipTextModel 的 forward 方法覆盖了 __call__
特殊方法。
尽管需要在此函数中定义前进传递的配方,但之后应调用该 Module
实例,而不是此实例,因为前者负责执行预和后处理步骤,而后者则默默忽略它们。
TFBlipVisionModel
调用
< 源代码 >( pixel_values: tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: Optional[bool] = None ) → transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling or tuple(tf.Tensor)
参数
- pixel_values (
tf.Tensor
of shape(batch_size, num_channels, height, width)
) — 像素值。如果提供了填充,则默认会忽略填充。您可以使用 BlipImageProcessor 来获取像素值。有关详细信息,请参阅 BlipImageProcessor.call()。 - output_attentions (
bool
, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回 tensor 下的attentions
。 - output_hidden_states (
bool
, optional) —— 是否返回所有层的隐藏状态。有关详细信息,请参阅返回张量下的hidden_states
。 - return_dict (
bool
, optional) —— 是否返回ModelOutput而不是普通元组。
返回
transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling 或 tuple(tf.Tensor)
A transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling 或一个包含 tf.Tensor
的元组(如果传递了 return_dict=False
或当 config.return_dict=False
)各种元素取决于配置(<class 'transformers.models.blip.configuration_blip.BlipVisionConfig'>
)和输入。
-
last_hidden_state (
tf.Tensor
的形状为(batch_size, sequence_length, hidden_size)
) —— 模型最后一层的输出中的隐藏状态序列。 -
pooler_output (
tf.Tensor
的形状为(batch_size, hidden_size)
) —— 序列中第一个标记的最后一层隐藏状态(分类标记),通过线性层和Tanh激活函数进一步处理。线性层的权重是从预训练时的下一个句子预测(分类)目标训练得到的。此输出通常 不是 输入语义内容的良好摘要,通常更好的做法是对整个输入序列的隐藏状态序列进行平均或池化。
-
hidden_states (
tuple(tf.Tensor)
,optional,在传递output_hidden_states=True
时返回或当config.output_hidden_states=True
时返回) —— 一个形如(batch_size, sequence_length, hidden_size)
的tf.Tensor
的元组(一个用于嵌入输出的输出,一个用于每层的输出)。模型在每个层输出的隐藏状态以及初始嵌入输出。
-
attentions (
tuple(tf.Tensor)
,optional,在传递output_attentions=True
时返回或当config.output_attentions=True
时返回) —— 一个形状为(batch_size, num_heads, sequence_length, sequence_length)
的tf.Tensor
的元组(每个层一个)。注意力softmax后的注意力权重,用于计算自注意力头中的加权和。
TFBlipVisionModel向前方法,覆盖了__call__
特殊方法。
尽管需要在此函数中定义前进传递的配方,但之后应调用该 Module
实例,而不是此实例,因为前者负责执行预和后处理步骤,而后者则默默忽略它们。
TFBlipForConditionalGeneration
类 transformers.TFBlipForConditionalGeneration
< 来源 >( config: BlipConfig *args **kwargs )
参数
- config (BlipConfig) — 模型参数的配置类。用配置文件初始化不会加载与模型相关的权重,仅加载配置。查看from_pretrained()方法来加载模型权重。
BLIP 图像标题模型。该模型由视觉编码器和文本解码器组成。可以可选地传入 input_ids
到模型中,作为文本提示,以便让文本解码器继续提示。否则,解码器将从 [BOS](序列开头)标记开始生成文本。将从文本输入开始生成标题。如果没有提供文本输入,解码器将只使用 [BOS] 标记开始。
该模型继承自 TFPreTrainedModel。查看超类文档,了解库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、修剪头等)。
此模型还属于 keras.Model 的子类。将其作为常规的 TF 2.0 Keras 模型使用,并参考 TF 2.0 文档了解所有与通用用法和行为相关的事项。
调用
< 源代码 >( pixel_values: tf.Tensor input_ids: tf.Tensor | None = None attention_mask: tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None labels: tf.Tensor | None = None return_dict: Optional[bool] = None training: Optional[bool] = None ) → transformers.models.blip.modeling_tf_blip.TFBlipForConditionalGenerationModelOutput
或 tuple(tf.Tensor)
参数
- return_dict (
bool
, 可选) — 是否返回ModelOutput而不是普通元组。
返回
transformers.models.blip.modeling_tf_blip.TFBlipForConditionalGenerationModelOutput
或tuple(tf.Tensor)
一个transformers.models.blip.modeling_tf_blip.TFBlipForConditionalGenerationModelOutput
或一个包含各种元素的tf.Tensor
的元组(如果传递了return_dict=False
或当config.return_dict=False
时),这些元素取决于配置(<class 'transformers.models.blip.configuration_blip.BlipConfig'>
)和输入。
-
loss (
tf.Tensor
, 可选,当提供labels
时返回,形状为(1,)
的tf.Tensor
)— 文本解码器中的语言建模损失。 -
logits (
tf.Tensor
的形状为(batch_size, sequence_length, config.vocab_size)
,可选) — 文本解码器模型语言建模头部的预测分数。 -
image_embeds (
tf.Tensor
的形状为(batch_size, output_dim)
,可选) — 将视觉Transformer模型应用于输入图像后获得图像嵌入。 -
last_hidden_state (
tf.Tensor
的形状为(batch_size, sequence_length, hidden_size)
,可选) — 模型最后一层的输出隐藏状态序列。 -
hidden_states (
tuple(tf.Tensor)
,可选,当返回output_hidden_states=True
时返回) — 包含形状为(batch_size, sequence_length, hidden_size)
的tf.Tensor
的元组(如果模型有嵌入层,则一个用于嵌入输出的,一个用于每个层的输出)。每个层的模型输出隐藏状态以及可选的初始嵌入输出。
-
attentions (
tuple(tf.Tensor)
,可选,当传递output_attentions=True
时返回) — 包含形状为(batch_size, num_heads, sequence_length, sequence_length)
的tf.Tensor
的元组(每个层一个)。注意力软化的权重,用于在自注意力头部计算加权平均值。
TFBlipForConditionalGeneration的前向方法覆盖了__call__
特殊方法。
尽管需要在此函数中定义前进传递的配方,但之后应调用该 Module
实例,而不是此实例,因为前者负责执行预和后处理步骤,而后者则默默忽略它们。
示例
>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, TFBlipForConditionalGeneration
>>> processor = AutoProcessor.from_pretrained("Salesforce/blip-image-captioning-base")
>>> model = TFBlipForConditionalGeneration.from_pretrained("Salesforce/blip-image-captioning-base")
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> text = "A picture of"
>>> inputs = processor(images=image, text=text, return_tensors="tf")
>>> outputs = model(**inputs)
TFBlipForImageTextRetrieval
类 transformers.TFBlipForImageTextRetrieval
< source >( config: BlipConfig *args **kwargs )
参数
- config (BlipConfig) — 模型配置类,包含所有模型参数。使用配置文件初始化不会加载与模型关联的权重,只加载配置。请参阅 from_pretrained() 方法来加载模型权重。
具有视觉和文本投影仪以及顶部分类头的BLIP模型。该模型用于图像-文本检索的上下文中。给定一张图片和一段文本,模型返回文本与图片相关性的概率。
该模型继承自 TFPreTrainedModel。查看超类文档,了解库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、修剪头等)。
此模型还属于 keras.Model 的子类。将其作为常规的 TF 2.0 Keras 模型使用,并参考 TF 2.0 文档了解所有与通用用法和行为相关的事项。
调用
< source >( input_ids: tf.Tensor pixel_values: tf.Tensor | None = None use_itm_head: Optional[bool] = True attention_mask: tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: Optional[bool] = None ) → transformers.models.blip.modeling_tf_blip.TFBlipImageTextMatchingModelOutput
或 tuple(tf.Tensor)
参数
- pixel_values (
tf.Tensor
的shape为(batch_size, num_channels, height, width)
) — 像素值。如果提供,默认将忽略填充。可以通过 BlipImageProcessor 获取像素值。有关详细信息,请参阅 BlipImageProcessor.call()。 - output_attentions (
bool
,可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions
。 - output_hidden_states (
bool
, 可选) — 是否返回所有层的隐藏状态。更详细的说明见返回张量下的hidden_states
。 - return_dict (
bool
, 可选) — 是否返回 ModelOutput 而不是普通元组。
返回
transformers.models.blip.modeling_tf_blip.TFBlipImageTextMatchingModelOutput
或 tuple(tf.Tensor)
A transformers.models.blip.modeling_tf_blip.TFBlipImageTextMatchingModelOutput
或一个包含各种元素(根据配置 <class 'transformers.models.blip.configuration_blip.BlipVisionConfig'>
和输入)的 tf.Tensor
元组(如果传递了 return_dict=False
或 config.return_dict=False
)。
-
itm_score (
tf.Tensor
) — 图像-文本相似度得分。 -
loss (
tf.Tensor
形状为(1,)
,可选,当提供labels
时返回) — 来自文本解码器的语言模型损失。 -
image_embeds (
tf.Tensor
形状为(batch_size, output_dim)
,可选,当模型以with_projection=True
初始化时返回) — 对 pooler_output 应用投影层后获得的图像嵌入。 -
last_hidden_state (
tf.Tensor
的形状为(batch_size, sequence_length, hidden_size)
) —— 模型最后一层的输出中的隐藏状态序列。 -
hidden_states (
tuple(tf.Tensor)
,可选,当传递output_hidden_states=True
时返回或当config.output_hidden_states=True
时返回) — 一个tf.Tensor
的元组(如果模型有嵌入层,则为嵌入层的输出 + 每层的输出)的形状为(batch_size, sequence_length, hidden_size)
。每个层的模型输出隐藏状态以及可选的初始嵌入输出。
-
vision_pooler_output (
tf.Tensor
形状为(batch_size, hidden_size)
,可选) — 模型视觉分支最后层的隐藏状态。 -
attentions (
tuple(tf.Tensor)
,optional,在传递output_attentions=True
时返回或当config.output_attentions=True
时返回) —— 一个形状为(batch_size, num_heads, sequence_length, sequence_length)
的tf.Tensor
的元组(每个层一个)。注意力softmax后的注意力权重,用于计算自注意力头中的加权和。
-
question_embeds (
tf.Tensor
) — 通过文本投影层获得的疑问嵌入。
TFBlipForImageTextRetrieval 的前进方法覆盖了 __call__
特殊方法。
尽管需要在此函数中定义前进传递的配方,但之后应调用该 Module
实例,而不是此实例,因为前者负责执行预和后处理步骤,而后者则默默忽略它们。
示例
>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, TFBlipForImageTextRetrieval
>>> model = TFBlipForImageTextRetrieval.from_pretrained("Salesforce/blip-itm-base-coco")
>>> processor = AutoProcessor.from_pretrained("Salesforce/blip-itm-base-coco")
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> text = "an image of a cat"
>>> inputs = processor(images=image, text=text, return_tensors="tf")
>>> outputs = model(**inputs)
TFBlipForQuestionAnswering
类 transformers.TFBlipForQuestionAnswering
< 源代码 >( config: BlipConfig *args **kwargs )
参数
- config (BlipConfig) — 模型配置类,包含所有模型参数。使用配置文件初始化时,不会加载模型对应的权重,只会加载配置信息。请查看 from_pretrained() 方法以加载模型权重。
BLIP 图像问答模型。该模型由图像编码器、文本编码器和文本解码器组成。图像编码器将输入图像进行编码,文本编码器将输入问题及其编码的图像一同编码,文本解码器将输出问题的答案。
该模型继承自 TFPreTrainedModel。查看超类文档,了解库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、修剪头等)。
此模型还属于 keras.Model 的子类。将其作为常规的 TF 2.0 Keras 模型使用,并参考 TF 2.0 文档了解所有与通用用法和行为相关的事项。
调用
< 源代码 >( input_ids: tf.Tensor pixel_values: tf.Tensor | None = None decoder_input_ids: tf.Tensor | None = None decoder_attention_mask: tf.Tensor | None = None attention_mask: tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None labels: tf.Tensor | None = None return_dict: Optional[bool] = None training: Optional[bool] = None ) → transformers.models.blip.modeling_tf_blip.TFBlipTextVisionModelOutput
or tuple(tf.Tensor)
参数
- pixel_values (
tf.Tensor
of shape(batch_size, num_channels, height, width)
) — 像素值。如果你提供填充,默认将忽略它。可以使用 BlipImageProcessor 获取像素值。有关详细信息,请参阅 BlipImageProcessor.调用()。 - output_attentions (
bool
, 可选) — 是否返回所有注意力的张量。有关详细信息,请参阅返回张量下的attentions
。 - output_hidden_states (
bool
, 可选) — 是否返回所有层的隐藏状态。有关详细信息,请参阅返回张量下的hidden_states
。 - return_dict (
bool
, 可选) — 是否返回一个 ModelOutput 而不是普通的元组。
返回
transformers.models.blip.modeling_tf_blip.TFBlipTextVisionModelOutput
或 tuple(tf.Tensor)
A transformers.models.blip.modeling_tf_blip.TFBlipTextVisionModelOutput
或一个包含各种元素的 tf.Tensor
元组(如果通过 return_dict=False
或当 config.return_dict=False
传递时),这取决于配置(<class 'transformers.models.blip.configuration_blip.BlipVisionConfig'>
)和输入。
-
loss (
tf.Tensor
形状为(1,)
,可选,当提供labels
时返回) — 来自文本解码器的语言模型损失。 -
image_embeds (
tf.Tensor
形状为(batch_size, output_dim)
,可选,当模型以with_projection=True
初始化时返回) — 对 pooler_output 应用投影层后获得的图像嵌入。 -
last_hidden_state (
tf.Tensor
的形状为(batch_size, sequence_length, hidden_size)
) —— 模型最后一层的输出中的隐藏状态序列。 -
hidden_states (
tuple(tf.Tensor)
,可选,当传递output_hidden_states=True
时返回或当config.output_hidden_states=True
时返回) — 一个tf.Tensor
的元组(如果模型有嵌入层,则为嵌入层的输出 + 每层的输出)的形状为(batch_size, sequence_length, hidden_size)
。每个层的模型输出隐藏状态以及可选的初始嵌入输出。
-
attentions (
tuple(tf.Tensor)
,optional,在传递output_attentions=True
时返回或当config.output_attentions=True
时返回) —— 一个形状为(batch_size, num_heads, sequence_length, sequence_length)
的tf.Tensor
的元组(每个层一个)。注意力softmax后的注意力权重,用于计算自注意力头中的加权和。
TFBlipForQuestionAnswering 的向前方法,覆盖了 __call__ 特殊方法。
尽管需要在此函数中定义前进传递的配方,但之后应调用该 Module
实例,而不是此实例,因为前者负责执行预和后处理步骤,而后者则默默忽略它们。
示例
>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, TFBlipForQuestionAnswering
>>> model = TFBlipForQuestionAnswering.from_pretrained("Salesforce/blip-vqa-base")
>>> processor = AutoProcessor.from_pretrained("Salesforce/blip-vqa-base")
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> # training
>>> text = "How many cats are in the picture?"
>>> label = "2"
>>> inputs = processor(images=image, text=text, return_tensors="tf")
>>> labels = processor(text=label, return_tensors="tf").input_ids
>>> inputs["labels"] = labels
>>> outputs = model(**inputs)
>>> loss = outputs.loss
>>> # inference
>>> text = "How many cats are in the picture?"
>>> inputs = processor(images=image, text=text, return_tensors="tf")
>>> outputs = model.generate(**inputs)
>>> print(processor.decode(outputs[0], skip_special_tokens=True))
2