Transformers 文档
BLIP
并获得增强的文档体验
开始使用
BLIP
BLIP (Bootstrapped Language-Image Pretraining) 是一个视觉语言预训练 (VLP) 框架,专为理解和生成任务而设计。现有的大多数预训练模型在这两方面都表现平平。它使用一个字幕生成器生成字幕,并使用一个过滤器去除嘈杂的字幕。这提高了训练数据的质量,并更有效地利用了杂乱的网络数据。
你可以在 BLIP 集合中找到所有原始的 BLIP 检查点。
此模型由 ybelkada 贡献。
点击右侧边栏中的 BLIP 模型,了解更多如何将 BLIP 应用于不同视觉语言任务的示例。
以下示例演示了如何使用 Pipeline 或 AutoModel 类进行视觉问答。
import torch
from transformers import pipeline
pipeline = pipeline(
task="visual-question-answering",
model="Salesforce/blip-vqa-base",
torch_dtype=torch.float16,
device=0
)
url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"
pipeline(question="What is the weather in this image?", image=url)
资源
请参阅此 笔记本,了解如何在自定义数据集上微调 BLIP 进行图像字幕生成。
BlipConfig
class 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 )
参数
- text_config (
dict
, 可选) — 用于初始化 BlipTextConfig 的配置选项字典。 - 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 (float, 可选, 默认为 0.0) — [0.0, 1.0] 范围内的浮点数。指定计算损失时的平滑量,其中 0.0 表示不平滑。目标将成为原始真实值和均匀分布的混合,如
重新思考计算机视觉的 Inception 架构 <https://huggingface.co/papers/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
class transformers.BlipTextConfig
< 来源 >( vocab_size = 30524 hidden_size = 768 encoder_hidden_size = 768 intermediate_size = 3072 projection_dim = 768 num_hidden_layers = 12 num_attention_heads = 8 max_position_embeddings = 512 hidden_act = 'gelu' layer_norm_eps = 1e-12 hidden_dropout_prob = 0.0 attention_probs_dropout_prob = 0.0 initializer_range = 0.02 bos_token_id = 30522 eos_token_id = 2 pad_token_id = 0 sep_token_id = 102 is_decoder = True use_cache = True label_smoothing = 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 编码器中每个注意力层的注意力头数量。 - max_position_embeddings (
int
, 可选, 默认为 512) — 该模型可能使用的最大序列长度。通常设置为一个较大的值以防万一(例如,512、1024 或 2048)。 - hidden_act (
str
或function
, 可选, 默认为"gelu"
) — 编码器和池化器中的非线性激活函数(函数或字符串)。如果是字符串,支持"gelu"
、"relu"
、"selu"
和"gelu_new"
"gelu"
。 - layer_norm_eps (
float
, 可选, 默认为 1e-12) — 层归一化层使用的 epsilon。 - hidden_dropout_prob (
float
, 可选, 默认为 0.0) — 嵌入、编码器和池化器中所有全连接层的 dropout 概率。 - attention_dropout (
float
, 可选, 默认为 0.0) — 注意力概率的 dropout 比率。 - initializer_range (
float
, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态分布初始化器的标准差。 - 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
) — 模型是否应返回最后一个 key/values 注意力(并非所有模型都使用)。 - label_smoothing (float, 可选) — [0.0, 1.0] 范围内的浮点数。指定计算损失时的平滑量,其中 0.0 表示不平滑。目标将成为原始真实值和均匀分布的混合,如
重新思考计算机视觉的 Inception 架构 <https://huggingface.co/papers/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
class transformers.BlipVisionConfig
< 来源 >( 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"
"gelu"
。 - layer_norm_eps (
float
, 可选, 默认为 1e-5) — 层归一化层使用的 epsilon 值。 - attention_dropout (
float
, 可选, 默认为 0.0) — 注意力概率的 dropout 比率。 - initializer_range (
float
, 可选, 默认为 1e-10) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
这是用于存储 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
class transformers.BlipProcessor
< 源 >( image_processor tokenizer **kwargs )
参数
- image_processor (
BlipImageProcessor
) — BlipImageProcessor 的实例。图像处理器是必需输入。 - tokenizer (
BertTokenizerFast
) — [‘BertTokenizerFast`] 的实例。分词器是必需输入。
构建一个 BLIP 处理器,它将 BERT 分词器和 BLIP 图像处理器封装到一个单一的处理器中。
BlipProcessor 提供了 BlipImageProcessor 和 BertTokenizerFast 的所有功能。有关更多信息,请参阅 __call__()
和 decode() 的文档字符串。
此方法将其所有参数转发给 BertTokenizerFast 的 batch_decode()。请参阅此方法的文档字符串以获取更多信息。
BlipImageProcessor
class transformers.BlipImageProcessor
< 源 >( do_resize: bool = True size: typing.Optional[dict[str, int]] = None resample: Resampling = <Resampling.BICUBIC: 3> do_rescale: bool = True rescale_factor: typing.Union[int, float] = 0.00392156862745098 do_normalize: bool = True image_mean: typing.Union[float, list[float], NoneType] = None image_std: typing.Union[float, list[float], NoneType] = 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
, 可选, 默认为True
) — 是否归一化图像。可以通过preprocess
方法中的do_normalize
参数覆盖。 - image_mean (
float
或list[float]
, 可选, 默认为IMAGENET_STANDARD_MEAN
) — 如果归一化图像,则使用的均值。这是一个浮点数或浮点数列表,其长度与图像中的通道数相同。可以通过preprocess
方法中的image_mean
参数覆盖。 - image_std (
float
或list[float]
, 可选, 默认为IMAGENET_STANDARD_STD
) — 如果归一化图像,则使用的标准差。这是一个浮点数或浮点数列表,其长度与图像中的通道数相同。可以通过preprocess
方法中的image_std
参数覆盖。 - do_convert_rgb (
bool
, 可选, 默认为True
) — 是否将图像转换为 RGB。
构建 BLIP 图像处理器。
preprocess
< 源 >( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']] do_resize: typing.Optional[bool] = None size: typing.Optional[dict[str, int]] = None resample: Resampling = None do_rescale: typing.Optional[bool] = None rescale_factor: typing.Optional[float] = None do_normalize: typing.Optional[bool] = None image_mean: typing.Union[float, list[float], NoneType] = None image_std: typing.Union[float, list[float], NoneType] = None return_tensors: typing.Union[str, transformers.utils.generic.TensorType, NoneType] = None do_convert_rgb: typing.Optional[bool] = None data_format: ChannelDimension = <ChannelDimension.FIRST: 'channels_first'> input_data_format: typing.Union[str, transformers.image_utils.ChannelDimension, NoneType] = 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
批次。
- 未设置:返回
- data_format (
ChannelDimension
或str
, 可选, 默认为ChannelDimension.FIRST
) — 输出图像的通道维度格式。可以是以下之一:"channels_first"
或ChannelDimension.FIRST
:图像格式为 (num_channels, height, width)。"channels_last"
或ChannelDimension.LAST
:图像格式为 (height, width, num_channels)。- 未设置:使用输入图像的通道维度格式。
- input_data_format (
ChannelDimension
或str
, 可选) — 输入图像的通道维度格式。如果未设置,则从输入图像推断通道维度格式。可以是以下之一:"channels_first"
或ChannelDimension.FIRST
:图像格式为 (num_channels, height, width)。"channels_last"
或ChannelDimension.LAST
:图像格式为 (height, width, num_channels)。"none"
或ChannelDimension.NONE
:图像格式为 (height, width)。
预处理一张或一批图像。
BlipImageProcessorFast
class transformers.BlipImageProcessorFast
< 源 >( **kwargs: typing_extensions.Unpack[transformers.image_processing_utils_fast.DefaultFastImageProcessorKwargs] )
构建一个快速的 Blip 图像处理器。
preprocess
< 源 >( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']] *args **kwargs: typing_extensions.Unpack[transformers.image_processing_utils_fast.DefaultFastImageProcessorKwargs] ) → <class 'transformers.image_processing_base.BatchFeature'>
参数
- images (
Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]
) — 要预处理的图像。期望像素值范围为 0 到 255 的单个或批量图像。如果传入像素值在 0 到 1 之间的图像,请设置do_rescale=False
。 - do_resize (
bool
, 可选) — 是否调整图像大小。 - size (
dict[str, int]
, 可选) — 描述模型的最大输入维度。 - default_to_square (
bool
, 可选) — 当调整大小(如果`size`是整数)时是否默认使用方形图像。 - resample (
Union[PILImageResampling, F.InterpolationMode, NoneType]
) — 如果图像需要调整大小,则使用的重采样滤波器。这可以是枚举类型`PILImageResampling`中的一个。仅当`do_resize`设置为`True`时才有效。 - do_center_crop (
bool
, 可选) — 是否对图像进行中心裁剪。 - crop_size (
dict[str, int]
, 可选) — 应用`center_crop`后输出图像的大小。 - do_rescale (
bool
, 可选) — 是否对图像进行缩放。 - rescale_factor (
Union[int, float, NoneType]
) — 如果`do_rescale`设置为`True`,则用于缩放图像的缩放因子。 - do_normalize (
bool
, 可选) — 是否对图像进行归一化。 - image_mean (
Union[float, list[float], NoneType]
) — 用于归一化的图像平均值。仅当`do_normalize`设置为`True`时才有效。 - image_std (
Union[float, list[float], NoneType]
) — 用于归一化的图像标准差。仅当`do_normalize`设置为`True`时才有效。 - do_convert_rgb (
bool
, 可选) — 是否将图像转换为RGB格式。 - return_tensors (
Union[str, ~utils.generic.TensorType, NoneType]
) — 如果设置为`pt`,则返回堆叠的张量,否则返回张量列表。 - data_format (
~image_utils.ChannelDimension
, 可选) — 仅支持`ChannelDimension.FIRST`。为了与慢速处理器兼容而添加。 - input_data_format (
Union[str, ~image_utils.ChannelDimension, NoneType]
) — 输入图像的通道维度格式。如果未设置,则从输入图像推断通道维度格式。可以是以下之一:- `"channels_first"` 或 `ChannelDimension.FIRST`:图像格式为 (通道数, 高度, 宽度)。
- `"channels_last"` 或 `ChannelDimension.LAST`:图像格式为 (高度, 宽度, 通道数)。
- `"none"` 或 `ChannelDimension.NONE`:图像格式为 (高度, 宽度)。
- device (
torch.device
, 可选) — 处理图像的设备。如果未设置,则从输入图像推断设备。 - disable_grouping (
bool
, 可选) — 是否禁用按大小对图像进行分组,以单独而不是批量处理它们。如果为None,则如果图像在CPU上,则设置为True,否则设置为False。此选择基于经验观察,详情请见: https://github.com/huggingface/transformers/pull/38157
返回
<class 'transformers.image_processing_base.BatchFeature'>
- data (
dict
) — 由 call 方法返回的列表/数组/张量字典(“pixel_values”等)。 - tensor_type (
Union[None, str, TensorType]
, 可选) — 您可以在此处提供一个`tensor_type`,以便在初始化时将整数列表转换为PyTorch/TensorFlow/Numpy张量。
BlipModel
BlipModel将在未来版本中被弃用,请根据您的用例使用BlipForConditionalGeneration、BlipForImageTextRetrieval或BlipForQuestionAnswering。
class transformers.BlipModel
< 源 >( config: BlipConfig )
参数
- config (BlipConfig) — 包含模型所有参数的模型配置类。用配置文件初始化不会加载与模型相关的权重,只加载配置。请查阅 from_pretrained() 方法来加载模型权重。
此模型将在未来版本中被弃用。请根据您的用例使用`BlipForConditionalGeneration`、`BlipForQuestionAnswering`或`BlipForImageTextRetrieval`。
此模型继承自 PreTrainedModel。请查阅超类文档以了解库为其所有模型实现的一般方法(例如下载或保存、调整输入嵌入大小、修剪头等)。
此模型也是 PyTorch torch.nn.Module 子类。请将其作为常规 PyTorch 模块使用,并参阅 PyTorch 文档以了解所有与一般用法和行为相关的事项。
forward
< 源 >( input_ids: typing.Optional[torch.LongTensor] = None pixel_values: typing.Optional[torch.FloatTensor] = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.LongTensor] = None return_loss: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None interpolate_pos_encoding: bool = False ) → transformers.models.blip.modeling_blip.BlipOutput
or tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor
, 形状为(batch_size, sequence_length)
, 可选) — 词汇表中输入序列标记的索引。填充默认会被忽略。可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- pixel_values (
torch.FloatTensor
, 形状为(batch_size, num_channels, image_size, image_size)
, 可选) — 与输入图像对应的张量。像素值可以使用{image_processor_class}
获取。有关详细信息,请参阅{image_processor_class}.__call__
({processor_class}
使用{image_processor_class}
处理图像)。 - attention_mask (
torch.Tensor
, 形状为(batch_size, sequence_length)
, 可选) — 避免对填充标记索引执行注意力操作的掩码。掩码值选择范围为[0, 1]
:- 1 表示 未被掩盖 的标记,
- 0 表示 被掩盖 的标记。
- position_ids (
torch.LongTensor
, 形状为(batch_size, sequence_length)
, 可选) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.n_positions - 1]
。 - 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)
一个`transformers.models.blip.modeling_blip.BlipOutput`或一个`torch.FloatTensor`元组(如果传入`return_dict=False`或`config.return_dict=False`),其中包含根据配置(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 (
<class '~modeling_outputs.BaseModelOutputWithPooling'>.text_model_output
, 默认为None
) — BlipTextModel 的输出。 - vision_model_output (
<class '~modeling_outputs.BaseModelOutputWithPooling'>.vision_model_output
, 默认为None
) — 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
< 源 >( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.Tensor] = None return_dict: typing.Optional[bool] = None ) → text_features (torch.FloatTensor
, 形状为 (batch_size, output_dim
)
参数
- input_ids (
torch.Tensor
, 形状为(batch_size, sequence_length)
, 可选) — 词汇表中输入序列标记的索引。填充默认会被忽略。可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor
, 形状为(batch_size, sequence_length)
, 可选) — 避免对填充标记索引执行注意力操作的掩码。掩码值选择范围为[0, 1]
:- 1 表示 未被掩盖 的标记,
- 0 表示 被掩盖 的标记。
- position_ids (
torch.Tensor
, 形状为(batch_size, sequence_length)
, 可选) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.n_positions - 1]
。 - return_dict (
bool
, 可选) — 是否返回 ModelOutput 而不是普通元组。
返回
text_features (torch.FloatTensor
, 形状为 (batch_size, output_dim
)
通过对 BlipTextModel 的池化输出应用投影层获得的文本嵌入。
示例
>>> 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
< 源 >( pixel_values: typing.Optional[torch.FloatTensor] = None return_dict: typing.Optional[bool] = None interpolate_pos_encoding: bool = False ) → image_features (torch.FloatTensor
, 形状为 (batch_size, output_dim
)
参数
- pixel_values (
torch.FloatTensor
, 形状为(batch_size, num_channels, image_size, image_size)
, 可选) — 与输入图像对应的张量。像素值可以使用{image_processor_class}
获取。有关详细信息,请参阅{image_processor_class}.__call__
({processor_class}
使用{image_processor_class}
处理图像)。 - return_dict (
bool
, 可选) — 是否返回 ModelOutput 而不是普通元组。 - interpolate_pos_encoding (
bool
, 默认为False
) — 是否对预训练的位置编码进行插值。
返回
image_features (torch.FloatTensor
, 形状为 (batch_size, output_dim
)
通过对 BlipVisionModel 的池化输出应用投影层获得的图像嵌入。
示例
>>> 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 和 Illia Polosukhin 的《Attention is all you need》中描述的架构。参数和`is_decoder`设置为`True`;然后期望`encoder_hidden_states`作为前向传播的输入。
forward
< 源 >( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None encoder_embeds: typing.Optional[torch.Tensor] = None encoder_hidden_states: typing.Optional[torch.Tensor] = None encoder_attention_mask: typing.Optional[torch.Tensor] = None past_key_values: typing.Optional[list[torch.FloatTensor]] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None is_decoder: typing.Optional[bool] = False )
encoder_hidden_states (torch.FloatTensor
, 可选): 编码器最后一层输出的隐藏状态序列。如果模型配置为解码器,则在交叉注意力中使用。encoder_attention_mask (torch.FloatTensor
, 可选): 避免对编码器输入中的填充标记索引执行注意力操作的掩码。如果模型配置为解码器,则在交叉注意力中使用此掩码。掩码值选择范围为 [0, 1]
- 1 表示 未被掩盖 的标记,
- 0 表示 被掩盖 的标记。past_key_values (
tuple(tuple(torch.FloatTensor))
, 可选): 包含注意力块的预计算键和值隐藏状态。可用于加速解码。如果使用`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`)。
BlipTextLMHeadModel
forward
< 源 >( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None encoder_hidden_states: typing.Optional[torch.Tensor] = None encoder_attention_mask: typing.Optional[torch.Tensor] = None labels: typing.Optional[torch.Tensor] = None past_key_values: typing.Optional[list[torch.Tensor]] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None return_logits: typing.Optional[bool] = False is_decoder: typing.Optional[bool] = True reduction: typing.Optional[str] = 'mean' )
encoder_hidden_states (torch.FloatTensor
, 可选): 编码器最后一层输出的隐藏状态序列。如果模型配置为解码器,则在交叉注意力中使用。encoder_attention_mask (torch.FloatTensor
, 可选): 避免对编码器输入中的填充标记索引执行注意力操作的掩码。如果模型配置为解码器,则在交叉注意力中使用此掩码。掩码值选择范围为 [0, 1]
- 1 表示 未被掩盖 的标记,
- 0 表示被 遮盖 的标记。labels (
torch.LongTensor
, 可选):用于计算从左到右语言建模损失(下一个词预测)的标签。索引应在[-100, 0, ..., config.vocab_size]
之间(参见input_ids
文档字符串)。索引设置为-100
的标记将被忽略(遮盖),损失仅针对标签为[0, ..., config.vocab_size]
的标记计算。past_key_values (tuple(tuple(torch.FloatTensor))
, 可选):包含注意力块预先计算好的键和值隐藏状态。可用于加速解码。如果使用了past_key_values
,用户可以选择仅输入形状为(batch_size, 1)
的最后一个decoder_input_ids
(那些没有将过去的键值状态提供给此模型的)而不是形状为(batch_size, sequence_length)
的所有decoder_input_ids
。use_cache (bool
, 可选):如果设置为True
,将返回past_key_values
键值状态,可用于加速解码(参见past_key_values
)。
- forward
BlipVisionModel
forward
< source >( pixel_values: typing.Optional[torch.FloatTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None interpolate_pos_encoding: bool = False ) → transformers.modeling_outputs.BaseModelOutputWithPooling 或 tuple(torch.FloatTensor)
参数
- pixel_values (形状为
(batch_size, num_channels, image_size, image_size)
的torch.FloatTensor
,可选) — 对应于输入图像的张量。像素值可以使用{image_processor_class}
获得。有关详细信息,请参见{image_processor_class}.__call__
({processor_class}
使用{image_processor_class}
处理图像)。 - 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)
一个 transformers.modeling_outputs.BaseModelOutputWithPooling 或一个 torch.FloatTensor
元组(如果传入 return_dict=False
或 config.return_dict=False
时),包含根据配置 (BlipConfig) 和输入的不同元素。
-
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 后的注意力权重,用于计算自注意力头中的加权平均值。
BlipVisionModel 的 forward 方法,覆盖了 __call__
特殊方法。
尽管前向传播的实现需要在该函数中定义,但随后应该调用`Module`实例而不是此函数,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
BlipForConditionalGeneration
class transformers.BlipForConditionalGeneration
< source >( config: BlipConfig )
参数
- config (BlipConfig) — 模型配置类,包含模型的所有参数。使用配置文件初始化不加载与模型关联的权重,只加载配置。请查看 from_pretrained() 方法加载模型权重。
用于图像字幕生成的 BLIP 模型。该模型由视觉编码器和文本解码器组成。可以选择将 input_ids
传递给模型作为文本提示,使文本解码器继续该提示。否则,解码器将从 [BOS] (序列开始) 标记开始生成文本。如果没有提供文本输入,解码器将只从 [BOS] 标记开始。
此模型继承自 PreTrainedModel。请查阅超类文档以了解库为其所有模型实现的一般方法(例如下载或保存、调整输入嵌入大小、修剪头等)。
此模型也是 PyTorch torch.nn.Module 子类。请将其作为常规 PyTorch 模块使用,并参阅 PyTorch 文档以了解所有与一般用法和行为相关的事项。
forward
< source >( pixel_values: FloatTensor input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.LongTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None labels: typing.Optional[torch.LongTensor] = None return_dict: typing.Optional[bool] = None interpolate_pos_encoding: bool = False ) → transformers.models.blip.modeling_blip.BlipForConditionalGenerationModelOutput
或 tuple(torch.FloatTensor)
参数
- pixel_values (形状为
(batch_size, num_channels, image_size, image_size)
的torch.FloatTensor
) — 对应于输入图像的张量。像素值可以使用{image_processor_class}
获得。有关详细信息,请参见{image_processor_class}.__call__
({processor_class}
使用{image_processor_class}
处理图像)。 - input_ids (形状为
(batch_size, sequence_length)
的torch.LongTensor
,可选) — 词汇表中输入序列标记的索引。填充将默认被忽略。索引可以使用 AutoTokenizer 获取。有关详细信息,请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (形状为
(batch_size, sequence_length)
的torch.LongTensor
,可选) — 掩码,用于避免在填充标记索引上执行注意力。掩码值在[0, 1]
中选择:- 1 表示 未被掩码 的标记,
- 0 表示 被掩码 的标记。
- output_attentions (
bool
, 可选) — 是否返回所有注意力层的注意力张量。有关详细信息,请参阅返回张量下的attentions
。 - output_hidden_states (
bool
, 可选) — 是否返回所有层的隐藏状态。有关详细信息,请参阅返回张量下的hidden_states
。 - labels (形状为
(batch_size, sequence_length)
的torch.LongTensor
,可选) — 用于计算掩码语言建模损失的标签。索引应在[0, ..., config.vocab_size]
或 -100 之间(参见input_ids
文档字符串)。索引设置为-100
的标记将被忽略(掩码),损失仅针对标签在[0, ..., config.vocab_size]
中的标记计算。 - return_dict (
bool
, 可选) — 是否返回 ModelOutput 而不是普通元组。 - interpolate_pos_encoding (
bool
, 默认为False
) — 是否插值预训练的位置编码。
返回
transformers.models.blip.modeling_blip.BlipForConditionalGenerationModelOutput
或 tuple(torch.FloatTensor)
一个 transformers.models.blip.modeling_blip.BlipForConditionalGenerationModelOutput
或一个 torch.FloatTensor
元组(如果传入 return_dict=False
或 config.return_dict=False
时),包含根据配置 (BlipConfig) 和输入的不同元素。
-
loss (
torch.FloatTensor
, 可选,当提供labels
时返回,形状为(1,)
的torch.FloatTensor
) — 来自文本解码器的语言建模损失。 -
logits (形状为
(batch_size, sequence_length, config.vocab_size)
的torch.FloatTensor
, 可选) — 文本解码器模型语言建模头的预测分数。 -
image_embeds (形状为
(batch_size, output_dim)
的torch.FloatTensor
, 可选) — 在对输入图像应用 Vision Transformer 模型后获得的图像嵌入。 -
last_hidden_state (形状为
(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
, 可选,默认为None
) — 模型最后一层输出的隐藏状态序列。 -
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: typing.Optional[bool] = True attention_mask: typing.Optional[torch.LongTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None interpolate_pos_encoding: bool = False ) → transformers.models.blip.modeling_blip.BlipTextVisionModelOutput
或 tuple(torch.FloatTensor)
参数
- input_ids (形状为
(batch_size, sequence_length)
的torch.LongTensor
) — 词汇表中输入序列标记的索引。填充将默认被忽略。索引可以使用 AutoTokenizer 获取。有关详细信息,请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- pixel_values (形状为
(batch_size, num_channels, image_size, image_size)
的torch.FloatTensor
) — 对应于输入图像的张量。像素值可以使用{image_processor_class}
获得。有关详细信息,请参见{image_processor_class}.__call__
({processor_class}
使用{image_processor_class}
处理图像)。 - use_itm_head (
bool
, 可选,默认为True
) — 是否使用图像-文本匹配头。 - attention_mask (形状为
(batch_size, sequence_length)
的torch.LongTensor
,可选) — 掩码,用于避免在填充标记索引上执行注意力。掩码值在[0, 1]
中选择:- 1 表示 未被掩码 的标记,
- 0 表示 被掩码 的标记。
- output_attentions (
bool
, 可选) — 是否返回所有注意力层的注意力张量。有关详细信息,请参阅返回张量下的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
时),包含根据配置 (BlipConfig) 和输入的不同元素。
-
loss (形状为
(1,)
的torch.FloatTensor
,可选,当提供labels
时返回) — 来自文本解码器的语言建模损失。 -
image_embeds (形状为
(batch_size, output_dim)
的torch.FloatTensor
,可选,当模型以with_projection=True
初始化时返回) — 通过将投影层应用于 pooler_output 获得的图像嵌入。 -
last_hidden_state (形状为
(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
, 可选,默认为None
) — 模型最后一层输出的隐藏状态序列。 -
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
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每个层一个)。注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
BlipForImageTextRetrieval 的 forward 方法,覆盖了 __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
class transformers.BlipForQuestionAnswering
< source >( 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: typing.Optional[torch.LongTensor] = None decoder_attention_mask: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.LongTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None labels: typing.Optional[torch.LongTensor] = None return_dict: typing.Optional[bool] = None interpolate_pos_encoding: bool = False ) → transformers.models.blip.modeling_blip.BlipTextVisionModelOutput
或 tuple(torch.FloatTensor)
参数
- input_ids (形状为
(batch_size, sequence_length)
的torch.LongTensor
) — 词汇表中输入序列标记的索引。填充将默认被忽略。索引可以使用 AutoTokenizer 获取。有关详细信息,请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- pixel_values (形状为
(batch_size, num_channels, image_size, image_size)
的torch.FloatTensor
) — 对应于输入图像的张量。像素值可以使用{image_processor_class}
获得。有关详细信息,请参见{image_processor_class}.__call__
({processor_class}
使用{image_processor_class}
处理图像)。 - decoder_input_ids (形状为
(batch_size, target_sequence_length)
的torch.LongTensor
,可选) — 词汇表中解码器输入序列标记的索引。索引可以使用 AutoTokenizer 获取。有关详细信息,请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- decoder_attention_mask (形状为
(batch_size, target_sequence_length)
的torch.LongTensor
,可选) — 掩码,用于避免在某些标记索引上执行注意力。默认情况下,将使用因果掩码,以确保模型只能查看先前的输入以预测未来。 - attention_mask (
torch.LongTensor
,形状为(batch_size, sequence_length)
,可选) — 用于避免对填充标记索引执行注意力操作的掩码。掩码值选择范围为[0, 1]
:- 1 表示**未被掩码**的标记,
- 0 表示**被掩码**的标记。
- output_attentions (
bool
,可选) — 是否返回所有注意力层的注意力张量。更多详细信息请参阅返回张量下的attentions
。 - output_hidden_states (
bool
,可选) — 是否返回所有层的隐藏状态。更多详细信息请参阅返回张量下的hidden_states
。 - labels (
torch.LongTensor
,形状为(batch_size, sequence_length)
,可选) — 用于计算掩码语言建模损失的标签。索引应在[0, ..., config.vocab_size]
或 -100 之间(请参阅input_ids
文档字符串)。索引设置为-100
的标记将被忽略(掩码),损失仅针对标签在[0, ..., config.vocab_size]
范围内的标记计算。 - 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
时),包含根据配置 (BlipConfig) 和输入的不同元素。
-
loss (形状为
(1,)
的torch.FloatTensor
,可选,当提供labels
时返回) — 来自文本解码器的语言建模损失。 -
image_embeds (形状为
(batch_size, output_dim)
的torch.FloatTensor
,可选,当模型以with_projection=True
初始化时返回) — 通过将投影层应用于 pooler_output 获得的图像嵌入。 -
last_hidden_state (形状为
(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
, 可选,默认为None
) — 模型最后一层输出的隐藏状态序列。 -
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
时返回) — 形状为(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
调用
< source >( 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()。 - return_loss (
bool
,可选) — 是否返回对比损失。 - output_attentions (
bool
,可选) — 是否返回所有注意力层的注意力张量。更多详细信息请参阅返回张量下的attentions
。 - output_hidden_states (
bool
,可选) — 是否返回所有层的隐藏状态。更多详细信息请参阅返回张量下的hidden_states
。 - return_dict (
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 (
tf.Tensor
,形状为(1,)
,可选,当return_loss
为True
时返回) — 图像-文本相似度的对比损失。 - logits_per_image:(
tf.Tensor
,形状为(image_batch_size, text_batch_size)
) —image_embeds
和text_embeds
之间的缩放点积分数。这表示图像-文本相似度分数。 - 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 的 forward 方法,覆盖了 __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
< source >( 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
,形状为 (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 的 forward 方法,覆盖了 __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
,形状为 (batch_size, output_dim
)
参数
- pixel_values (
tf.Tensor
,形状为(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 的 forward 方法,覆盖了 __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
class transformers.TFBlipTextModel
< source >( config add_pooling_layer = True name = None **kwargs )
该模型可以作为编码器(仅具有自注意力)以及解码器,在这种情况下,在自注意力层之间添加一个交叉注意力层,遵循 Ashish Vaswani、Noam Shazeer、Niki Parmar、Jakob Uszkoreit、Llion Jones、Aidan N. Gomez 和 Illia Polosukhin 的《Attention is all you need》中描述的架构。参数和`is_decoder`设置为`True`;然后期望`encoder_hidden_states`作为前向传播的输入。
调用
< source >( input_ids: TFModelInputType | None = None attention_mask: tf.Tensor | None = None position_ids: tf.Tensor | None = None head_mask: tf.Tensor | None = None inputs_embeds: tf.Tensor | None = None encoder_embeds: tf.Tensor | None = None encoder_hidden_states: tf.Tensor | None = None encoder_attention_mask: tf.Tensor | None = None past_key_values: tuple[tuple[tf.Tensor]] | None = None use_cache: bool | None = None output_attentions: bool | None = None output_hidden_states: bool | None = None return_dict: bool | None = None is_decoder: bool = False training: bool = False )
参数
- 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 对象而不是普通元组。 - encoder_hidden_states (
tf.Tensor
,可选) — 编码器最后一层输出的隐藏状态序列。如果模型配置为解码器,则用于交叉注意力。 - encoder_attention_mask (
tf.Tensor
,可选) — 用于避免对编码器输入中的填充标记索引执行注意力操作的掩码。如果模型配置为解码器,则此掩码用于交叉注意力。掩码值选择范围为[0, 1]
:- 1 表示**未被掩码**的标记,
- 0 表示**被掩码**的标记。
- past_key_values (
tuple(tuple(tf.Tensor))
,可选) — 包含注意力块的预计算键值隐藏状态。可用于加速解码。如果使用past_key_values
,用户可以选择只输入形状为(batch_size, 1)
的最后一个decoder_input_ids
(那些未向模型提供其过去的键值状态的 ID),而不是形状为(batch_size, sequence_length)
的所有decoder_input_ids
。 - use_cache (
bool
,可选) — 如果设置为True
,将返回past_key_values
键值状态,可用于加速解码(请参阅past_key_values
)。
TFBlipTextModel 的 forward 方法,覆盖了 __call__
特殊方法。
尽管前向传播的实现需要在该函数中定义,但随后应该调用`Module`实例而不是此函数,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
TFBlipTextLMHeadModel
调用
< source >( input_ids = None attention_mask = None position_ids = None head_mask = None inputs_embeds = None encoder_hidden_states = None encoder_attention_mask = None labels = None past_key_values = None use_cache = None output_attentions = None output_hidden_states = None return_dict = None return_logits = False is_decoder = True training = None )
参数
- input_ids (
tf.Tensor
of shape(batch_size, sequence_length)
) — 输入序列标记在词汇表中的索引。如果提供填充,将默认忽略。索引可以使用 AutoProcessor 获得。详情请参阅
BlipProcessor.__call__()
。 - attention_mask (
tf.Tensor
of shape(batch_size, sequence_length)
, 可选) — 掩码,用于避免对填充标记索引执行注意力操作。掩码值选择在[0, 1]
之间:- 1 表示未被掩码的标记,
- 0 表示被掩码的标记。
- position_ids (
tf.Tensor
of shape(batch_size, sequence_length)
, 可选) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为[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 表示被掩码的标记。
- labels (
tf.Tensor
, 可选) — 用于计算从左到右语言建模损失(下一个词预测)的标签。索引应在[-100, 0, ..., config.vocab_size]
之间(参见input_ids
文档字符串)。索引设置为-100
的标记将被忽略(掩码),损失仅针对标签为[0, ..., config.vocab_size]
的标记计算。 - past_key_values (
tuple(tuple(tf.Tensor))
, 可选) — 包含注意力块预计算的键和值隐藏状态。可用于加速解码。如果使用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
)。
TFBlipTextLMHeadModel 的 forward 方法,重写了 __call__
特殊方法。
尽管前向传播的实现需要在该函数中定义,但随后应该调用`Module`实例而不是此函数,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
- forward
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 或 tuple(tf.Tensor)
参数
- 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 而不是普通元组。
返回
transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling 或 tuple(tf.Tensor)
一个 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
of shape(batch_size, sequence_length, hidden_size)
) — 模型最后一层输出的隐藏状态序列。 -
pooler_output (
tf.Tensor
of shape(batch_size, hidden_size)
) — 序列中第一个标记(分类标记)的最后一层隐藏状态,经过线性层和 Tanh 激活函数进一步处理。线性层权重在预训练期间通过下一句预测(分类)目标进行训练。此输出通常不是输入语义内容的良好摘要,通常最好对整个输入序列的隐藏状态进行平均或池化。
-
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)
, 可选, 当传入output_attentions=True
或当config.output_attentions=True
时返回) —tf.Tensor
的元组(每个层一个)形状为(batch_size, num_heads, sequence_length, sequence_length)
。注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
TFBlipVisionModel 的 forward 方法,重写了 __call__
特殊方法。
尽管前向传播的实现需要在该函数中定义,但随后应该调用`Module`实例而不是此函数,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
TFBlipForConditionalGeneration
class 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)
参数
- 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 而不是普通元组。
返回
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
时返回,tf.Tensor
of shape(1,)
) — 来自文本解码器的语言建模损失。 -
logits (
tf.Tensor
of shape(batch_size, sequence_length, config.vocab_size)
, 可选) — 文本解码器模型语言建模头部的预测分数。 -
image_embeds (
tf.Tensor
of shape(batch_size, output_dim)
, 可选) — 应用视觉 Transformer 模型到输入图像后获得的图像嵌入。 -
last_hidden_state (
tf.Tensor
of shape(batch_size, sequence_length, hidden_size)
, 可选) — 模型最后一层输出的隐藏状态序列。 -
hidden_states (
tuple(tf.Tensor)
, 可选, 当传入output_hidden_states=True
时返回) —tf.Tensor
的元组(一个用于嵌入层的输出,如果模型有嵌入层,+ 每个层的输出)形状为(batch_size, sequence_length, hidden_size)
。模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
-
attentions (
tuple(tf.Tensor)
, 可选, 当传入output_attentions=True
时返回) —tf.Tensor
的元组(每个层一个)形状为(batch_size, num_heads, sequence_length, sequence_length)
。注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
TFBlipForConditionalGeneration 的 forward 方法,重写了 __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
class transformers.TFBlipForImageTextRetrieval
< 源 >( 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 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
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 而不是普通元组。
返回
transformers.models.blip.modeling_tf_blip.TFBlipImageTextMatchingModelOutput
或 tuple(tf.Tensor)
一个 transformers.models.blip.modeling_tf_blip.TFBlipImageTextMatchingModelOutput
或 tf.Tensor
的元组(如果传入 return_dict=False
或当 config.return_dict=False
时),包含根据配置 (<class 'transformers.models.blip.configuration_blip.BlipVisionConfig'>
) 和输入而变化的各种元素。
-
itm_score (
tf.Tensor
) — 图像-文本相似度得分。 -
loss (
tf.Tensor
of shape(1,)
, 可选, 当提供labels
时返回) — 来自文本解码器的语言建模损失。 -
image_embeds (
tf.Tensor
of shape(batch_size, output_dim)
可选 当模型使用with_projection=True
初始化时返回) — 通过将投影层应用于 pooler_output 获得的图像嵌入。 -
last_hidden_state (
tf.Tensor
of shape(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
of shape(batch_size, hidden_size)
, 可选) — 模型视觉分支中最后一层的隐藏状态。 -
attentions (
tuple(tf.Tensor)
, 可选, 当传入output_attentions=True
或当config.output_attentions=True
时返回) —tf.Tensor
的元组(每个层一个)形状为(batch_size, num_heads, sequence_length, sequence_length)
。注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
-
question_embeds (
tf.Tensor
) — 通过文本投影层获得的问句嵌入。
TFBlipForImageTextRetrieval 的 forward 方法,重写了 __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
class 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
或 tuple(tf.Tensor)
参数
- pixel_values (形状为
(batch_size, num_channels, height, width)
的tf.Tensor
) — 像素值。如果提供填充,默认情况下将被忽略。像素值可以使用 BlipImageProcessor 获取。有关详细信息,请参阅 BlipImageProcessor.call()。 - output_attentions (
bool
, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions
。 - output_hidden_states (
bool
, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
。 - return_dict (
bool
, 可选) — 是否返回 ModelOutput 而不是纯元组。
返回
transformers.models.blip.modeling_tf_blip.TFBlipTextVisionModelOutput
或 tuple(tf.Tensor)
一个 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
of shape(1,)
, 可选, 当提供labels
时返回) — 来自文本解码器的语言建模损失。 -
image_embeds (
tf.Tensor
of shape(batch_size, output_dim)
可选 当模型使用with_projection=True
初始化时返回) — 通过将投影层应用于 pooler_output 获得的图像嵌入。 -
last_hidden_state (
tf.Tensor
of shape(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)
, 可选, 当传入output_attentions=True
或当config.output_attentions=True
时返回) —tf.Tensor
的元组(每个层一个)形状为(batch_size, num_heads, sequence_length, sequence_length)
。注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
TFBlipForQuestionAnswering 的 forward 方法,覆盖了 __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