Hugging Face 的标志

Transformers 文档

BLIP

Hugging Face's logo
加入 Hugging Face 社区

并获得增强的文档体验

开始使用

BLIP

PyTorch TensorFlow

概述

BLIP 模型由 Junnan Li、Dongxu Li、Caiming Xiong 和 Steven Hoi 在 BLIP: Bootstrapping Language-Image Pre-training for Unified Vision-Language Understanding and Generation 中提出。

BLIP 是一个能够执行各种多模态任务的模型，包括

  • 视觉问答
  • 图像-文本检索（图像-文本匹配）
  • 图像描述

论文摘要如下

视觉-语言预训练 (VLP) 提升了许多视觉-语言任务的性能。然而，大多数现有的预训练模型仅擅长于基于理解的任务或基于生成的任务。此外，性能的提升很大程度上是通过使用从网络收集的嘈杂图像-文本对来扩大数据集实现的，这不是最佳的监督来源。在本文中，我们提出了 BLIP，一个新的 VLP 框架，它可以灵活地迁移到视觉-语言理解和生成任务。BLIP 通过引导 captions 有效地利用了嘈杂的网络数据，其中 captioner 生成合成 captions，而过滤器移除嘈杂的 captions。我们在广泛的视觉-语言任务上取得了最先进的结果，例如图像-文本检索（平均 recall@1 提升 +2.7%），图像描述（CIDEr 提升 +2.8%）和 VQA（VQA 分数提升 +1.6%）。BLIP 还展示了在零样本方式下直接迁移到视频语言任务时的强大泛化能力。代码、模型和数据集已发布。

BLIP.gif

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

资源

  • Jupyter notebook，关于如何在自定义数据集上微调 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, optional, 可选, 默认为 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

