Transformers 文档

CLIP

Hugging Face's logo
加入 Hugging Face 社区

并获得增强的文档体验

开始使用

PyTorch TensorFlow Flax FlashAttention SDPA

CLIP

CLIP 是一个多模态视觉和语言模型,其动机是为了克服训练计算机视觉模型时对象类别数量固定的问题。CLIP 通过对 4 亿个(图像,文本)对进行联合训练,直接从原始文本中学习图像。这种规模的预训练使其能够零样本迁移到下游任务。CLIP 使用图像编码器和文本编码器来获取视觉特征和文本特征。这两种特征都被投影到具有相同维数的潜在空间中,它们的点积给出了相似度分数。

你可以在 OpenAI 组织下找到所有原始的 CLIP 检查点。

点击右侧边栏中的 CLIP 模型,查看更多如何将 CLIP 应用于不同图像和语言任务的示例。

下面的示例演示了如何使用 PipelineAutoModel 类来计算多个文本描述和一张图像之间的相似度分数。

流水线
自动模型
import torch
from transformers import pipeline

clip = pipeline(
   task="zero-shot-image-classification",
   model="openai/clip-vit-base-patch32",
   torch_dtype=torch.bfloat16,
   device=0
)
labels = ["a photo of a cat", "a photo of a dog", "a photo of a car"]
clip("http://images.cocodataset.org/val2017/000000039769.jpg", candidate_labels=labels)

注意

CLIPConfig

class transformers.CLIPConfig

< >

( text_config = None vision_config = None projection_dim = 512 logit_scale_init_value = 2.6592 **kwargs )

参数

  • text_config (dict, 可选) — 用于初始化 CLIPTextConfig 的配置选项字典。
  • vision_config (dict, 可选) — 用于初始化 CLIPVisionConfig 的配置选项字典。
  • projection_dim (int, 可选, 默认为 512) — 文本和视觉投影层的维度。
  • logit_scale_init_value (float, 可选, 默认为 2.6592) — logit_scale 参数的初始值。默认值根据原始 CLIP 实现使用。
  • kwargs (可选) — 关键字参数字典。

CLIPConfig 是用于存储 CLIPModel 配置的配置类。它用于根据指定的参数实例化一个 CLIP 模型,定义文本模型和视觉模型配置。使用默认值实例化一个配置将产生与 CLIP openai/clip-vit-base-patch32 架构相似的配置。

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

示例

>>> from transformers import CLIPConfig, CLIPModel

>>> # Initializing a CLIPConfig with openai/clip-vit-base-patch32 style configuration
>>> configuration = CLIPConfig()

>>> # Initializing a CLIPModel (with random weights) from the openai/clip-vit-base-patch32 style configuration
>>> model = CLIPModel(configuration)

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

>>> # We can also initialize a CLIPConfig from a CLIPTextConfig and a CLIPVisionConfig
>>> from transformers import CLIPTextConfig, CLIPVisionConfig

>>> # Initializing a CLIPText and CLIPVision configuration
>>> config_text = CLIPTextConfig()
>>> config_vision = CLIPVisionConfig()

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

from_text_vision_configs

< >

( text_config: CLIPTextConfig vision_config: CLIPVisionConfig **kwargs ) CLIPConfig

返回

CLIPConfig

一个配置对象的实例

从 clip 文本模型配置和 clip 视觉模型配置实例化一个 CLIPConfig(或其派生类)。

CLIPTextConfig

class transformers.CLIPTextConfig

< >

( vocab_size = 49408 hidden_size = 512 intermediate_size = 2048 projection_dim = 512 num_hidden_layers = 12 num_attention_heads = 8 max_position_embeddings = 77 hidden_act = 'quick_gelu' layer_norm_eps = 1e-05 attention_dropout = 0.0 initializer_range = 0.02 initializer_factor = 1.0 pad_token_id = 1 bos_token_id = 49406 eos_token_id = 49407 **kwargs )

