Transformers 文档
CLIP
并获得增强的文档体验
开始使用
CLIP
CLIP 是一个多模态视觉和语言模型,其动机是为了克服训练计算机视觉模型时对象类别数量固定的问题。CLIP 通过对 4 亿个(图像,文本)对进行联合训练,直接从原始文本中学习图像。这种规模的预训练使其能够零样本迁移到下游任务。CLIP 使用图像编码器和文本编码器来获取视觉特征和文本特征。这两种特征都被投影到具有相同维数的潜在空间中,它们的点积给出了相似度分数。
你可以在 OpenAI 组织下找到所有原始的 CLIP 检查点。
点击右侧边栏中的 CLIP 模型,查看更多如何将 CLIP 应用于不同图像和语言任务的示例。
下面的示例演示了如何使用 Pipeline 或 AutoModel 类来计算多个文本描述和一张图像之间的相似度分数。
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)
注意
- 使用 CLIPImageProcessor 来调整(或缩放)和归一化模型所需的图像。
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
从 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 (
str
或function
, 可选, 默认为"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 (
str
或function
, 可选, 默认为"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]
通过连接和添加特殊词元,从一个序列或一对序列中为序列分类任务构建模型输入。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]
从没有添加特殊标记的标记列表中检索序列ID。此方法在使用分词器prepare_for_model
方法添加特殊标记时调用。
create_token_type_ids_from_sequences
< 来源 >( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None ) → list[int]
从传入的两个序列创建掩码。CLIP 不使用词元类型 ID,因此返回一个零列表。
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]
通过连接和添加特殊词元,从一个序列或一对序列中为序列分类任务构建模型输入。CLIP 序列具有以下格式:
- 单个序列:
<|startoftext|> X <|endoftext|>
序列对不是预期的使用情况,但它们将在没有分隔符的情况下被处理。
create_token_type_ids_from_sequences
< 来源 >( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None ) → 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
orfloat
, 可选, 默认为1/255
) — 如果重新缩放图像,则使用的缩放因子。可在preprocess
方法中通过 `rescale_factor` 参数覆盖。 - do_normalize (
bool
, 可选, 默认为True
) — 是否对图像进行归一化。可在preprocess
方法中通过 `do_normalize` 参数覆盖。 - image_mean (
float
或list[float]
, 可选, 默认为[0.48145466, 0.4578275, 0.40821073]
) — 如果对图像进行归一化,则使用的均值。这是一个浮点数或浮点数列表,其长度等于图像中的通道数。可在preprocess
方法中通过image_mean
参数覆盖。 - image_std (
float
或list[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 (
float
或list[float]
, 可选, 默认为self.image_mean
) — 用于归一化的图像均值。仅当do_normalize
设置为True
时有效。 - image_std (
float
或list[float]
, 可选, 默认为self.image_std
) — 用于归一化的图像标准差。仅在do_normalize
设置为True
时生效。 - do_convert_rgb (
bool
, 可选, 默认为self.do_convert_rgb
) — 是否将图像转换为 RGB 格式。 - return_tensors (
str
或TensorType
, 可选) — 返回张量的类型。可以是以下之一:- 未设置:返回一个
np.ndarray
列表。 TensorType.TENSORFLOW
或'tf'
:返回一个tf.Tensor
类型的批次。TensorType.PYTORCH
或'pt'
:返回一个torch.Tensor
类型的批次。TensorType.NUMPY
或'np'
:返回一个np.ndarray
类型的批次。TensorType.JAX
或'jax'
:返回一个jax.numpy.ndarray
类型的批次。
- 未设置:返回一个
- data_format (
ChannelDimension
或str
, 可选, 默认为ChannelDimension.FIRST
) — 输出图像的通道维度格式。可以是以下之一:"channels_first"
或ChannelDimension.FIRST
:图像格式为 (num_channels, height, width)。"channels_last"
或ChannelDimension.LAST
:图像格式为 (height, width, num_channels)。- 未设置:使用输入图像的通道维度格式。
- input_data_format (
ChannelDimension
或str
, 可选) — 输入图像的通道维度格式。如果未设置,则从输入图像中推断通道维度格式。可以是以下之一:"channels_first"
或ChannelDimension.FIRST
:图像格式为 (num_channels, height, width)。"channels_last"
或ChannelDimension.LAST
:图像格式为 (height, width, num_channels)。"none"
或ChannelDimension.NONE
:图像格式为 (height, width)。
预处理一张或一批图像。
CLIPImageProcessorFast
class transformers.CLIPImageProcessorFast
< source >( **kwargs: typing_extensions.Unpack[transformers.image_processing_utils_fast.DefaultFastImageProcessorKwargs] )
构建一个快速 Clip 图像处理器。
preprocess
< source >( 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
CLIPProcessor
class transformers.CLIPProcessor
< source >( image_processor = None tokenizer = None **kwargs )
参数
- image_processor (CLIPImageProcessor, 可选) — 图像处理器是必需的输入。
- tokenizer (CLIPTokenizerFast, 可选) — 分词器是必需的输入。
构建一个 CLIP 处理器,它将 CLIP 图像处理器和 CLIP 分词器包装成一个单一的处理器。
CLIPProcessor 提供了 CLIPImageProcessor 和 CLIPTokenizerFast 的所有功能。更多信息请参见 __call__()
和 decode()。
此方法将其所有参数转发给 CLIPTokenizerFast 的 batch_decode()。更多信息请参考该方法的文档字符串。
此方法将其所有参数转发给 CLIPTokenizerFast 的 decode()。有关更多信息,请参阅此方法的文档字符串。
CLIPModel
class transformers.CLIPModel
< source >( config: CLIPConfig )
参数
- config (CLIPConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只会加载配置。请查看 from_pretrained() 方法来加载模型权重。
基础 Clip 模型,输出原始的隐藏状态,顶部没有任何特定的头部。
此模型继承自 PreTrainedModel。请查看超类文档以了解该库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、修剪头部等)。
此模型也是 PyTorch torch.nn.Module 的子类。可以像常规的 PyTorch 模块一样使用它,并参考 PyTorch 文档了解所有与通用用法和行为相关的事项。
forward
< source >( 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.CLIPOutput
或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor
,形状为(batch_size, sequence_length)
, 可选) — 词汇表中输入序列标记的索引。默认情况下,填充将被忽略。可以使用 AutoTokenizer 获取索引。有关详细信息,请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- pixel_values (
torch.FloatTensor
,形状为(batch_size, num_channels, image_size, image_size)
, 可选) — 对应于输入图像的张量。可以使用{image_processor_class}
获取像素值。有关详细信息,请参见{image_processor_class}.__call__
({processor_class}
使用{image_processor_class}
处理图像)。 - attention_mask (
torch.Tensor
,形状为(batch_size, sequence_length)
, 可选) — 用于避免对填充标记索引执行注意力的掩码。掩码值在[0, 1]
中选择:- 1 表示**未被掩码**的标记,
- 0 表示**被掩码**的标记。
- position_ids (
torch.LongTensor
,形状为(batch_size, sequence_length)
, 可选) — 每个输入序列标记在位置嵌入中的位置索引。在[0, config.n_positions - 1]
范围内选择。 - return_loss (
bool
, 可选) — 是否返回对比损失。 - output_attentions (
bool
, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回张量下的attentions
。 - output_hidden_states (
bool
, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量下的hidden_states
。 - interpolate_pos_encoding (
bool
, 默认为False
) — 是否对预训练的位置编码进行插值。
返回
transformers.models.clip.modeling_clip.CLIPOutput
或 tuple(torch.FloatTensor)
一个 transformers.models.clip.modeling_clip.CLIPOutput
或一个 `torch.FloatTensor` 元组(如果传递了 return_dict=False
或当 config.return_dict=False
时),根据配置 (CLIPConfig) 和输入包含各种元素。
- 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)
) — 将投影层应用于 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
< source >( 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()。
- 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]
范围内选择。 - 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
< source >( 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__()。
- 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]` 范围内选择。
- output_attentions (`bool` 类型,可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的 `attentions`。
- output_hidden_states (`bool` 类型,可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的 `hidden_states`。
返回
transformers.modeling_outputs.BaseModelOutputWithPooling 或 tuple(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__()。
- 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]` 范围内选择。
- 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.BaseModelOutputWithPooling 或 tuple(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.ImageClassifierOutput 或 tuple(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])
...
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.TFCLIPOutput
或 tuple(tf.Tensor)
参数
- input_ids (
np.ndarray
、tf.Tensor
、list[tf.Tensor]
、`dict[str, tf.Tensor]
或dict[str, np.ndarray]
,每个样本形状必须为 `(batch_size, sequence_length)`) — 词汇表中输入序列标记的索引。索引可以使用 AutoTokenizer 获得。详情请参阅 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。
- pixel_values (
np.ndarray
、tf.Tensor
、list[tf.Tensor]
、dict[str, tf.Tensor]
或dict[str, np.ndarray]
,每个样本形状必须为 `(batch_size, num_channels, height, width)`) — 像素值。像素值可以使用 AutoImageProcessor 获得。详情请参阅 CLIPImageProcessor.call()。 - attention_mask (
np.ndarray
或tf.Tensor
,形状为 `(batch_size, sequence_length)`,可选) — 用于避免对填充标记索引执行注意力计算的掩码。掩码值选自 `[0, 1]`:- 1 表示标记未被掩码,
- 0 表示标记已被掩码。
- position_ids (
np.ndarray
或tf.Tensor
,形状为 `(batch_size, sequence_length)`,可选) — 位置嵌入中每个输入序列标记的位置索引。取值范围为 `[0, config.max_position_embeddings - 1]`。 - 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.TFCLIPOutput
或 tuple(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_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`) — 将投影层应用于 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.ndarray
、tf.Tensor
、list[tf.Tensor]
、`dict[str, tf.Tensor]
或dict[str, np.ndarray]
,每个样本形状必须为 `(batch_size, sequence_length)`) — 词汇表中输入序列标记的索引。索引可以使用 AutoTokenizer 获得。详情请参阅 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。
- attention_mask (
np.ndarray
或tf.Tensor
,形状为 `(batch_size, sequence_length)`,可选) — 用于避免对填充标记索引执行注意力计算的掩码。掩码值选自 `[0, 1]`:- 1 表示标记未被掩码,
- 0 表示标记已被掩码。
- position_ids (
np.ndarray
或tf.Tensor
,形状为 `(batch_size, sequence_length)`,可选) — 位置嵌入中每个输入序列标记的位置索引。取值范围为 `[0, config.max_position_embeddings - 1]`。 - 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.ndarray
、tf.Tensor
、list[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
调用
< 来源 >( 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.TFBaseModelOutputWithPooling 或 tuple(tf.Tensor)
参数
- input_ids (
np.ndarray
、tf.Tensor
、list[tf.Tensor]
、`dict[str, tf.Tensor]
或dict[str, np.ndarray]
,每个样本形状必须为 `(batch_size, sequence_length)`) — 词汇表中输入序列标记的索引。索引可以使用 AutoTokenizer 获得。详情请参阅 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。
- attention_mask (
np.ndarray
或tf.Tensor
,形状为 `(batch_size, sequence_length)`,可选) — 用于避免对填充标记索引执行注意力计算的掩码。掩码值选自 `[0, 1]`:- 1 表示标记未被掩码,
- 0 表示标记已被掩码。
- position_ids (
np.ndarray
或tf.Tensor
,形状为 `(batch_size, sequence_length)`,可选) — 位置嵌入中每个输入序列标记的位置索引。取值范围为 `[0, config.max_position_embeddings - 1]`。 - 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.TFBaseModelOutputWithPooling 或 tuple(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
调用
< 来源 >( 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.TFBaseModelOutputWithPooling 或 tuple(tf.Tensor)
参数
- pixel_values (
np.ndarray
、tf.Tensor
、list[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.TFBaseModelOutputWithPooling 或 tuple(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
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.float32
、jax.numpy.float16
(在 GPU 上) 和jax.numpy.bfloat16
(在 TPU 上) 中的一种。这可用于在 GPU 或 TPU 上启用混合精度训练或半精度推理。如果指定了该参数,所有计算都将使用给定的
dtype
执行。请注意,这仅指定计算的数据类型,不影响模型参数的数据类型。
此模型继承自 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.FlaxCLIPOutput
或 tuple(torch.FloatTensor)
参数
- input_ids (
numpy.ndarray
,形状为(batch_size, sequence_length)
) — 词汇表中输入序列标记的索引。如果提供填充,默认将被忽略。索引可以使用 AutoTokenizer 获得。详情请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- 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]
。 - 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.FlaxCLIPOutput
或 tuple(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_embeds
和text_embeds
之间的缩放点积得分。这表示图文相似性得分。 - logits_per_text:(
jnp.ndarray
,形状为(text_batch_size, image_batch_size)
) —text_embeds
和image_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)
)
参数
- input_ids (
numpy.ndarray
,形状为(batch_size, sequence_length)
) — 词汇表中输入序列标记的索引。如果提供填充,默认将被忽略。索引可以使用 AutoTokenizer 获得。详情请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
返回
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.FlaxBaseModelOutputWithPooling 或 tuple(torch.FloatTensor)
参数
- input_ids (
numpy.ndarray
,形状为(batch_size, sequence_length)
) — 词汇表中输入序列标记的索引。如果提供填充,默认将被忽略。索引可以使用 AutoTokenizer 获得。详情请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- 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]
。 - output_attentions (
bool
, 可选) — 是否返回所有注意力层的注意力张量。更多细节请参阅返回张量下的attentions
。 - output_hidden_states (
bool
, 可选) — 是否返回所有层的隐藏状态。更多细节请参阅返回张量下的hidden_states
。 - return_dict (
bool
, 可选) — 是否返回 ModelOutput 而不是普通元组。
返回
transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPooling 或 tuple(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.FlaxCLIPTextModelOutput
或 tuple(torch.FloatTensor)
参数
- input_ids (
numpy.ndarray
,形状为(batch_size, sequence_length)
) — 词汇表中输入序列标记的索引。如果提供填充,默认将被忽略。索引可以使用 AutoTokenizer 获得。详情请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- 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]
。 - output_attentions (
bool
, 可选) — 是否返回所有注意力层的注意力张量。更多细节请参阅返回张量下的attentions
。 - output_hidden_states (
bool
, 可选) — 是否返回所有层的隐藏状态。更多细节请参阅返回张量下的hidden_states
。 - return_dict (
bool
, 可选) — 是否返回 ModelOutput 而不是普通元组。
返回
transformers.models.clip.modeling_flax_clip.FlaxCLIPTextModelOutput
或 tuple(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.FlaxBaseModelOutputWithPooling 或 tuple(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.FlaxBaseModelOutputWithPooling 或 tuple(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