返回值

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, optional, 默认为 30524) — Blip 文本模型的词汇表大小。定义了在调用 BlipModel 时传递的 inputs_ids 可以表示的不同 token 的数量。
  • hidden_size (int, optional, 默认为 768) — 编码器层和池化层的维度。
  • encoder_hidden_size (int, optional, 默认为 768) — 来自视觉模型的编码器层的维度。
  • intermediate_size (int, optional, 默认为 3072) — Transformer 编码器中“中间层”（即，前馈层）的维度。
  • num_hidden_layers (int, optional, 默认为 12) — Transformer 编码器中隐藏层的数量。
  • num_attention_heads (int, optional, 默认为 8) — Transformer 编码器中每个注意力层的注意力头数。
  • max_position_embeddings (int, optional, 默认为 512) — 此模型可能使用的最大序列长度。通常设置为较大的值以防万一（例如，512 或 1024 或 2048）。
  • hidden_act (str 或 function, optional, 默认为 "gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果为字符串，则支持 "gelu", "relu", "selu" 和 "gelu_new" "gelu"。
  • layer_norm_eps (float, optional, 默认为 1e-12) — 层归一化层使用的 epsilon 值。
  • hidden_dropout_prob (float, optional, 默认为 0.0) — embeddings、编码器和池化器中所有全连接层的 dropout 概率。
  • attention_dropout (float, optional, 默认为 0.0) — 注意力概率的 dropout 比率。
  • initializer_range (float, optional, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
  • bos_token_id (int, optional, 默认为 30522) — sequence-of-beginning token 的 id。
  • eos_token_id (int, optional, 默认为 2) — end-of-sequence token 的 id。
  • pad_token_id (int, optional, 默认为 0) — padding token 的 id。
  • sep_token_id (int, optional, 默认为 102) — separator token 的 id。
  • is_decoder (bool, optional, 默认为 True) — 模型是否用作解码器。
  • use_cache (bool, optional, 默认为 True) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）。
  • label_smoothing (float, optional) — [0.0, 1.0] 范围内的浮点数。指定计算损失时平滑的量，其中 0.0 表示不平滑。目标变成原始 ground truth 和均匀分布的混合，如 Rethinking the Inception Architecture for Computer Vision <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

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, optional, defaults to 768) — 编码器层和池化层的维度。
  • intermediate_size (int, optional, defaults to 3072) — Transformer 编码器中“中间”（即，前馈）层的维度。
  • num_hidden_layers (int, optional, defaults to 12) — Transformer 编码器中隐藏层的数量。
  • num_attention_heads (int, optional, defaults to 12) — Transformer 编码器中每个注意力层的注意力头的数量。
  • image_size (int, optional, defaults to 384) — 每张图片的大小（分辨率）。
  • patch_size (int, optional, defaults to 16) — 每个 patch 的大小（分辨率）。
  • hidden_act (str 或 function, optional, defaults to "gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果为字符串，则支持 "gelu"、"relu"、"selu" 和 "gelu_new" "gelu"。
  • layer_norm_eps (float, optional, defaults to 1e-5) — 层归一化层使用的 epsilon 值。
  • attention_dropout (float, optional, defaults to 0.0) — 注意力概率的 dropout 比率。
  • initializer_range (float, optional, defaults to 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`] 的一个实例。tokenizer 是必需的输入。

构建一个 BLIP 处理器，它将 BERT tokenizer 和 BLIP 图像处理器包装成一个单独的处理器。

BlipProcessor 提供了 BlipImageProcessor 和 BertTokenizerFast 的所有功能。有关更多信息，请参阅 __call__() 和 decode() 的文档字符串。

batch_decode

< >

( *args **kwargs )

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

decode

< >

( *args **kwargs )

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

BlipImageProcessor

class transformers.BlipImageProcessor

< >

( do_resize: bool = True size: typing.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, typing.List[float], NoneType] = None image_std: typing.Union[float, typing.List[float], NoneType] = None do_convert_rgb: bool = True **kwargs )

参数

  • do_resize (bool, optional, defaults to True) — 是否将图像的（高度，宽度）尺寸调整为指定的 size。可以通过 preprocess 方法中的 do_resize 参数覆盖。
  • size (dict, optional, defaults to {"height" -- 384, "width": 384})：调整大小后输出图像的大小。可以通过 preprocess 方法中的 size 参数覆盖。
  • resample (PILImageResampling, optional, defaults to Resampling.BICUBIC) — 如果调整图像大小，则使用的重采样过滤器。仅当 do_resize 设置为 True 时才有效。可以通过 preprocess 方法中的 resample 参数覆盖。
  • do_rescale (bool, optional, defaults to True) — 是否按指定的比例 rescale_factor 重新缩放图像。可以通过 preprocess 方法中的 do_rescale 参数覆盖。
  • rescale_factor (int 或 float, optional, defaults to 1/255) — 如果重新缩放图像，则使用的缩放因子。仅当 do_rescale 设置为 True 时才有效。可以通过 preprocess 方法中的 rescale_factor 参数覆盖。
  • do_normalize (bool, optional, defaults to True) — 是否标准化图像。可以通过 preprocess 方法中的 do_normalize 参数覆盖。可以通过 preprocess 方法中的 do_normalize 参数覆盖。
  • image_mean (float 或 List[float], optional, defaults to IMAGENET_STANDARD_MEAN) — 如果标准化图像，则使用的均值。这是一个浮点数或浮点数列表，其长度为图像中通道的数量。可以通过 preprocess 方法中的 image_mean 参数覆盖。可以通过 preprocess 方法中的 image_mean 参数覆盖。
  • image_std (float 或 List[float], optional, defaults to IMAGENET_STANDARD_STD) — 如果标准化图像，则使用的标准差。这是一个浮点数或浮点数列表，其长度为图像中通道的数量。可以通过 preprocess 方法中的 image_std 参数覆盖。可以通过 preprocess 方法中的 image_std 参数覆盖。
  • do_convert_rgb (bool, optional, defaults to 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[typing.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, typing.List[float], NoneType] = None image_std: typing.Union[float, typing.List[float], NoneType] = None return_tensors: typing.Union[str, transformers.utils.generic.TensorType, NoneType] = None do_convert_rgb: 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, optional, defaults to self.do_resize) — 是否调整图像大小。默认为 self.do_resize。
  • size (Dict[str, int], optional, defaults to self.size) — 控制 resize 之后图像的大小。图像的最短边将被调整为 size["shortest_edge"]，同时保持纵横比。如果调整大小后的图像的最长边 > int(size["shortest_edge"] * (1333 / 800))，则图像将再次调整大小，使最长边等于 int(size["shortest_edge"] * (1333 / 800))。 默认为 self.size。
  • resample (PILImageResampling, optional, defaults to self.resample) — 如果调整图像大小，则使用的重采样过滤器。 仅在 do_resize 设置为 True 时有效。 默认为 self.resample。
  • do_rescale (bool, optional, defaults to self.do_rescale) — 是否将图像值重新缩放到 [0 - 1] 之间。 默认为 self.do_rescale。
  • rescale_factor (float, optional, defaults to self.rescale_factor) — 如果 do_rescale 设置为 True，则用于重新缩放图像的缩放因子。 默认为 self.rescale_factor。
  • do_normalize (bool, optional, defaults to self.do_normalize) — 是否标准化图像。 默认为 self.do_normalize。
  • image_mean (float or List[float], optional, defaults to self.image_mean) — 如果 do_normalize 设置为 True，则用于标准化图像的图像均值。 默认为 self.image_mean。
  • image_std (float or List[float], optional, defaults to self.image_std) — 如果 do_normalize 设置为 True，则用于标准化图像的图像标准差。 默认为 self.image_std。
  • do_convert_rgb (bool, optional, defaults to self.do_convert_rgb) — 是否将图像转换为 RGB 格式。 默认为 self.do_convert_rgb。
  • return_tensors (str or TensorType, optional) — 返回的张量类型。可以是以下之一：
    • Unset: 返回 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 or str, optional, defaults to ChannelDimension.FIRST) — 输出图像的通道维度格式。可以是以下之一：
    • "channels_first" 或 ChannelDimension.FIRST: 图像格式为 (num_channels, height, width)。
    • "channels_last" 或 ChannelDimension.LAST: 图像格式为 (height, width, num_channels)。
    • Unset: 使用输入图像的通道维度格式。
    默认为 ChannelDimension.FIRST。
  • input_data_format (ChannelDimension or str, optional) — 输入图像的通道维度格式。 如果未设置，则通道维度格式将从输入图像中推断。可以是以下之一：
    • "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] )

参数

  • do_resize (bool, optional, defaults to self.do_resize) — 是否将图像的（高度，宽度）尺寸调整为指定的 size。 可以被 preprocess 方法中的 do_resize 参数覆盖。 默认为 self.do_resize。
  • size (dict, optional, defaults to self.size) — 调整大小后输出图像的大小。 可以被 preprocess 方法中的 size 参数覆盖。 默认为 self.size。
  • default_to_square (bool, optional, defaults to self.default_to_square) — 如果 size 是整数，是否在调整大小时默认使用方形图像。 默认为 self.default_to_square。
  • resample (PILImageResampling, optional, defaults to self.resample) — 如果调整图像大小，则使用的重采样过滤器。 仅在 do_resize 设置为 True 时有效。 可以被 preprocess 方法中的 resample 参数覆盖。 默认为 self.resample。
  • do_center_crop (bool, optional, defaults to self.do_center_crop) — 是否将图像中心裁剪为指定的 crop_size。 可以被 preprocess 方法中的 do_center_crop 参数覆盖。 默认为 self.do_center_crop。
  • crop_size (Dict[str, int] optional, defaults to self.crop_size) — 应用 center_crop 后输出图像的大小。 可以被 preprocess 方法中的 crop_size 参数覆盖。 默认为 self.crop_size。
  • do_rescale (bool, optional, defaults to self.do_rescale) — 是否通过指定的缩放比例 rescale_factor 重新缩放图像。 可以被 preprocess 方法中的 do_rescale 参数覆盖。 默认为 self.do_rescale。
  • rescale_factor (int 或 float, 可选, 默认为 self.rescale_factor) — 如果要调整图像大小，则使用的缩放因子。仅当 do_rescale 设置为 True 时才有效。可以被 preprocess 方法中的 rescale_factor 参数覆盖。
  • do_normalize (bool, 可选, 默认为 self.do_normalize) — 是否对图像进行归一化。可以被 preprocess 方法中的 do_normalize 参数覆盖。可以被 preprocess 方法中的 do_normalize 参数覆盖。
  • image_mean (float 或 List[float], 可选, 默认为 self.image_mean) — 如果要对图像进行归一化，则使用的均值。这是一个浮点数或浮点数列表，其长度为图像中通道的数量。可以被 preprocess 方法中的 image_mean 参数覆盖。可以被 preprocess 方法中的 image_mean 参数覆盖。
  • image_std (float 或 List[float], 可选, 默认为 self.image_std) — 如果要对图像进行归一化，则使用的标准差。这是一个浮点数或浮点数列表，其长度为图像中通道的数量。可以被 preprocess 方法中的 image_std 参数覆盖。可以被 preprocess 方法中的 image_std 参数覆盖。
  • do_convert_rgb (bool, 可选, 默认为 self.do_convert_rgb) — 是否将图像转换为 RGB 格式。
  • return_tensors (str 或 TensorType, 可选, 默认为 self.return_tensors) — 如果设置为 `pt`，则返回堆叠的张量，否则返回张量列表。
  • data_format (ChannelDimension 或 str, 可选, 默认为 self.data_format) — 仅支持 ChannelDimension.FIRST。为与慢速处理器兼容而添加。
  • input_data_format (ChannelDimension 或 str, 可选, 默认为 self.input_data_format) — 输入图像的通道维度格式。如果未设置，则从输入图像推断通道维度格式。可以是以下之一：
    • "channels_first" 或 ChannelDimension.FIRST：图像格式为 (num_channels, height, width)。
    • "channels_last" 或 ChannelDimension.LAST：图像格式为 (height, width, num_channels)。
    • "none" 或 ChannelDimension.NONE：图像格式为 (height, width)。
  • device (torch.device, 可选, 默认为 self.device) — 处理图像的设备。如果未设置，则从输入图像推断设备。

构建一个快速 BLIP 图像处理器。

preprocess

< >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']] **kwargs: typing_extensions.Unpack[transformers.image_processing_utils_fast.DefaultFastImageProcessorKwargs] )

参数

  • images (ImageInput) — 要预处理的图像。 接受像素值范围为 0 到 255 的单个或一批图像。如果传入像素值介于 0 和 1 之间的图像，请设置 do_rescale=False。
  • do_resize (bool, 可选, 默认为 self.do_resize) — 是否调整图像大小。
  • size (Dict[str, int], 可选, 默认为 self.size) — 描述模型的最大输入尺寸。
  • resample (PILImageResampling 或 InterpolationMode, 可选, 默认为 self.resample) — 如果调整图像大小，则使用的重采样过滤器。 这可以是枚举 PILImageResampling 之一。仅当 do_resize 设置为 True 时才有效。
  • do_center_crop (bool, 可选, 默认为 self.do_center_crop) — 是否对图像进行中心裁剪。
  • crop_size (Dict[str, int], 可选, 默认为 self.crop_size) — 应用 center_crop 后输出图像的大小。
  • do_rescale (bool, 可选, 默认为 self.do_rescale) — 是否缩放图像。
  • rescale_factor (float, 可选, 默认为 self.rescale_factor) — 如果 do_rescale 设置为 True，则用于缩放图像的缩放因子。
  • do_normalize (bool, 可选, 默认为 self.do_normalize) — 是否对图像进行归一化。
  • image_mean (float 或 List[float], 可选, 默认为 self.image_mean) — 用于归一化的图像均值。仅当 do_normalize 设置为 True 时才有效。
  • image_std (float 或 List[float], 可选, 默认为 self.image_std) — 用于归一化的图像标准差。仅当 do_normalize 设置为 True 时才有效。
  • do_convert_rgb (bool, 可选, 默认为 self.do_convert_rgb) — 是否将图像转换为 RGB 格式。
  • return_tensors (str 或 TensorType, 可选, 默认为 self.return_tensors) — 如果设置为 `pt`，则返回堆叠的张量，否则返回张量列表。
  • data_format (ChannelDimension 或 str, 可选, 默认为 self.data_format) — 仅支持 ChannelDimension.FIRST。为与慢速处理器兼容而添加。
  • input_data_format (ChannelDimension 或 str, 可选, 默认为 self.input_data_format) — 输入图像的通道维度格式。如果未设置，则从输入图像推断通道维度格式。可以是以下之一：
    • "channels_first" 或 ChannelDimension.FIRST：图像采用（num_channels，height，width）格式。
    • "channels_last" 或 ChannelDimension.LAST：图像采用（height，width，num_channels）格式。
    • "none" 或 ChannelDimension.NONE：图像采用（height，width）格式。
  • device (torch.device, 可选, 默认为 self.device) — 用于处理图像的设备。如果未设置，则从输入图像推断设备。

预处理单张或批量图像。

Pytorch
隐藏 Pytorch 内容

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

参数

  • input_ids (torch.LongTensor，形状为 (batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。如果您提供 padding，默认情况下将被忽略。

    索引可以使用 AutoProcessor 获得。有关详细信息，请参阅 BlipProcessor.__call__()。

    什么是 input IDs？

  • attention_mask (torch.Tensor，形状为 (batch_size, sequence_length)，可选) — Mask，用于避免在 padding token 索引上执行 attention。Mask 值在 [0, 1] 中选择：

    • 1 表示 未被 mask 的 tokens，
    • 0 表示 已被 mask 的 tokens。

    什么是 attention masks？

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

    什么是 position IDs？

  • pixel_values (torch.FloatTensor，形状为 (batch_size, num_channels, height, width)) — 像素值。如果您提供 padding，默认情况下将被忽略。像素值可以使用 BlipImageProcessor 获得。有关详细信息，请参阅 BlipImageProcessor.call()。
  • return_loss (bool，可选) — 是否返回对比损失。
  • output_attentions (bool，可选) — 是否返回所有 attention 层的 attentions tensors。有关更多详细信息，请参阅返回 tensors 下的 attentions。
  • output_hidden_states (bool，可选) — 是否返回所有层的 hidden states。有关更多详细信息，请参阅返回 tensors 下的 hidden_states。
  • return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通 tuple。
  • interpolate_pos_encoding (bool，可选，默认为 False) — 是否插值预训练的位置编码。

返回值

transformers.models.blip.modeling_blip.BlipOutput 或 tuple(torch.FloatTensor)

一个 transformers.models.blip.modeling_blip.BlipOutput 或一个 torch.FloatTensor 的 tuple（如果传递了 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 的 pooled output 获得的文本嵌入。
  • image_embeds(torch.FloatTensor，形状为 (batch_size, output_dim) — 通过将投影层应用于 BlipVisionModel 的 pooled output 获得的图像嵌入。
  • text_model_output(BaseModelOutputWithPooling): BlipTextModel 的输出。
  • vision_model_output(BaseModelOutputWithPooling): BlipVisionModel 的输出。

BlipModel forward 方法，覆盖了 __call__ 特殊方法。

尽管 forward pass 的配方需要在该函数中定义，但应该在之后调用 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.LongTensor，形状为 (batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。如果您提供 padding，默认情况下将被忽略。

    索引可以使用 AutoProcessor 获得。有关详细信息，请参阅 BlipProcessor.__call__()。

    什么是 input IDs？

  • attention_mask (torch.Tensor，形状为 (batch_size, sequence_length)，可选) — Mask，用于避免在 padding token 索引上执行 attention。Mask 值在 [0, 1] 中选择：

    • 1 表示 未被 mask 的 tokens，
    • 0 表示 已被 mask 的 tokens。

    什么是 attention masks？

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

    什么是 position IDs？

  • output_attentions (bool，可选) — 是否返回所有 attention 层的 attentions tensors。有关更多详细信息，请参阅返回 tensors 下的 attentions。
  • output_hidden_states (bool，可选) — 是否返回所有层的 hidden states。有关更多详细信息，请参阅返回 tensors 下的 hidden_states。
  • return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通 tuple。

返回值

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

通过将投影层应用于 BlipTextModel 的 pooled output 获得的文本嵌入。

BlipModel forward 方法，覆盖了 __call__ 特殊方法。

尽管 forward pass 的配方需要在该函数中定义，但应该在之后调用 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（获取图像特征）

< >

( 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, height, width)) — 像素值。如果您提供 padding，默认情况下将被忽略。像素值可以使用 BlipImageProcessor 获得。有关详细信息，请参阅 BlipImageProcessor.call()。
  • output_attentions (bool，可选) — 是否返回所有 attention 层的 attentions tensors。有关更多详细信息，请参阅返回 tensors 下的 attentions。
  • output_hidden_states (bool，可选) — 是否返回所有层的 hidden states。有关更多详细信息，请参阅返回 tensors 下的 hidden_states。
  • return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通 tuple。
  • interpolate_pos_encoding (bool，可选，默认为 False) — 是否插值预训练的位置编码。

返回值

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

通过将投影层应用于 BlipVisionModel 的池化输出获得的图像嵌入。

BlipModel forward 方法，覆盖了 __call__ 特殊方法。

尽管 forward pass 的配方需要在该函数中定义，但应该在之后调用 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

class transformers.BlipTextModel

< >

( config add_pooling_layer = True )

该模型可以充当编码器（仅具有自注意力），也可以充当解码器，在后一种情况下，自注意力层之间会添加一个交叉注意力层，遵循 Ashish Vaswani、Noam Shazeer、Niki Parmar、Jakob Uszkoreit、Llion Jones、Aidan N. Gomez、Lukasz Kaiser 和 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[typing.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）。

BlipVisionModel

class transformers.BlipVisionModel

< >

( config: BlipVisionConfig )

forward（前向传播）

< >

( 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, height, width) 的 torch.FloatTensor) — 像素值。默认情况下，如果您提供填充，则会忽略填充。像素值可以使用 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)

transformers.modeling_outputs.BaseModelOutputWithPooling 或 torch.FloatTensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），包含各种元素，具体取决于配置 (<class 'transformers.models.blip.configuration_blip.BlipVisionConfig'>) 和输入。

  • 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 时返回) — torch.FloatTensor 的元组（如果模型具有嵌入层，则为嵌入的输出，+ 每个层的输出一个），形状为 (batch_size, sequence_length, hidden_size)。

    模型在每一层输出处的隐藏状态，加上可选的初始嵌入输出。

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

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

BlipVisionModel 正向方法，覆盖了 __call__ 特殊方法。

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

BlipForConditionalGeneration

class 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: 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, height, width) 的 torch.FloatTensor) — 像素值。默认情况下，如果您提供填充，则会忽略填充。像素值可以使用 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 或 torch.FloatTensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），包含各种元素，具体取决于配置 (<class 'transformers.models.blip.configuration_blip.BlipVisionConfig'>) 和输入。

  • 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，可选) — 模型最后一层的输出处的隐藏状态序列。

  • hidden_states (tuple(torch.FloatTensor)，可选，当 output_hidden_states=True 时返回) — torch.FloatTensor 的元组（如果模型具有嵌入层，则为嵌入的输出，+ 每个层的输出一个），形状为 (batch_size, sequence_length, hidden_size)。

    模型在每一层输出处的隐藏状态，加上可选的初始嵌入输出。

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

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

BlipForConditionalGeneration 正向方法，覆盖了 __call__ 特殊方法。

尽管 forward pass 的配方需要在该函数中定义，但应该在之后调用 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

< >

( config: BlipConfig )

参数

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

带有视觉和文本投影器以及顶部分类头的 BLIP 模型。该模型用于图像-文本检索的上下文中。给定图像和文本，模型返回文本与图像相关的概率。

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

此模型也是 PyTorch torch.nn.Module 子类。请像使用常规 PyTorch 模块一样使用它，并参阅 PyTorch 文档，了解与常规用法和行为相关的所有事项。

forward（前向传播）

< >

( 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 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.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 初始化时返回) — 通过将投影层应用于 pooler_output 获得的图像嵌入。

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

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

    模型在每一层输出处的隐藏状态，加上可选的初始嵌入输出。

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

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

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

尽管 forward pass 的配方需要在该函数中定义，但应该在之后调用 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

< >

( config: BlipConfig )

参数

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

用于视觉问答的 BLIP 模型。该模型由视觉编码器、文本编码器以及文本解码器组成。视觉编码器将编码输入图像，文本编码器将编码输入问题以及图像的编码，文本解码器将输出问题的答案。

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

此模型也是 PyTorch torch.nn.Module 子类。请像使用常规 PyTorch 模块一样使用它，并参阅 PyTorch 文档，了解与常规用法和行为相关的所有事项。

forward（前向传播）

< >

( 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 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.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 初始化时返回) — 通过将投影层应用于 pooler_output 获得的图像嵌入。

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

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

    模型在每一层输出处的隐藏状态，加上可选的初始嵌入输出。

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

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

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

尽管 forward pass 的配方需要在该函数中定义，但应该在之后调用 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
TensorFlow
隐藏 TensorFlow 内容

TFBlipModel

class transformers.TFBlipModel

< >

( config: BlipConfig *inputs **kwargs )

call

< >

( 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 or tuple(tf.Tensor)

参数

  • input_ids (tf.Tensor，形状为 (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。如果您提供填充，默认情况下会忽略填充。

    索引可以使用 AutoProcessor 获得。有关详细信息，请参阅 BlipProcessor.__call__()。

    什么是输入 ID？

  • 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] 中选择。

    什么是位置 ID？

  • pixel_values (tf.Tensor，形状为 (batch_size, num_channels, height, width)) — 像素值。如果您提供填充，默认情况下会忽略填充。像素值可以使用 BlipImageProcessor 获得。有关详细信息，请参阅 BlipImageProcessor.call()。
  • return_loss (bool, optional) — 是否返回对比损失。
  • output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。 有关更多详细信息，请参见返回张量下的 attentions。
  • output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。 有关更多详细信息，请参见返回张量下的 hidden_states。
  • return_dict (bool, optional) — 是否返回 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 前向方法，覆盖了 __call__ 特殊方法。

尽管 forward pass 的配方需要在该函数中定义，但应该在之后调用 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，形状为 (batch_size, output_dim)

参数

  • input_ids (tf.Tensor，形状为 (batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。 如果您提供填充，默认情况下会忽略填充。

    索引可以使用 AutoProcessor 获得。 有关详细信息，请参见 BlipProcessor.__call__()。

    什么是输入 IDs？

  • attention_mask (tf.Tensor，形状为 (batch_size, sequence_length)，可选) — 掩码，以避免在 padding token 索引上执行注意力机制。 掩码值选自 [0, 1]：

    • 1 表示未被掩码的 tokens，
    • 0 表示被掩码的 tokens。

    什么是注意力掩码？

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

    什么是位置 IDs？

  • output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。 有关更多详细信息，请参见返回张量下的 attentions。
  • output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。 有关更多详细信息，请参见返回张量下的 hidden_states。
  • return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

返回值

text_features (tf.Tensor，形状为 (batch_size, output_dim)

通过将投影层应用于 TFBlipTextModel 的池化输出而获得的文本嵌入。

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

尽管 forward pass 的配方需要在该函数中定义，但应该在之后调用 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（获取图像特征）

< >

( 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, optional) — 是否返回所有注意力层的注意力张量。 有关更多详细信息，请参见返回张量下的 attentions。
  • output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。 有关更多详细信息，请参见返回张量下的 hidden_states。
  • return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

返回值

image_features (tf.Tensor，形状为 (batch_size, output_dim)

通过将投影层应用于 TFBlipVisionModel 的池化输出而获得的图像嵌入。

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

尽管 forward pass 的配方需要在该函数中定义，但应该在之后调用 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

< >

( config add_pooling_layer = True name = None **kwargs )

该模型可以充当编码器（仅具有自注意力），也可以充当解码器，在后一种情况下，自注意力层之间会添加一个交叉注意力层，遵循 Ashish Vaswani、Noam Shazeer、Niki Parmar、Jakob Uszkoreit、Llion Jones、Aidan N. Gomez、Lukasz Kaiser 和 Illia Polosukhin 在 Attention is all you need 中描述的架构。参数 is_decoder 设置为 True；然后需要将 encoder_hidden_states 作为正向传递的输入。

call

< >

( 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)) — 词汇表中输入序列 tokens 的索引。 如果您提供填充，默认情况下会忽略填充。

    索引可以使用 AutoProcessor 获得。 有关详细信息，请参见 BlipProcessor.__call__()。

    什么是输入 IDs？

  • attention_mask (tf.Tensor，形状为 (batch_size, sequence_length)，可选) — 掩码，以避免在 padding token 索引上执行注意力机制。 掩码值选自 [0, 1]：

    • 1 表示未被掩码的 tokens，
    • 0 表示被掩码的 tokens。

    什么是注意力掩码？

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

    什么是位置 IDs？

  • output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。 有关更多详细信息，请参见返回张量下的 attentions。
  • output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。 有关更多详细信息，请参见返回张量下的 hidden_states。
  • return_dict (bool, optional) — 是否返回 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）。

The TFBlipTextModel forward 方法重写了 __call__ 特殊方法。

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

TFBlipVisionModel

class transformers.TFBlipVisionModel

< >

( config: BlipVisionConfig *args **kwargs )

call

< >

( 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 (形状为 (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.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 (形状为 (batch_size, sequence_length, hidden_size) 的 tf.Tensor) — 模型最后一层输出的隐藏状态序列。

  • pooler_output (形状为 (batch_size, hidden_size) 的 tf.Tensor) — 序列的第一个标记（分类标记）的最后一层隐藏状态，通过线性层和 Tanh 激活函数进一步处理。线性层权重通过预训练期间的下一句预测（分类）目标进行训练。

    此输出通常不是输入语义内容的良好摘要，对于整个输入序列，您通常最好使用平均或池化隐藏状态序列。

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

The TFBlipVisionModel forward 方法重写了 __call__ 特殊方法。

尽管 forward pass 的配方需要在该函数中定义，但应该在之后调用 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 文档，了解与一般用法和行为相关的所有事项。

call

< >

( 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 (形状为 (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.TFBlipForConditionalGenerationModelOutput 或 tuple(tf.Tensor)

A 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 (形状为 (batch_size, sequence_length, config.vocab_size) 的 tf.Tensor, 可选) — 文本解码器模型的语言建模头的预测分数。

  • image_embeds (形状为 (batch_size, output_dim) 的 tf.Tensor, 可选) — 将 Vision Transformer 模型应用于输入图像后获得的图像嵌入。

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

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

The TFBlipForConditionalGeneration forward 方法重写了 __call__ 特殊方法。

尽管 forward pass 的配方需要在该函数中定义，但应该在之后调用 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 文档，了解与一般用法和行为相关的所有事项。

call

< >

( 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 or tuple(tf.Tensor)

参数

  • 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 而不是普通元组。

返回值

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，形状为 (1,)，可选，当提供 labels 时返回) — 来自文本解码器的语言建模损失。

  • image_embeds (tf.Tensor，形状为 (batch_size, output_dim)，可选，当模型使用 with_projection=True 初始化时返回) — 通过将投影层应用于 pooler_output 获得的图像嵌入。

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

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

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

  • question_embeds (tf.Tensor) — 通过文本投影层获得的问题嵌入。

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

尽管 forward pass 的配方需要在该函数中定义，但应该在之后调用 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 文档，了解与一般用法和行为相关的所有事项。

call

< >

( 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，形状为 (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.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，形状为 (1,)，可选，当提供 labels 时返回) — 来自文本解码器的语言建模损失。

  • image_embeds (tf.Tensor，形状为 (batch_size, output_dim)，可选，当模型使用 with_projection=True 初始化时返回) — 通过将投影层应用于 pooler_output 获得的图像嵌入。

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

  • 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 前向方法，覆盖了 __call__ 特殊方法。

尽管 forward pass 的配方需要在该函数中定义，但应该在之后调用 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
< > 在 GitHub 上更新

←AyaVision BLIP-2→