参数

  • vocab_size (int, 可选, 默认为 49408) — CLIP 文本模型的词汇表大小。定义了在调用 CLIPModel 时传递的 inputs_ids 可以表示的不同词元的数量。
  • hidden_size (int, 可选, 默认为 512) — 编码器层和池化层的维度。
  • intermediate_size (int, 可选, 默认为 2048) — Transformer 编码器中“中间”层(即前馈层)的维度。
  • projection_dim (int, 可选, 默认为 512) — 文本和视觉投影层的维度。
  • num_hidden_layers (int, 可选, 默认为 12) — Transformer 编码器中的隐藏层数量。
  • num_attention_heads (int, 可选, 默认为 8) — Transformer 编码器中每个注意力层的注意力头数量。
  • max_position_embeddings (int, 可选, 默认为 77) — 该模型可能使用的最大序列长度。通常将其设置为一个较大的值以备不时之需(例如,512、1024 或 2048)。
  • hidden_act (strfunction, 可选, 默认为 "quick_gelu") — 编码器和池化层中的非线性激活函数(函数或字符串)。如果为字符串,则支持 "gelu""relu""selu""gelu_new""quick_gelu"
  • layer_norm_eps (float, 可选, 默认为 1e-05) — 层归一化层使用的 epsilon 值。
  • attention_dropout (float, 可选, 默认为 0.0) — 注意力概率的 dropout 比例。
  • initializer_range (float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
  • initializer_factor (float, 可选, 默认为 1.0) — 一个用于初始化所有权重矩阵的因子(应保持为 1,内部用于初始化测试)。
  • pad_token_id (int, 可选, 默认为 1) — 填充词元 ID。
  • bos_token_id (int, 可选, 默认为 49406) — 序列开始词元 ID。
  • eos_token_id (int, 可选, 默认为 49407) — 序列结束词元 ID。

这是用于存储 CLIPTextModel 配置的配置类。它用于根据指定的参数实例化一个 CLIP 文本编码器,定义模型架构。使用默认值实例化一个配置将产生与 CLIP openai/clip-vit-base-patch32 架构的文本编码器相似的配置。

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

示例

>>> from transformers import CLIPTextConfig, CLIPTextModel

>>> # Initializing a CLIPTextConfig with openai/clip-vit-base-patch32 style configuration
>>> configuration = CLIPTextConfig()

>>> # Initializing a CLIPTextModel (with random weights) from the openai/clip-vit-base-patch32 style configuration
>>> model = CLIPTextModel(configuration)

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

CLIPVisionConfig

class transformers.CLIPVisionConfig

< >

( hidden_size = 768 intermediate_size = 3072 projection_dim = 512 num_hidden_layers = 12 num_attention_heads = 12 num_channels = 3 image_size = 224 patch_size = 32 hidden_act = 'quick_gelu' layer_norm_eps = 1e-05 attention_dropout = 0.0 initializer_range = 0.02 initializer_factor = 1.0 **kwargs )

参数

  • hidden_size (int, 可选, 默认为 768) — 编码器层和池化层的维度。
  • intermediate_size (int, 可选, 默认为 3072) — Transformer 编码器中“中间”层(即前馈层)的维度。
  • projection_dim (int, 可选, 默认为 512) — 文本和视觉投影层的维度。
  • num_hidden_layers (int, 可选, 默认为 12) — Transformer 编码器中的隐藏层数量。
  • num_attention_heads (int, 可选, 默认为 12) — Transformer 编码器中每个注意力层的注意力头数量。
  • num_channels (int, 可选, 默认为 3) — 输入通道的数量。
  • image_size (int, 可选, 默认为 224) — 每个图像的尺寸(分辨率)。
  • patch_size (int, 可选, 默认为 32) — 每个图块的尺寸(分辨率)。
  • hidden_act (strfunction, 可选, 默认为 "quick_gelu") — 编码器和池化层中的非线性激活函数(函数或字符串)。如果为字符串,则支持 "gelu""relu""selu""gelu_new""quick_gelu"
  • layer_norm_eps (float, 可选, 默认为 1e-05) — 层归一化层使用的 epsilon 值。
  • attention_dropout (float, 可选, 默认为 0.0) — 注意力概率的 dropout 比例。
  • initializer_range (float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
  • initializer_factor (float, 可选, 默认为 1.0) — 一个用于初始化所有权重矩阵的因子(应保持为 1,内部用于初始化测试)。

这是用于存储 CLIPVisionModel 配置的配置类。它用于根据指定的参数实例化一个 CLIP 视觉编码器,定义模型架构。使用默认值实例化一个配置将产生与 CLIP openai/clip-vit-base-patch32 架构的视觉编码器相似的配置。

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

示例

>>> from transformers import CLIPVisionConfig, CLIPVisionModel

>>> # Initializing a CLIPVisionConfig with openai/clip-vit-base-patch32 style configuration
>>> configuration = CLIPVisionConfig()

>>> # Initializing a CLIPVisionModel (with random weights) from the openai/clip-vit-base-patch32 style configuration
>>> model = CLIPVisionModel(configuration)

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

CLIPTokenizer

class transformers.CLIPTokenizer

< >

( vocab_file merges_file errors = 'replace' unk_token = '<|endoftext|>' bos_token = '<|startoftext|>' eos_token = '<|endoftext|>' pad_token = '<|endoftext|>' **kwargs )

参数

  • vocab_file (str) — 词汇表文件的路径。
  • merges_file (str) — merges 文件的路径。
  • errors (str, 可选, 默认为 "replace") — 将字节解码为 UTF-8 时遵循的范例。有关更多信息,请参阅 bytes.decode
  • unk_token (str, 可选, 默认为 "<|endoftext|>") — 未知词元(token)。不在词汇表中的词元无法转换为 ID,将被设置为此词元。
  • bos_token (str, 可选, 默认为 "<|startoftext|>") — 序列开始词元。
  • eos_token (str, 可选, 默认为 "<|endoftext|>") — 序列结束词元。
  • pad_token (str, 可选, 默认为 "<|endoftext|>") — 用于填充的词元,例如当批处理不同长度的序列时。

构建一个 CLIP 分词器。基于字节级的字节对编码(Byte-Pair-Encoding)。

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

build_inputs_with_special_tokens

< >

( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None ) list[int]

参数

  • token_ids_0 (list[int]) — 将要添加特殊词元的 ID 列表。
  • token_ids_1 (list[int], 可选) — 用于序列对的可选的第二个 ID 列表。

返回

list[int]

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

通过连接和添加特殊词元,从一个序列或一对序列中为序列分类任务构建模型输入。CLIP 序列具有以下格式:

  • 单个序列:<|startoftext|> X <|endoftext|>

序列对不是预期的使用情况,但它们将在没有分隔符的情况下被处理。

get_special_tokens_mask

< >

( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None already_has_special_tokens: bool = False ) list[int]

参数

  • token_ids_0 (list[int]) — ID 列表。
  • token_ids_1 (list[int], 可选) — 用于序列对的可选的第二个 ID 列表。
  • already_has_special_tokens (bool, 可选, 默认为 False) — 词元列表是否已经为模型格式化了特殊词元。

返回

list[int]

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

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

create_token_type_ids_from_sequences

< >

( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None ) list[int]

参数

  • token_ids_0 (list[int]) — ID 列表。
  • token_ids_1 (list[int], 可选) — 用于序列对的可选的第二个 ID 列表。

返回

list[int]

零列表。

从传入的两个序列创建掩码。CLIP 不使用词元类型 ID,因此返回一个零列表。

save_vocabulary

< >

( save_directory: str filename_prefix: typing.Optional[str] = None )

CLIPTokenizerFast

class transformers.CLIPTokenizerFast

< >

( vocab_file = None merges_file = None tokenizer_file = None unk_token = '<|endoftext|>' bos_token = '<|startoftext|>' eos_token = '<|endoftext|>' pad_token = '<|endoftext|>' **kwargs )

参数

  • vocab_file (str, 可选) — 词汇表文件的路径。
  • merges_file (str, 可选) — merges 文件的路径。
  • tokenizer_file (str, 可选) — 用来替代词汇表文件的分词器文件的路径。
  • unk_token (str, 可选, 默认为 "<|endoftext|>") — 未知词元(token)。不在词汇表中的词元无法转换为 ID,将被设置为此词元。
  • bos_token (str, 可选, 默认为 "<|startoftext|>") — 序列开始词元。
  • eos_token (str, 可选, 默认为 "<|endoftext|>") — 序列结束词元。
  • pad_token (str, 可选, 默认为 "<|endoftext|>") — 用于填充的词元,例如当批处理不同长度的序列时。

构建一个“快速”CLIP分词器(由HuggingFace的*tokenizers*库支持)。基于字节级的字节对编码(Byte-Pair-Encoding)。

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

build_inputs_with_special_tokens

< >

( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None ) list[int]

参数

  • token_ids_0 (list[int]) — 将要添加特殊词元的 ID 列表。
  • token_ids_1 (list[int], 可选) — 用于序列对的可选的第二个 ID 列表。

返回

list[int]

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

通过连接和添加特殊词元,从一个序列或一对序列中为序列分类任务构建模型输入。CLIP 序列具有以下格式:

  • 单个序列:<|startoftext|> X <|endoftext|>

序列对不是预期的使用情况,但它们将在没有分隔符的情况下被处理。

create_token_type_ids_from_sequences

< >

( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None ) list[int]

参数

  • token_ids_0 (list[int]) — ID 列表。
  • token_ids_1 (list[int], 可选) — 用于序列对的可选的第二个 ID 列表。

返回

list[int]

零列表。

从传入的两个序列创建掩码。CLIP 不使用词元类型 ID,因此返回一个零列表。

CLIPImageProcessor

class transformers.CLIPImageProcessor

< >

( do_resize: bool = True size: typing.Optional[dict[str, int]] = None resample: Resampling = <Resampling.BICUBIC: 3> do_center_crop: bool = True crop_size: typing.Optional[dict[str, int]] = None 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[str, int] 可选, 默认为 {"shortest_edge" -- 224}): 调整大小后图像的尺寸。图像的最短边将调整为 size[“shortest_edge”],最长边将相应调整以保持输入图像的长宽比。可在 preprocess 方法中通过 `size` 参数覆盖。
  • resample (PILImageResampling, 可选, 默认为 Resampling.BICUBIC) — 如果调整图像大小,则使用的重采样滤波器。可在 preprocess 方法中通过 `resample` 参数覆盖。
  • do_center_crop (bool, 可选, 默认为 True) — 是否对图像进行中心裁剪至指定的 crop_size。可在 preprocess 方法中通过 `do_center_crop` 参数覆盖。
  • crop_size (dict[str, int] 可选, 默认为 224) — 应用 center_crop 后输出图像的尺寸。可在 preprocess 方法中通过 `crop_size` 参数覆盖。
  • do_rescale (bool, 可选, 默认为 True) — 是否通过指定的缩放因子 rescale_factor 来重新缩放图像。可在 preprocess 方法中通过 `do_rescale` 参数覆盖。
  • rescale_factor (int or float, 可选, 默认为 1/255) — 如果重新缩放图像,则使用的缩放因子。可在 preprocess 方法中通过 `rescale_factor` 参数覆盖。
  • do_normalize (bool, 可选, 默认为 True) — 是否对图像进行归一化。可在 preprocess 方法中通过 `do_normalize` 参数覆盖。
  • image_mean (floatlist[float], 可选, 默认为 [0.48145466, 0.4578275, 0.40821073]) — 如果对图像进行归一化,则使用的均值。这是一个浮点数或浮点数列表,其长度等于图像中的通道数。可在 preprocess 方法中通过 image_mean 参数覆盖。
  • image_std (floatlist[float], 可选, 默认为 [0.26862954, 0.26130258, 0.27577711]) — 如果对图像进行归一化,则使用的标准差。这是一个浮点数或浮点数列表,其长度等于图像中的通道数。可在 preprocess 方法中通过 image_std 参数覆盖。
  • do_convert_rgb (bool, 可选, 默认为 True) — 是否将图像转换为 RGB。

构建一个 CLIP 图像处理器。

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_center_crop: typing.Optional[bool] = None crop_size: typing.Optional[int] = 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 do_convert_rgb: typing.Optional[bool] = None return_tensors: typing.Union[str, transformers.utils.generic.TensorType, NoneType] = None data_format: typing.Optional[transformers.image_utils.ChannelDimension] = <ChannelDimension.FIRST: 'channels_first'> input_data_format: typing.Union[str, transformers.image_utils.ChannelDimension, NoneType] = None **kwargs )

参数

  • images (ImageInput) — 要预处理的图像。期望单个或一批图像,其像素值范围为 0 到 255。如果传入的图像像素值在 0 到 1 之间,请设置 `do_rescale=False`。
  • do_resize (bool, 可选, 默认为 self.do_resize) — 是否调整图像大小。
  • size (dict[str, int], 可选, 默认为 self.size) — 调整大小后图像的尺寸。图像的最短边将调整为 size[“shortest_edge”],最长边将相应调整以保持输入图像的长宽比。
  • resample (int, 可选, 默认为 self.resample) — 如果调整图像大小,则使用的重采样滤波器。这可以是枚举 PILImageResampling 之一。仅当 do_resize 设置为 True 时有效。
  • do_center_crop (bool, 可选, 默认为 self.do_center_crop) — 是否对图像进行中心裁剪。
  • crop_size (dict[str, int], 可选, 默认为 self.crop_size) — 中心裁剪的尺寸。仅当 do_center_crop 设置为 True 时有效。
  • do_rescale (bool, 可选, 默认为 self.do_rescale) — 是否重新缩放图像。
  • rescale_factor (float, 可选, 默认为 self.rescale_factor) — 如果 do_rescale 设置为 True,则用于重新缩放图像的缩放因子。
  • do_normalize (bool, 可选, 默认为 self.do_normalize) — 是否对图像进行归一化。
  • image_mean (floatlist[float], 可选, 默认为 self.image_mean) — 用于归一化的图像均值。仅当 do_normalize 设置为 True 时有效。
  • image_std (floatlist[float], 可选, 默认为 self.image_std) — 用于归一化的图像标准差。仅在 do_normalize 设置为 True 时生效。
  • do_convert_rgb (bool, 可选, 默认为 self.do_convert_rgb) — 是否将图像转换为 RGB 格式。
  • return_tensors (strTensorType, 可选) — 返回张量的类型。可以是以下之一:
    • 未设置:返回一个 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 (ChannelDimensionstr, 可选, 默认为 ChannelDimension.FIRST) — 输出图像的通道维度格式。可以是以下之一:
    • "channels_first"ChannelDimension.FIRST:图像格式为 (num_channels, height, width)。
    • "channels_last"ChannelDimension.LAST:图像格式为 (height, width, num_channels)。
    • 未设置:使用输入图像的通道维度格式。
  • input_data_format (ChannelDimensionstr, 可选) — 输入图像的通道维度格式。如果未设置,则从输入图像中推断通道维度格式。可以是以下之一:
    • "channels_first"ChannelDimension.FIRST:图像格式为 (num_channels, height, width)。
    • "channels_last"ChannelDimension.LAST:图像格式为 (height, width, num_channels)。
    • "none"ChannelDimension.NONE:图像格式为 (height, width)。

预处理一张或一批图像。

CLIPImageProcessorFast

class transformers.CLIPImageProcessorFast

< >

( **kwargs: typing_extensions.Unpack[transformers.image_processing_utils_fast.DefaultFastImageProcessorKwargs] )

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

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:图像格式为 (num_channels, height, width)。
    • "channels_last"ChannelDimension.LAST:图像格式为 (height, width, num_channels)。
    • "none"ChannelDimension.NONE:图像格式为 (height, width)。
  • 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张量。

CLIPFeatureExtractor

class transformers.CLIPFeatureExtractor

< >

( *args **kwargs )

CLIPProcessor

class transformers.CLIPProcessor

< >

( image_processor = None tokenizer = None **kwargs )

参数

构建一个 CLIP 处理器,它将 CLIP 图像处理器和 CLIP 分词器包装成一个单一的处理器。

CLIPProcessor 提供了 CLIPImageProcessorCLIPTokenizerFast 的所有功能。更多信息请参见 __call__()decode()

batch_decode

< >

( *args **kwargs )

此方法将其所有参数转发给 CLIPTokenizerFast 的 batch_decode()。更多信息请参考该方法的文档字符串。

decode

< >

( *args **kwargs )

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

Pytorch
隐藏 Pytorch 内容

CLIPModel

class transformers.CLIPModel

< >

( config: CLIPConfig )

参数

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

基础 Clip 模型,输出原始的隐藏状态,顶部没有任何特定的头部。

此模型继承自 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 interpolate_pos_encoding: bool = False ) transformers.models.clip.modeling_clip.CLIPOutputtuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor,形状为 (batch_size, sequence_length), 可选) — 词汇表中输入序列标记的索引。默认情况下,填充将被忽略。

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

    什么是输入 ID?

  • 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] 范围内选择。

    什么是位置 ID?

  • return_loss (bool, 可选) — 是否返回对比损失。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回张量下的 attentions
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量下的 hidden_states
  • interpolate_pos_encoding (bool, 默认为 False) — 是否对预训练的位置编码进行插值。

返回

transformers.models.clip.modeling_clip.CLIPOutputtuple(torch.FloatTensor)

一个 transformers.models.clip.modeling_clip.CLIPOutput 或一个 `torch.FloatTensor` 元组(如果传递了 return_dict=False 或当 config.return_dict=False 时),根据配置 (CLIPConfig) 和输入包含各种元素。

  • loss (torch.FloatTensor,形状为 (1,), 可选, 当 return_lossTrue 时返回) — 图像-文本相似度的对比损失。
  • logits_per_image (torch.FloatTensor,形状为 (image_batch_size, text_batch_size)) — image_embedstext_embeds 之间的缩放点积得分。这表示图像-文本相似度分数。
  • logits_per_text (torch.FloatTensor,形状为 (text_batch_size, image_batch_size)) — text_embedsimage_embeds 之间的缩放点积得分。这表示文本-图像相似度分数。
  • text_embeds (torch.FloatTensor,形状为 (batch_size, output_dim)) — 将投影层应用于 CLIPTextModel 的池化输出所获得的文本嵌入。
  • image_embeds (torch.FloatTensor,形状为 (batch_size, output_dim)) — 将投影层应用于 CLIPVisionModel 的池化输出所获得的图像嵌入。
  • text_model_output (<class '~modeling_outputs.BaseModelOutputWithPooling'>.text_model_output, 默认为 None) — CLIPTextModel 的输出。
  • vision_model_output (<class '~modeling_outputs.BaseModelOutputWithPooling'>.vision_model_output, 默认为 None) — CLIPVisionModel 的输出。

CLIPModel 的 forward 方法覆盖了 __call__ 特殊方法。

尽管前向传播的流程需要在此函数内定义,但之后应调用 `Module` 实例而不是此函数,因为前者会处理运行前处理和后处理步骤,而后者会静默地忽略它们。

示例

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

>>> model = CLIPModel.from_pretrained("openai/clip-vit-base-patch32")
>>> processor = AutoProcessor.from_pretrained("openai/clip-vit-base-patch32")

>>> 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 output_attentions: typing.Optional[bool] = None output_hidden_states: 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()

    什么是输入 ID?

  • 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] 范围内选择。

    什么是位置 ID?

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

返回

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

将投影层应用于 CLIPTextModel 的池化输出所获得的文本嵌入。

示例

>>> from transformers import AutoTokenizer, CLIPModel

>>> model = CLIPModel.from_pretrained("openai/clip-vit-base-patch32")
>>> tokenizer = AutoTokenizer.from_pretrained("openai/clip-vit-base-patch32")

>>> inputs = tokenizer(["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 output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None interpolate_pos_encoding: bool = False ) image_features (形状为 `(batch_size, output_dim)` 的 `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`。
  • interpolate_pos_encoding (`bool` 类型,默认为 `False`) — 是否对预训练的位置编码进行插值。

返回

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

将投影层应用于 CLIPVisionModel 的池化输出所获得的图像嵌入。

示例

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

>>> model = CLIPModel.from_pretrained("openai/clip-vit-base-patch32")
>>> processor = AutoProcessor.from_pretrained("openai/clip-vit-base-patch32")

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

CLIPTextModel

class transformers.CLIPTextModel

< >

( config: CLIPTextConfig )

参数

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

来自 CLIP 的文本模型,顶部没有任何头或投影。

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

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

forward

< >

( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None ) transformers.modeling_outputs.BaseModelOutputWithPooling 或 `tuple(torch.FloatTensor)`

参数

  • input_ids (形状为 `(batch_size, sequence_length)` 的 `torch.Tensor`,可选) — 词汇表中输入序列标记的索引。默认情况下将忽略填充。

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

    什么是输入 ID?

  • attention_mask (形状为 `(batch_size, sequence_length)` 的 `torch.Tensor`,可选) — 用于避免对填充标记索引执行注意力的掩码。掩码值在 `[0, 1]` 中选择:

    • 1 表示标记未被遮盖
    • 0 表示标记被遮盖

    什么是注意力掩码?

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

    什么是位置 ID?

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

返回

transformers.modeling_outputs.BaseModelOutputWithPoolingtuple(torch.FloatTensor)

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

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

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

CLIPTextModel 的前向方法,覆盖了 `__call__` 特殊方法。

尽管前向传播的流程需要在此函数内定义,但之后应调用 `Module` 实例而不是此函数,因为前者会处理运行前处理和后处理步骤,而后者会静默地忽略它们。

示例

>>> from transformers import AutoTokenizer, CLIPTextModel

>>> model = CLIPTextModel.from_pretrained("openai/clip-vit-base-patch32")
>>> tokenizer = AutoTokenizer.from_pretrained("openai/clip-vit-base-patch32")

>>> inputs = tokenizer(["a photo of a cat", "a photo of a dog"], padding=True, return_tensors="pt")

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

CLIPTextModelWithProjection

class transformers.CLIPTextModelWithProjection

< >

( config: CLIPTextConfig )

参数

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

顶部带有一个投影层的 Clip 模型(池化输出顶部的一个线性层)。

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

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

forward

< >

( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None ) `transformers.models.clip.modeling_clip.CLIPTextModelOutput` 或 `tuple(torch.FloatTensor)`

参数

  • input_ids (形状为 `(batch_size, sequence_length)` 的 `torch.Tensor`,可选) — 词汇表中输入序列标记的索引。默认情况下将忽略填充。

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

    什么是输入 ID?

  • attention_mask (形状为 `(batch_size, sequence_length)` 的 `torch.Tensor`,可选) — 用于避免对填充标记索引执行注意力的掩码。掩码值在 `[0, 1]` 中选择:

    • 1 表示标记未被遮盖
    • 0 表示标记被遮盖

    什么是注意力掩码?

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

    什么是位置 ID?

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

返回

`transformers.models.clip.modeling_clip.CLIPTextModelOutput` 或 `tuple(torch.FloatTensor)`

一个 `transformers.models.clip.modeling_clip.CLIPTextModelOutput` 或一个 `torch.FloatTensor` 的元组(如果传递了 `return_dict=False` 或当 `config.return_dict=False` 时),根据配置(CLIPConfig)和输入,包含各种元素。

  • text_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` 时返回) — `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 后的注意力权重,用于计算自注意力头中的加权平均值。

CLIPTextModelWithProjection 的前向方法,覆盖了 `__call__` 特殊方法。

尽管前向传播的流程需要在此函数内定义,但之后应调用 `Module` 实例而不是此函数,因为前者会处理运行前处理和后处理步骤,而后者会静默地忽略它们。

示例

>>> from transformers import AutoTokenizer, CLIPTextModelWithProjection

>>> model = CLIPTextModelWithProjection.from_pretrained("openai/clip-vit-base-patch32")
>>> tokenizer = AutoTokenizer.from_pretrained("openai/clip-vit-base-patch32")

>>> inputs = tokenizer(["a photo of a cat", "a photo of a dog"], padding=True, return_tensors="pt")

>>> outputs = model(**inputs)
>>> text_embeds = outputs.text_embeds

CLIPVisionModelWithProjection

class transformers.CLIPVisionModelWithProjection

< >

( config: CLIPVisionConfig )

参数

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

顶部带有一个投影层的 Clip 模型(池化输出顶部的一个线性层)。

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

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

forward

< >

( pixel_values: typing.Optional[torch.FloatTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None interpolate_pos_encoding: bool = False ) `transformers.models.clip.modeling_clip.CLIPVisionModelOutput` 或 `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`。
  • interpolate_pos_encoding (`bool` 类型,默认为 `False`) — 是否对预训练的位置编码进行插值。

返回

`transformers.models.clip.modeling_clip.CLIPVisionModelOutput` 或 `tuple(torch.FloatTensor)`

一个 `transformers.models.clip.modeling_clip.CLIPVisionModelOutput` 或一个 `torch.FloatTensor` 的元组(如果传递了 `return_dict=False` 或当 `config.return_dict=False` 时),根据配置(CLIPConfig)和输入,包含各种元素。

  • 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` 时返回) — `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 后的注意力权重,用于计算自注意力头中的加权平均值。

CLIPVisionModelWithProjection 的前向方法,覆盖了 `__call__` 特殊方法。

尽管前向传播的流程需要在此函数内定义,但之后应调用 `Module` 实例而不是此函数,因为前者会处理运行前处理和后处理步骤,而后者会静默地忽略它们。

示例

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

>>> model = CLIPVisionModelWithProjection.from_pretrained("openai/clip-vit-base-patch32")
>>> processor = AutoProcessor.from_pretrained("openai/clip-vit-base-patch32")

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

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

>>> outputs = model(**inputs)
>>> image_embeds = outputs.image_embeds

CLIPVisionModel

class transformers.CLIPVisionModel

< >

( config: CLIPVisionConfig )

参数

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

来自 CLIP 的视觉模型,顶部没有任何头或投影。

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

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

forward

< >

( pixel_values: typing.Optional[torch.FloatTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: 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`。
  • interpolate_pos_encoding (`bool` 类型,默认为 `False`) — 是否对预训练的位置编码进行插值。

返回

transformers.modeling_outputs.BaseModelOutputWithPoolingtuple(torch.FloatTensor)

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

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

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

CLIPVisionModel 的前向方法,覆盖了 `__call__` 特殊方法。

尽管前向传播的流程需要在此函数内定义,但之后应调用 `Module` 实例而不是此函数,因为前者会处理运行前处理和后处理步骤,而后者会静默地忽略它们。

示例

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

>>> model = CLIPVisionModel.from_pretrained("openai/clip-vit-base-patch32")
>>> processor = AutoProcessor.from_pretrained("openai/clip-vit-base-patch32")

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

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

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

CLIPForImageClassification

class transformers.CLIPForImageClassification

< >

( config: CLIPConfig )

参数

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

带有图像分类头的 CLIP 视觉编码器(在补丁标记的池化最终隐藏状态之上加一个线性层),例如用于 ImageNet。

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

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

forward

< >

( pixel_values: typing.Optional[torch.Tensor] = None labels: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None ) transformers.modeling_outputs.ImageClassifierOutput 或 `tuple(torch.FloatTensor)`

参数

  • pixel_values (形状为 `(batch_size, num_channels, image_size, image_size)` 的 `torch.Tensor`,可选) — 对应于输入图像的张量。像素值可以使用 `{image_processor_class}` 获取。有关详细信息,请参阅 `{image_processor_class}.__call__`(`{processor_class}` 使用 `{image_processor_class}` 处理图像)。
  • labels (形状为 `(batch_size,)` 的 `torch.LongTensor`,可选) — 用于计算图像分类/回归损失的标签。索引应在 `[0, ..., config.num_labels - 1]` 范围内。如果 `config.num_labels == 1`,则计算回归损失(均方损失),如果 `config.num_labels > 1`,则计算分类损失(交叉熵)。
  • output_attentions (`bool` 类型,可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的 `attentions`。
  • output_hidden_states (`bool` 类型,可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的 `hidden_states`。

返回

transformers.modeling_outputs.ImageClassifierOutputtuple(torch.FloatTensor)

一个 transformers.modeling_outputs.ImageClassifierOutput 或一个 `torch.FloatTensor` 的元组(如果传递了 `return_dict=False` 或 `config.return_dict=False`),包含的各种元素取决于配置(CLIPConfig)和输入。

  • loss (形状为 (1,)torch.FloatTensor可选,当提供 labels 时返回) — 分类损失(如果 config.num_labels==1,则为回归损失)。

  • logits (形状为 (batch_size, config.num_labels)torch.FloatTensor) — 分类(如果 config.num_labels==1,则为回归)分数(SoftMax 之前)。

  • hidden_states (tuple(torch.FloatTensor), 可选, 当传递 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回) — `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, patch_size, sequence_length)`。

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

CLIPForImageClassification 的 forward 方法覆盖了 `__call__` 特殊方法。

尽管前向传播的流程需要在此函数内定义,但之后应调用 `Module` 实例而不是此函数,因为前者会处理运行前处理和后处理步骤,而后者会静默地忽略它们。

示例

>>> from transformers import AutoImageProcessor, CLIPForImageClassification
>>> import torch
>>> from datasets import load_dataset

>>> dataset = load_dataset("huggingface/cats-image")
>>> image = dataset["test"]["image"][0]

>>> image_processor = AutoImageProcessor.from_pretrained("openai/clip-vit-base-patch32")
>>> model = CLIPForImageClassification.from_pretrained("openai/clip-vit-base-patch32")

>>> inputs = image_processor(image, return_tensors="pt")

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

>>> # model predicts one of the 1000 ImageNet classes
>>> predicted_label = logits.argmax(-1).item()
>>> print(model.config.id2label[predicted_label])
...
TensorFlow
隐藏 TensorFlow 内容

TFCLIPModel

class transformers.TFCLIPModel

< >

( config: CLIPConfig *inputs **kwargs )

参数

  • config (CLIPConfig) — 包含模型所有参数的模型配置类。使用配置文件进行初始化不会加载与模型相关的权重,只会加载配置。请查阅 from_pretrained() 方法来加载模型权重。

该模型继承自 TFPreTrainedModel。请查阅超类文档,了解库为所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、修剪注意力头等)。

该模型也是 keras.Model 的子类。可以像常规的 TF 2.0 Keras 模型一样使用它,并参考 TF 2.0 文档了解所有与通用用法和行为相关的事项。

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

  • 所有输入作为关键字参数(如 PyTorch 模型),或
  • 所有输入作为第一个位置参数中的列表、元组或字典。

支持第二种格式的原因是,Keras 方法在向模型和层传递输入时更倾向于这种格式。由于这种支持,当使用 `model.fit()` 等方法时,一切应该会“自然而然地”工作——只需以 `model.fit()` 支持的任何格式传递您的输入和标签即可!然而,如果您想在 `fit()` 和 `predict()` 等 Keras 方法之外使用第二种格式,例如在使用 Keras `Functional` API 创建自己的层或模型时,有三种可能性可以用来将所有输入张量收集到第一个位置参数中。

  • 只有一个 input_ids 的单个张量,没有其他:model(input_ids)
  • 长度可变的列表,包含一个或多个输入张量,按文档字符串中给出的顺序:model([input_ids, attention_mask])model([input_ids, attention_mask, token_type_ids])
  • 一个字典,其中包含一个或多个与文档字符串中给出的输入名称关联的输入张量:model({"input_ids": input_ids, "token_type_ids": token_type_ids})

请注意,当使用子类化创建模型和层时,您无需担心这些问题,因为您可以像调用任何其他 Python 函数一样传递输入!

调用

< >

( input_ids: TFModelInputType | None = None pixel_values: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | 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: bool = False ) transformers.models.clip.modeling_tf_clip.TFCLIPOutputtuple(tf.Tensor)

参数

  • input_ids (np.ndarraytf.Tensorlist[tf.Tensor]、`dict[str, tf.Tensor]dict[str, np.ndarray],每个样本形状必须为 `(batch_size, sequence_length)`) — 词汇表中输入序列标记的索引。

    索引可以使用 AutoTokenizer 获得。详情请参阅 PreTrainedTokenizer.call()PreTrainedTokenizer.encode()

    什么是输入 ID?

  • pixel_values (np.ndarraytf.Tensorlist[tf.Tensor]dict[str, tf.Tensor]dict[str, np.ndarray],每个样本形状必须为 `(batch_size, num_channels, height, width)`) — 像素值。像素值可以使用 AutoImageProcessor 获得。详情请参阅 CLIPImageProcessor.call()
  • attention_mask (np.ndarraytf.Tensor,形状为 `(batch_size, sequence_length)`,可选) — 用于避免对填充标记索引执行注意力计算的掩码。掩码值选自 `[0, 1]`:

    • 1 表示标记未被掩码
    • 0 表示标记已被掩码

    什么是注意力掩码?

  • position_ids (np.ndarraytf.Tensor,形状为 `(batch_size, sequence_length)`,可选) — 位置嵌入中每个输入序列标记的位置索引。取值范围为 `[0, config.max_position_embeddings - 1]`。

    什么是位置 ID?

  • return_loss (bool, 可选) — 是否返回对比损失。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。更多细节请参阅返回张量下的 `attentions`。该参数只能在 Eager 模式下使用,在图模式下将使用配置中的值。
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。更多细节请参阅返回张量下的 `hidden_states`。该参数只能在 Eager 模式下使用,在图模式下将使用配置中的值。
  • return_dict (bool, 可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。该参数可以在 Eager 模式下使用,在图模式下该值将始终设置为 True。
  • training (bool, 可选, 默认为 `False`) — 是否将模型用于训练模式(一些模块如 dropout 模块在训练和评估之间有不同的行为)。

返回

transformers.models.clip.modeling_tf_clip.TFCLIPOutputtuple(tf.Tensor)

一个 `transformers.models.clip.modeling_tf_clip.TFCLIPOutput` 或 `tf.Tensor` 的元组(如果传递了 `return_dict=False` 或 `config.return_dict=False`),包含的各种元素取决于配置(`<class 'transformers.models.clip.configuration_clip.CLIPConfig'>`)和输入。

  • loss (tf.Tensor,形状为 (1,)可选,当 return_lossTrue 时返回) — 图像-文本相似度的对比损失。
  • 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`) — 将投影层应用于 TFCLIPTextModel 的池化输出所获得的文本嵌入。
  • image_embeds(tf.Tensor,形状为 `(batch_size, output_dim`) — 将投影层应用于 TFCLIPVisionModel 的池化输出所获得的图像嵌入。
  • text_model_output(~modeling_tf_utils.TFBaseModelOutputWithPooling): TFCLIPTextModel 的输出。
  • vision_model_output(~modeling_tf_utils.TFBaseModelOutputWithPooling): TFCLIPVisionModel 的输出。

TFCLIPModel 的 forward 方法覆盖了 `__call__` 特殊方法。

尽管前向传播的流程需要在此函数内定义,但之后应调用 `Module` 实例而不是此函数,因为前者会处理运行前处理和后处理步骤,而后者会静默地忽略它们。

示例

>>> import tensorflow as tf
>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, TFCLIPModel

>>> model = TFCLIPModel.from_pretrained("openai/clip-vit-base-patch32")
>>> processor = AutoProcessor.from_pretrained("openai/clip-vit-base-patch32")

>>> 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: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: bool = False ) text_features (tf.Tensor,形状为 `(batch_size, output_dim`)

参数

  • input_ids (np.ndarraytf.Tensorlist[tf.Tensor]、`dict[str, tf.Tensor]dict[str, np.ndarray],每个样本形状必须为 `(batch_size, sequence_length)`) — 词汇表中输入序列标记的索引。

    索引可以使用 AutoTokenizer 获得。详情请参阅 PreTrainedTokenizer.call()PreTrainedTokenizer.encode()

    什么是输入 ID?

  • attention_mask (np.ndarraytf.Tensor,形状为 `(batch_size, sequence_length)`,可选) — 用于避免对填充标记索引执行注意力计算的掩码。掩码值选自 `[0, 1]`:

    • 1 表示标记未被掩码
    • 0 表示标记已被掩码

    什么是注意力掩码?

  • position_ids (np.ndarraytf.Tensor,形状为 `(batch_size, sequence_length)`,可选) — 位置嵌入中每个输入序列标记的位置索引。取值范围为 `[0, config.max_position_embeddings - 1]`。

    什么是位置 ID?

  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。更多细节请参阅返回张量下的 `attentions`。该参数只能在 Eager 模式下使用,在图模式下将使用配置中的值。
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。更多细节请参阅返回张量下的 `hidden_states`。该参数只能在 Eager 模式下使用,在图模式下将使用配置中的值。
  • return_dict (bool, 可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。该参数可以在 Eager 模式下使用,在图模式下该值将始终设置为 True。
  • training (bool, 可选, 默认为 `False`) — 是否将模型用于训练模式(一些模块如 dropout 模块在训练和评估之间有不同的行为)。

返回

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

将投影层应用于 TFCLIPTextModel 的池化输出所获得的文本嵌入。

TFCLIPModel 的 forward 方法覆盖了 `__call__` 特殊方法。

尽管前向传播的流程需要在此函数内定义,但之后应调用 `Module` 实例而不是此函数,因为前者会处理运行前处理和后处理步骤,而后者会静默地忽略它们。

示例

>>> from transformers import AutoTokenizer, TFCLIPModel

>>> model = TFCLIPModel.from_pretrained("openai/clip-vit-base-patch32")
>>> tokenizer = AutoTokenizer.from_pretrained("openai/clip-vit-base-patch32")

>>> inputs = tokenizer(["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: TFModelInputType | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: bool = False ) image_features (tf.Tensor,形状为 `(batch_size, output_dim`)

参数

  • pixel_values (np.ndarraytf.Tensorlist[tf.Tensor]、`dict[str, tf.Tensor]dict[str, np.ndarray],每个样本形状必须为 `(batch_size, num_channels, height, width)`) — 像素值。像素值可以使用 AutoImageProcessor 获得。详情请参阅 CLIPImageProcessor.call()。 output_attentions (bool, 可选): 是否返回所有注意力层的注意力张量。更多细节请参阅返回张量下的 `attentions`。该参数只能在 Eager 模式下使用,在图模式下将使用配置中的值。
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。更多细节请参阅返回张量下的 `hidden_states`。该参数只能在 Eager 模式下使用,在图模式下将使用配置中的值。
  • return_dict (bool, 可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。该参数可以在 Eager 模式下使用,在图模式下该值将始终设置为 True。
  • training (bool, 可选, 默认为 `False`) — 是否将模型用于训练模式(一些模块如 dropout 模块在训练和评估之间有不同的行为)。

返回

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

将投影层应用于 TFCLIPVisionModel 的池化输出所获得的图像嵌入。

TFCLIPModel 的 forward 方法覆盖了 `__call__` 特殊方法。

尽管前向传播的流程需要在此函数内定义,但之后应调用 `Module` 实例而不是此函数,因为前者会处理运行前处理和后处理步骤,而后者会静默地忽略它们。

示例

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

>>> model = TFCLIPModel.from_pretrained("openai/clip-vit-base-patch32")
>>> processor = AutoProcessor.from_pretrained("openai/clip-vit-base-patch32")

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

TFCLIPTextModel

class transformers.TFCLIPTextModel

< >

( config: CLIPTextConfig *inputs **kwargs )

调用

< >

( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: Optional[bool] = False ) transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingtuple(tf.Tensor)

参数

  • input_ids (np.ndarraytf.Tensorlist[tf.Tensor]、`dict[str, tf.Tensor]dict[str, np.ndarray],每个样本形状必须为 `(batch_size, sequence_length)`) — 词汇表中输入序列标记的索引。

    索引可以使用 AutoTokenizer 获得。详情请参阅 PreTrainedTokenizer.call()PreTrainedTokenizer.encode()

    什么是输入 ID?

  • attention_mask (np.ndarraytf.Tensor,形状为 `(batch_size, sequence_length)`,可选) — 用于避免对填充标记索引执行注意力计算的掩码。掩码值选自 `[0, 1]`:

    • 1 表示标记未被掩码
    • 0 表示标记已被掩码

    什么是注意力掩码?

  • position_ids (np.ndarraytf.Tensor,形状为 `(batch_size, sequence_length)`,可选) — 位置嵌入中每个输入序列标记的位置索引。取值范围为 `[0, config.max_position_embeddings - 1]`。

    什么是位置 ID?

  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。更多细节请参阅返回张量下的 `attentions`。该参数只能在 Eager 模式下使用,在图模式下将使用配置中的值。
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。更多细节请参阅返回张量下的 `hidden_states`。该参数只能在 Eager 模式下使用,在图模式下将使用配置中的值。
  • return_dict (bool, 可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。该参数可以在 Eager 模式下使用,在图模式下该值将始终设置为 True。
  • training (bool, 可选, 默认为 `False`) — 是否将模型用于训练模式(一些模块如 dropout 模块在训练和评估之间有不同的行为)。

返回

transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingtuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling 或一个 `tf.Tensor` 的元组(如果传递了 `return_dict=False` 或 `config.return_dict=False`),包含的各种元素取决于配置(`<class 'transformers.models.clip.configuration_clip.CLIPTextConfig'>`)和输入。

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

  • pooler_output (tf.Tensor,形状为 `(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 后的注意力权重,用于计算自注意力头中的加权平均值。

TFCLIPTextModel 的 forward 方法覆盖了 `__call__` 特殊方法。

尽管前向传播的流程需要在此函数内定义,但之后应调用 `Module` 实例而不是此函数,因为前者会处理运行前处理和后处理步骤,而后者会静默地忽略它们。

示例

>>> from transformers import AutoTokenizer, TFCLIPTextModel

>>> model = TFCLIPTextModel.from_pretrained("openai/clip-vit-base-patch32")
>>> tokenizer = AutoTokenizer.from_pretrained("openai/clip-vit-base-patch32")

>>> inputs = tokenizer(["a photo of a cat", "a photo of a dog"], padding=True, return_tensors="tf")

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

TFCLIPVisionModel

class transformers.TFCLIPVisionModel

< >

( config: CLIPVisionConfig *inputs **kwargs )

调用

< >

( pixel_values: TFModelInputType | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: Optional[bool] = False ) transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingtuple(tf.Tensor)

参数

  • pixel_values (np.ndarraytf.Tensorlist[tf.Tensor]、`dict[str, tf.Tensor]dict[str, np.ndarray],每个样本形状必须为 `(batch_size, num_channels, height, width)`) — 像素值。像素值可以使用 AutoImageProcessor 获得。详情请参阅 CLIPImageProcessor.call()。 output_attentions (bool, 可选): 是否返回所有注意力层的注意力张量。更多细节请参阅返回张量下的 `attentions`。该参数只能在 Eager 模式下使用,在图模式下将使用配置中的值。
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。更多细节请参阅返回张量下的 `hidden_states`。该参数只能在 Eager 模式下使用,在图模式下将使用配置中的值。
  • return_dict (bool, 可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。该参数可以在 Eager 模式下使用,在图模式下该值将始终设置为 True。
  • training (bool, 可选, 默认为 `False`) — 是否将模型用于训练模式(一些模块如 dropout 模块在训练和评估之间有不同的行为)。

返回

transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingtuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling 或一个 `tf.Tensor` 的元组(如果传递了 `return_dict=False` 或 `config.return_dict=False`),包含的各种元素取决于配置(`<class 'transformers.models.clip.configuration_clip.CLIPVisionConfig'>`)和输入。

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

  • pooler_output (tf.Tensor,形状为 `(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 后的注意力权重,用于计算自注意力头中的加权平均值。

TFCLIPVisionModel 的 forward 方法覆盖了 `__call__` 特殊方法。

尽管前向传播的流程需要在此函数内定义,但之后应调用 `Module` 实例而不是此函数,因为前者会处理运行前处理和后处理步骤,而后者会静默地忽略它们。

示例

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

>>> model = TFCLIPVisionModel.from_pretrained("openai/clip-vit-base-patch32")
>>> processor = AutoProcessor.from_pretrained("openai/clip-vit-base-patch32")

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

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

>>> outputs = model(**inputs)
>>> last_hidden_state = outputs.last_hidden_state
>>> pooled_output = outputs.pooler_output  # pooled CLS states
JAX
隐藏 JAX 内容

FlaxCLIPModel

class transformers.FlaxCLIPModel

< >

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

参数

  • config (CLIPConfig) — 包含模型所有参数的模型配置类。使用配置文件进行初始化不会加载与模型相关的权重,只会加载配置。请查阅 from_pretrained() 方法来加载模型权重。
  • dtype (jax.numpy.dtype, 可选, 默认为 jax.numpy.float32) — 计算时的数据类型。可以是 jax.numpy.float32jax.numpy.float16 (在 GPU 上) 和 jax.numpy.bfloat16 (在 TPU 上) 中的一种。

    这可用于在 GPU 或 TPU 上启用混合精度训练或半精度推理。如果指定了该参数,所有计算都将使用给定的 dtype 执行。

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

    如果您希望更改模型参数的数据类型,请参阅 to_fp16()to_bf16()

此模型继承自 FlaxPreTrainedModel。查阅父类的文档以了解该库为所有模型实现的通用方法(例如下载、保存和转换 PyTorch 模型的权重)。

该模型也是一个 flax.linen.Module 子类。可以像常规的 Flax linen Module 一样使用它,并参考 Flax 文档了解所有与通用用法和行为相关的事项。

最后,此模型支持固有的 JAX 功能,例如

__call__

< >

( input_ids pixel_values attention_mask = None position_ids = None params: typing.Optional[dict] = None dropout_rng: <function PRNGKey at 0x7effc7ad3a30> = None train: bool = False output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) transformers.models.clip.modeling_flax_clip.FlaxCLIPOutputtuple(torch.FloatTensor)

参数

  • input_ids (numpy.ndarray,形状为 (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。如果提供填充,默认将被忽略。

    索引可以使用 AutoTokenizer 获得。详情请参阅 PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

    什么是输入 ID?

  • attention_mask (numpy.ndarray,形状为 (batch_size, sequence_length), 可选) — 用于避免对填充标记索引执行注意力操作的掩码。掩码值选自 [0, 1]

    • 1 表示标记未被遮盖
    • 0 表示标记已被遮盖

    什么是注意力掩码?

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

    什么是位置 ID?

  • pixel_values (numpy.ndarray,形状为 (batch_size, num_channels, height, width)) — 像素值。如果提供填充,默认将被忽略。像素值可以使用 AutoImageProcessor 获得。详情请参阅 CLIPImageProcessor.call()
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。更多细节请参阅返回张量下的 attentions
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。更多细节请参阅返回张量下的 hidden_states
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。

返回

transformers.models.clip.modeling_flax_clip.FlaxCLIPOutputtuple(torch.FloatTensor)

一个 transformers.models.clip.modeling_flax_clip.FlaxCLIPOutput 或一个 torch.FloatTensor 元组(如果传递了 return_dict=False 或当 config.return_dict=False 时),根据配置(<class 'transformers.models.clip.configuration_clip.CLIPConfig'>)和输入,包含各种元素。

  • logits_per_image:(jnp.ndarray,形状为 (image_batch_size, text_batch_size)) — image_embedstext_embeds 之间的缩放点积得分。这表示图文相似性得分。
  • logits_per_text:(jnp.ndarray,形状为 (text_batch_size, image_batch_size)) — text_embedsimage_embeds 之间的缩放点积得分。这表示文图相似性得分。
  • text_embeds(jnp.ndarray,形状为 (batch_size, output_dim)) — 通过将投影层应用于 FlaxCLIPTextModel 的池化输出而获得的文本嵌入。
  • image_embeds(jnp.ndarray,形状为 (batch_size, output_dim)) — 通过将投影层应用于 FlaxCLIPVisionModel 的池化输出而获得的图像嵌入。
  • text_model_output(FlaxBaseModelOutputWithPooling): FlaxCLIPTextModel 的输出。
  • vision_model_output(FlaxBaseModelOutputWithPooling): FlaxCLIPVisionModel 的输出。

FlaxCLIPPreTrainedModel 的前向方法重写了 __call__ 特殊方法。

尽管前向传播的流程需要在此函数内定义,但之后应调用 `Module` 实例而不是此函数,因为前者会处理运行前处理和后处理步骤,而后者会静默地忽略它们。

示例

>>> import jax
>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, FlaxCLIPModel

>>> model = FlaxCLIPModel.from_pretrained("openai/clip-vit-base-patch32")
>>> processor = AutoProcessor.from_pretrained("openai/clip-vit-base-patch32")

>>> 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="np", padding=True
... )

>>> outputs = model(**inputs)
>>> logits_per_image = outputs.logits_per_image  # this is the image-text similarity score
>>> probs = jax.nn.softmax(logits_per_image, axis=1)  # we can take the softmax to get the label probabilities

get_text_features

< >

( input_ids attention_mask = None position_ids = None params: typing.Optional[dict] = None dropout_rng: <function PRNGKey at 0x7effc7ad3a30> = None train = False ) text_features (jnp.ndarray,形状为 (batch_size, output_dim))

参数

返回

text_features (jnp.ndarray,形状为 (batch_size, output_dim))

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

示例

>>> from transformers import AutoTokenizer, FlaxCLIPModel

>>> model = FlaxCLIPModel.from_pretrained("openai/clip-vit-base-patch32")
>>> tokenizer = AutoTokenizer.from_pretrained("openai/clip-vit-base-patch32")

>>> inputs = tokenizer(["a photo of a cat", "a photo of a dog"], padding=True, return_tensors="np")
>>> text_features = model.get_text_features(**inputs)

get_image_features

< >

( pixel_values params: typing.Optional[dict] = None dropout_rng: <function PRNGKey at 0x7effc7ad3a30> = None train = False ) image_features (jnp.ndarray,形状为 (batch_size, output_dim))

参数

  • pixel_values (numpy.ndarray,形状为 (batch_size, num_channels, height, width)) — 像素值。如果提供填充,默认将被忽略。像素值可以使用 AutoImageProcessor 获得。详情请参阅 CLIPImageProcessor.call()

返回

image_features (jnp.ndarray,形状为 (batch_size, output_dim))

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

示例

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

>>> model = FlaxCLIPModel.from_pretrained("openai/clip-vit-base-patch32")
>>> processor = AutoProcessor.from_pretrained("openai/clip-vit-base-patch32")

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

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

>>> image_features = model.get_image_features(**inputs)

FlaxCLIPTextModel

class transformers.FlaxCLIPTextModel

< >

( config: CLIPTextConfig input_shape = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )

__call__

< >

( input_ids attention_mask = None position_ids = None params: typing.Optional[dict] = None dropout_rng: <function PRNGKey at 0x7effc7ad3a30> = None train: bool = False output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPoolingtuple(torch.FloatTensor)

参数

  • input_ids (numpy.ndarray,形状为 (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。如果提供填充,默认将被忽略。

    索引可以使用 AutoTokenizer 获得。详情请参阅 PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

    什么是输入 ID?

  • attention_mask (numpy.ndarray,形状为 (batch_size, sequence_length), 可选) — 用于避免对填充标记索引执行注意力操作的掩码。掩码值选自 [0, 1]

    • 1 表示标记未被遮盖
    • 0 表示标记已被遮盖

    什么是注意力掩码?

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

    什么是位置 ID?

  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。更多细节请参阅返回张量下的 attentions
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。更多细节请参阅返回张量下的 hidden_states
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。

返回

transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPoolingtuple(torch.FloatTensor)

一个 transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPooling 或一个 torch.FloatTensor 元组(如果传递了 return_dict=False 或当 config.return_dict=False 时),根据配置(<class 'transformers.models.clip.configuration_clip.CLIPTextConfig'>)和输入,包含各种元素。

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

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

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

    模型在每个层输出的隐藏状态加上初始嵌入输出。

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

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

FlaxCLIPTextPreTrainedModel 的前向方法重写了 __call__ 特殊方法。

尽管前向传播的流程需要在此函数内定义,但之后应调用 `Module` 实例而不是此函数,因为前者会处理运行前处理和后处理步骤,而后者会静默地忽略它们。

示例

>>> from transformers import AutoTokenizer, FlaxCLIPTextModel

>>> model = FlaxCLIPTextModel.from_pretrained("openai/clip-vit-base-patch32")
>>> tokenizer = AutoTokenizer.from_pretrained("openai/clip-vit-base-patch32")

>>> inputs = tokenizer(["a photo of a cat", "a photo of a dog"], padding=True, return_tensors="np")

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

FlaxCLIPTextModelWithProjection

class transformers.FlaxCLIPTextModelWithProjection

< >

( config: CLIPTextConfig input_shape = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )

__call__

< >

( input_ids attention_mask = None position_ids = None params: typing.Optional[dict] = None dropout_rng: <function PRNGKey at 0x7effc7ad3a30> = None train: bool = False output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) transformers.models.clip.modeling_flax_clip.FlaxCLIPTextModelOutputtuple(torch.FloatTensor)

参数

  • input_ids (numpy.ndarray,形状为 (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。如果提供填充,默认将被忽略。

    索引可以使用 AutoTokenizer 获得。详情请参阅 PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

    什么是输入 ID?

  • attention_mask (numpy.ndarray,形状为 (batch_size, sequence_length), 可选) — 用于避免对填充标记索引执行注意力操作的掩码。掩码值选自 [0, 1]

    • 1 表示标记未被遮盖
    • 0 表示标记已被遮盖

    什么是注意力掩码?

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

    什么是位置 ID?

  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。更多细节请参阅返回张量下的 attentions
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。更多细节请参阅返回张量下的 hidden_states
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。

返回

transformers.models.clip.modeling_flax_clip.FlaxCLIPTextModelOutputtuple(torch.FloatTensor)

一个 transformers.models.clip.modeling_flax_clip.FlaxCLIPTextModelOutput 或一个 torch.FloatTensor 元组(如果传递了 return_dict=False 或当 config.return_dict=False 时),根据配置(<class 'transformers.models.clip.configuration_clip.CLIPTextConfig'>)和输入,包含各种元素。

  • text_embeds (jnp.ndarray,形状为 (batch_size, output_dim)) — 通过将投影层应用于 FlaxCLIPTextModel 的池化输出而获得的文本嵌入。

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

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

    模型在每个层输出的隐藏状态加上初始嵌入输出。

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

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

FlaxCLIPTextPreTrainedModel 的前向方法重写了 __call__ 特殊方法。

尽管前向传播的流程需要在此函数内定义,但之后应调用 `Module` 实例而不是此函数,因为前者会处理运行前处理和后处理步骤,而后者会静默地忽略它们。

示例

>>> from transformers import AutoTokenizer, FlaxCLIPTextModelWithProjection

>>> model = FlaxCLIPTextModelWithProjection.from_pretrained("openai/clip-vit-base-patch32")
>>> tokenizer = AutoTokenizer.from_pretrained("openai/clip-vit-base-patch32")

>>> inputs = tokenizer(["a photo of a cat", "a photo of a dog"], padding=True, return_tensors="np")

>>> outputs = model(**inputs)
>>> text_embeds = outputs.text_embeds

FlaxCLIPVisionModel

class transformers.FlaxCLIPVisionModel

< >

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

__call__

< >

( pixel_values params: typing.Optional[dict] = None dropout_rng: <function PRNGKey at 0x7effc7ad3a30> = None train: bool = False output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPoolingtuple(torch.FloatTensor)

参数

  • pixel_values (numpy.ndarray,形状为 (batch_size, num_channels, height, width)) — 像素值。如果您提供填充(Padding),默认情况下它将被忽略。像素值可以使用 AutoImageProcessor 获取。有关详细信息,请参阅 CLIPImageProcessor.call()
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的 attentions
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的 hidden_states
  • return_dict (bool, 可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。

返回

transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPoolingtuple(torch.FloatTensor)

transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPooling 或一个 torch.FloatTensor 的元组(如果传递了 return_dict=False 或当 config.return_dict=False 时),根据配置(<class 'transformers.models.clip.configuration_clip.CLIPVisionConfig'>)和输入包含各种元素。

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

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

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

    模型在每个层输出的隐藏状态加上初始嵌入输出。

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

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

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

尽管前向传播的流程需要在此函数内定义,但之后应调用 `Module` 实例而不是此函数,因为前者会处理运行前处理和后处理步骤,而后者会静默地忽略它们。

示例

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

>>> model = FlaxCLIPVisionModel.from_pretrained("openai/clip-vit-base-patch32")
>>> processor = AutoProcessor.from_pretrained("openai/clip-vit-base-patch32")

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

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

>>> outputs = model(**inputs)
>>> last_hidden_state = outputs.last_hidden_state
>>> pooler_output = outputs.pooler_output  # pooled CLS states
< > 在 GitHub 上更新