CLIP
概述
CLIP 模型在 Learning Transferable Visual Models From Natural Language Supervision 这篇论文中被提出，作者是 Alec Radford, Jong Wook Kim, Chris Hallacy, Aditya Ramesh, Gabriel Goh, Sandhini Agarwal, Girish Sastry, Amanda Askell, Pamela Mishkin, Jack Clark, Gretchen Krueger, Ilya Sutskever。CLIP (对比语言-图像预训练) 是一个在各种（图像，文本）对上训练的神经网络。它可以被用自然语言指示，以预测给定图像的最相关的文本片段，而无需直接为该任务进行优化，这类似于 GPT-2 和 3 的零样本能力。
该论文的摘要如下：
目前最先进的计算机视觉系统被训练来预测一组固定的、预先确定的对象类别。这种受限的监督形式限制了它们的通用性和可用性，因为需要额外的标记数据来指定任何其他视觉概念。直接从关于图像的原始文本中学习是一种很有前景的替代方案，它可以利用更广泛的监督来源。我们证明，预测哪个标题与哪个图像匹配的简单预训练任务，是一种有效且可扩展的方法，可以从互联网上收集的 4 亿个（图像，文本）对的数据集中从头开始学习 SOTA 图像表示。在预训练之后，自然语言被用来引用学习到的视觉概念（或描述新的概念），从而实现模型到下游任务的零样本迁移。我们通过在超过 30 个不同的现有计算机视觉数据集上进行基准测试来研究这种方法的性能，涵盖了诸如 OCR、视频中的动作识别、地理定位以及多种类型的细粒度对象分类等任务。该模型在大多数任务上实现了非平凡的迁移，并且通常与完全监督的基线模型具有竞争力，而无需任何数据集特定的训练。例如，我们在 ImageNet 上零样本匹配了原始 ResNet-50 的准确率，而无需使用它训练时使用的 128 万个训练样本中的任何一个。我们在此 https URL 发布我们的代码和预训练模型权重。
使用技巧和示例
CLIP 是一个多模态视觉和语言模型。它可用于图像-文本相似性以及零样本图像分类。CLIP 使用类似 ViT 的 Transformer 来获取视觉特征，并使用因果语言模型来获取文本特征。然后，文本和视觉特征都被投影到具有相同维度的潜在空间中。投影的图像和文本特征之间的点积然后被用作相似度分数。
为了将图像输入到 Transformer 编码器，每张图像被分割成一系列固定大小的非重叠补丁，然后进行线性嵌入。添加一个 [CLS] 令牌作为整个图像的表示。作者还添加了绝对位置嵌入，并将生成的向量序列馈送到标准的 Transformer 编码器。CLIPImageProcessor 可用于调整大小（或重新缩放）和归一化模型的图像。
CLIPTokenizer 用于编码文本。CLIPProcessor 将 CLIPImageProcessor 和 CLIPTokenizer 封装到一个实例中，以同时编码文本和准备图像。以下示例展示了如何使用 CLIPProcessor 和 CLIPModel 获取图像-文本相似度分数。
>>> from PIL import Image
>>> import requests
>>> from transformers import CLIPProcessor, CLIPModel
>>> model = CLIPModel.from_pretrained("openai/clip-vit-base-patch32")
>>> processor = CLIPProcessor.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结合 CLIP 和 Flash Attention 2
首先，请确保安装最新版本的 Flash Attention 2。
pip install -U flash-attn --no-build-isolation
还要确保您的硬件与 Flash-Attention 2 兼容。请阅读 flash-attn 仓库的官方文档以了解更多信息。同时确保以半精度加载您的模型（例如 torch.float16）。
对于小批量大小，当使用 flash attention 时，您可能会注意到模型速度减慢。请参考下面的 Flash Attention 和 SDPA 的预期加速 部分，并选择合适的 attention 实现。
要使用 Flash Attention 2 加载和运行模型，请参考以下代码片段：
>>> import torch
>>> import requests
>>> from PIL import Image
>>> from transformers import CLIPProcessor, CLIPModel
>>> device = "cuda"
>>> torch_dtype = torch.float16
>>> model = CLIPModel.from_pretrained(
... "openai/clip-vit-base-patch32",
... attn_implementation="flash_attention_2",
... device_map=device,
... torch_dtype=torch_dtype,
... )
>>> processor = CLIPProcessor.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)
>>> inputs.to(device)
>>> with torch.no_grad():
... with torch.autocast(device):
... 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
>>> print(probs)
tensor([[0.9946, 0.0052]], device='cuda:0', dtype=torch.float16)使用缩放点积注意力 (SDPA)
PyTorch 包括一个原生的缩放点积注意力 (SDPA) 运算符，作为 torch.nn.functional 的一部分。此函数包含多个实现，可以根据输入和正在使用的硬件应用。有关更多信息，请参阅官方文档或 GPU 推理 页面。
当实现可用时，torch>=2.1.1 默认使用 SDPA，但您也可以在 from_pretrained() 中设置 attn_implementation="sdpa" 以显式请求使用 SDPA。
from transformers import CLIPModel
model = CLIPModel.from_pretrained("openai/clip-vit-base-patch32", torch_dtype=torch.float16, attn_implementation="sdpa")为了获得最佳加速，我们建议以半精度加载模型（例如 torch.float16 或 torch.bfloat16）。
Flash Attention 和 SDPA 的预期加速
在本地基准测试 (NVIDIA A10G, PyTorch 2.3.1+cu121) 中，使用 float16，我们看到了 "openai/clip-vit-large-patch14" 检查点在推理期间的以下加速 (代码)
CLIPTextModel
| 文本标签数 | Eager (秒/迭代) | FA2 (秒/迭代) | FA2 加速 | SDPA (秒/迭代) | SDPA 加速 |
|---|---|---|---|---|---|
| 4 | 0.009 | 0.012 | 0.737 | 0.007 | 1.269 |
| 16 | 0.009 | 0.014 | 0.659 | 0.008 | 1.187 |
| 32 | 0.018 | 0.021 | 0.862 | 0.016 | 1.142 |
| 64 | 0.034 | 0.034 | 1.001 | 0.03 | 1.163 |
| 128 | 0.063 | 0.058 | 1.09 | 0.054 | 1.174 |
CLIPVisionModel
| 图像批次大小 | Eager (秒/迭代) | FA2 (秒/迭代) | FA2 加速 | SDPA (秒/迭代) | SDPA 加速 |
|---|---|---|---|---|---|
| 1 | 0.016 | 0.013 | 1.247 | 0.012 | 1.318 |
| 4 | 0.025 | 0.021 | 1.198 | 0.021 | 1.202 |
| 16 | 0.093 | 0.075 | 1.234 | 0.075 | 1.24 |
| 32 | 0.181 | 0.147 | 1.237 | 0.146 | 1.241 |
CLIPModel
| 图像批次大小 | 文本标签数 | Eager (秒/迭代) | FA2 (秒/迭代) | FA2 加速 | SDPA (秒/迭代) | SDPA 加速 |
|---|---|---|---|---|---|---|
| 1 | 4 | 0.025 | 0.026 | 0.954 | 0.02 | 1.217 |
| 1 | 16 | 0.026 | 0.028 | 0.918 | 0.02 | 1.287 |
| 1 | 64 | 0.042 | 0.046 | 0.906 | 0.036 | 1.167 |
| 4 | 4 | 0.028 | 0.033 | 0.849 | 0.024 | 1.189 |
| 4 | 16 | 0.034 | 0.035 | 0.955 | 0.029 | 1.169 |
| 4 | 64 | 0.059 | 0.055 | 1.072 | 0.05 | 1.179 |
| 16 | 4 | 0.096 | 0.088 | 1.091 | 0.078 | 1.234 |
| 16 | 16 | 0.102 | 0.09 | 1.129 | 0.083 | 1.224 |
| 16 | 64 | 0.127 | 0.11 | 1.157 | 0.105 | 1.218 |
| 32 | 4 | 0.185 | 0.159 | 1.157 | 0.149 | 1.238 |
| 32 | 16 | 0.19 | 0.162 | 1.177 | 0.154 | 1.233 |
| 32 | 64 | 0.216 | 0.181 | 1.19 | 0.176 | 1.228 |
资源
以下是官方 Hugging Face 和社区（标有 🌎）资源列表，可帮助您开始使用 CLIP。
- 使用遥感（卫星）图像和标题微调 CLIP，一篇关于如何使用 RSICD 数据集 微调 CLIP 以及数据增强引起的性能变化比较的博客文章。
- 这个示例脚本 展示了如何使用预训练的视觉和文本编码器以及 COCO 数据集 训练类似 CLIP 的视觉-文本双编码器模型。
- 一个关于如何使用预训练的 CLIP 进行推理，并使用束搜索进行图像字幕的 notebook。🌎
图像检索
- 一个关于使用预训练的 CLIP 进行图像检索并计算 MRR（平均倒数排名）分数的 notebook。🌎
- 一个关于图像检索并显示相似度分数的 notebook。🌎
- 一个关于如何使用多语言 CLIP 将图像和文本映射到同一向量空间的 notebook。🌎
- 一个关于如何在语义图像搜索中使用 CLIP 以及 Unsplash 和 TMDB 数据集的 notebook。🌎
可解释性
- 一个关于如何可视化输入令牌和图像片段之间相似性的 notebook。🌎
如果您有兴趣提交资源以包含在此处，请随时打开 Pull Request，我们将对其进行审核。该资源最好展示一些新的东西，而不是重复现有资源。
CLIPConfig
class transformers.CLIPConfig
< source >( 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
< source >( text_config: CLIPTextConfig vision_config: CLIPVisionConfig **kwargs ) → CLIPConfig
从 clip 文本模型配置和 clip 视觉模型配置实例化 CLIPConfig（或派生类）。
CLIPTextConfig
class transformers.CLIPTextConfig
< source >( 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可以表示的不同 token 的数量。 - hidden_size (
int, 可选, 默认为 512) — 编码器层和池化层的维度。 - intermediate_size (
int, optional, defaults to 2048) — Transformer 编码器中“中间”（即，前馈）层的维度。 - projection_dim (
int, optional, defaults to 512) — 文本和视觉投影层的维度。 - num_hidden_layers (
int, optional, defaults to 12) — Transformer 编码器中隐藏层的数量。 - num_attention_heads (
int, optional, defaults to 8) — Transformer 编码器中每个注意力层的注意力头的数量。 - max_position_embeddings (
int, optional, defaults to 77) — 此模型可能使用的最大序列长度。通常将其设置为较大的值以防万一（例如，512 或 1024 或 2048）。 - hidden_act (
str或function, optional, defaults to"quick_gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果为字符串，则支持"gelu"、"relu"、"selu"、"gelu_new"和"quick_gelu"。 - layer_norm_eps (
float, optional, defaults to 1e-05) — 层归一化层使用的 epsilon 值。 - attention_dropout (
float, optional, defaults to 0.0) — 注意力概率的 dropout 比率。 - initializer_range (
float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。 - initializer_factor (
float, optional, defaults to 1.0) — 用于初始化所有权重矩阵的因子（应保持为 1，内部用于初始化测试）。 - pad_token_id (
int, optional, defaults to 1) — 填充 token id。 - bos_token_id (
int, optional, defaults to 49406) — 流开始 token id。 - eos_token_id (
int, optional, defaults to 49407) — 流结束 token 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.configCLIPVisionConfig
class transformers.CLIPVisionConfig
< source >( 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, optional, defaults to 768) — 编码器层和池化器层的维度。 - intermediate_size (
int, optional, defaults to 3072) — Transformer 编码器中“中间”（即，前馈）层的维度。 - projection_dim (
int, optional, defaults to 512) — 文本和视觉投影层的维度。 - num_hidden_layers (
int, optional, defaults to 12) — Transformer 编码器中隐藏层的数量。 - num_attention_heads (
int, optional, defaults to 12) — Transformer 编码器中每个注意力层的注意力头的数量。 - num_channels (
int, optional, defaults to 3) — 输入通道的数量。 - image_size (
int, optional, defaults to 224) — 每张图像的大小（分辨率）。 - patch_size (
int, optional, defaults to 32) — 每个 patch 的大小（分辨率）。 - hidden_act (
str或function, optional, defaults to"quick_gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果为字符串，则支持"gelu"、"relu"、"selu"、"gelu_new"和"quick_gelu"。 - layer_norm_eps (
float, optional, defaults to 1e-05) — 层归一化层使用的 epsilon 值。 - attention_dropout (
float, optional, defaults to 0.0) — 注意力概率的 dropout 比率。 - initializer_range (
float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态分布初始化器的标准差，默认为 0.02。 - initializer_factor (
float, optional, defaults to 1.0) — 用于初始化所有权重矩阵的因子 (应保持为 1，内部用于初始化测试)，默认为 1.0。
这是用于存储 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.configCLIPTokenizer
class transformers.CLIPTokenizer
< source >( 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, optional, defaults to"replace") — 将字节解码为 UTF-8 时要遵循的范例。 有关更多信息，请参阅 bytes.decode，默认为"replace"。 - unk_token (
str, optional, defaults to"<|endoftext|>") — 未知 token。词汇表中不存在的 token 无法转换为 ID，而是设置为此 token，默认为"<|endoftext|>"。 - bos_token (
str, optional, defaults to"<|startoftext|>") — 序列开始 token，默认为"<|startoftext|>"。 - eos_token (
str, optional, defaults to"<|endoftext|>") — 序列结束 token，默认为"<|endoftext|>"。 - pad_token (
str, optional, defaults to"<|endoftext|>") — 用于填充的 token，例如在对不同长度的序列进行批处理时使用，默认为"<|endoftext|>"。
构建 CLIP tokenizer。基于字节级字节对编码 (Byte-Pair-Encoding)。
此 tokenizer 继承自 PreTrainedTokenizer，其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。
build_inputs_with_special_tokens
< source >( token_ids_0: List token_ids_1: Optional = None ) → List[int]
参数
- token_ids_0 (
List[int]) — 将在其中添加特殊 token 的 ID 列表。 - token_ids_1 (
List[int], optional) — 用于序列对的可选的第二个 ID 列表。
返回：
List[int]
带有适当特殊 token 的 输入 ID 列表。
通过连接并添加特殊 token，从序列或序列对构建模型输入，用于序列分类任务。CLIP 序列具有以下格式
- 单序列：
<|startoftext|> X <|endoftext|>
序列对不是预期的用例，但将无需分隔符进行处理。
get_special_tokens_mask
< source >( token_ids_0: List token_ids_1: Optional = None already_has_special_tokens: bool = False ) → List[int]
从没有添加特殊 token 的 token 列表中检索序列 ID。使用 tokenizer prepare_for_model 方法添加特殊 token 时，将调用此方法。
create_token_type_ids_from_sequences
< source >( token_ids_0: List token_ids_1: Optional = None ) → List[int]
从传递的两个序列创建 mask。CLIP 不使用 token 类型 ID，因此返回零列表。
CLIPTokenizerFast
class transformers.CLIPTokenizerFast
< source >( 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, optional) — 词汇表文件的路径。 - merges_file (
str, optional) — merges 文件的路径。 - tokenizer_file (
str, optional) — tokenizer 文件的路径，用于代替词汇表文件。 - unk_token (
str, optional, defaults to"<|endoftext|>") — 未知 token。词汇表中不存在的 token 无法转换为 ID，并会被设置为此 token。 - bos_token (
str, optional, defaults to"<|startoftext|>") — 序列开始 token。 - eos_token (
str, optional, defaults to"<|endoftext|>") — 序列结束 token。 - pad_token (
str, optional, defaults to"<|endoftext|>") — 用于 padding 的 token，例如在对不同长度的序列进行 batch 处理时使用。
构建一个 “fast” CLIP tokenizer（由 HuggingFace 的 tokenizers 库支持）。基于字节级 Byte-Pair-Encoding。
此 tokenizer 继承自 PreTrainedTokenizerFast，其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。
build_inputs_with_special_tokens
< source >( token_ids_0: List token_ids_1: Optional = None ) → List[int]
参数
- token_ids_0 (
List[int]) — 将向其添加特殊 token 的 ID 列表。 - token_ids_1 (
List[int], optional) — 用于序列对的可选的第二个 ID 列表。
返回：
List[int]
带有适当特殊 token 的 输入 ID 列表。
通过连接并添加特殊 token，从序列或序列对构建模型输入，用于序列分类任务。CLIP 序列具有以下格式
- 单序列：
<|startoftext|> X <|endoftext|>
序列对不是预期的用例，但将无需分隔符进行处理。
create_token_type_ids_from_sequences
< source >( token_ids_0: List token_ids_1: Optional = None ) → List[int]
从传递的两个序列创建 mask。CLIP 不使用 token 类型 ID，因此返回零列表。
CLIPImageProcessor
class transformers.CLIPImageProcessor
< source >( do_resize: bool = True size: Dict = None resample: Resampling = <Resampling.BICUBIC: 3> do_center_crop: bool = True crop_size: Dict = None do_rescale: bool = True rescale_factor: Union = 0.00392156862745098 do_normalize: bool = True image_mean: Union = None image_std: Union = None do_convert_rgb: bool = True **kwargs )
参数
- do_resize (
bool, optional, defaults toTrue) — 是否将图像的（高度，宽度）尺寸调整为指定的size。 可以被preprocess方法中的do_resize覆盖。 - size (
Dict[str, int]optional, defaults to{"shortest_edge" -- 224}): 调整大小后图像的尺寸。图像的最短边调整为 size[“shortest_edge”]，最长边调整为保持输入宽高比。 可以被preprocess方法中的size覆盖。 - resample (
PILImageResampling, optional, defaults toResampling.BICUBIC) — 如果调整图像大小，则使用的重采样过滤器。 可以被preprocess方法中的resample覆盖。 - do_center_crop (
bool, optional, defaults toTrue) — 是否将图像中心裁剪为指定的crop_size。 可以被preprocess方法中的do_center_crop覆盖。 - crop_size (
Dict[str, int]optional, defaults to 224) — 应用center_crop后输出图像的尺寸。 可以被preprocess方法中的crop_size覆盖。 - do_rescale (
bool, optional, defaults toTrue) — 是否按指定的比例rescale_factor缩放图像。 可以被preprocess方法中的do_rescale覆盖。 - rescale_factor (
intorfloat, optional, defaults to1/255) — 如果缩放图像，则使用的缩放因子。 可以被preprocess方法中的rescale_factor覆盖。 - do_normalize (
bool, optional, defaults toTrue) — 是否标准化图像。 可以被preprocess方法中的do_normalize覆盖。 - image_mean (
floatorList[float], optional, defaults to[0.48145466, 0.4578275, 0.40821073]) — 如果标准化图像，则使用的均值。这是一个浮点数或浮点数列表，其长度是图像中通道的数量。 可以被preprocess方法中的image_mean参数覆盖。 - image_std (
floatorList[float], optional, defaults to[0.26862954, 0.26130258, 0.27577711]) — 如果标准化图像，则使用的标准差。这是一个浮点数或浮点数列表，其长度是图像中通道的数量。 可以被preprocess方法中的image_std参数覆盖。 可以被preprocess方法中的image_std参数覆盖。 - do_convert_rgb (
bool, optional, defaults toTrue) — 是否将图像转换为 RGB 格式。
构建 CLIP 图像处理器。
preprocess
< source >( images: Union do_resize: bool = None size: Dict = None resample: Resampling = None do_center_crop: bool = None crop_size: int = None do_rescale: bool = None rescale_factor: float = None do_normalize: bool = None image_mean: Union = None image_std: Union = None do_convert_rgb: bool = None return_tensors: Union = None data_format: Optional = <ChannelDimension.FIRST: 'channels_first'> input_data_format: Union = None **kwargs )
参数
- images (
ImageInput) — 要预处理的图像。 期望单个或一批像素值范围为 0 到 255 的图像。 如果传入像素值介于 0 和 1 之间的图像，请设置do_rescale=False。 - do_resize (
bool, optional, defaults toself.do_resize) — 是否调整图像大小。 - size (
Dict[str, int], optional, defaults toself.size) — 调整大小后的图像尺寸。图像的最短边将被调整为 size[“shortest_edge”]，最长边将被调整以保持输入宽高比。 - resample (
int, optional, defaults toself.resample) — 如果调整图像大小，则使用的重采样过滤器。这可以是枚举PILImageResampling之一。仅当do_resize设置为True时才有效。 - do_center_crop (
bool, optional, defaults toself.do_center_crop) — 是否对图像进行中心裁剪。 - crop_size (
Dict[str, int], optional, defaults toself.crop_size) — 中心裁剪的尺寸。仅当do_center_crop设置为True时才有效。 - do_rescale (
bool, optional, defaults toself.do_rescale) — 是否对图像进行重新缩放。 - rescale_factor (
float, optional, defaults toself.rescale_factor) — 如果do_rescale设置为True，则通过此比例因子重新缩放图像。 - do_normalize (
bool, optional, defaults toself.do_normalize) — 是否对图像进行归一化。 - image_mean (
floatorList[float], optional, defaults toself.image_mean) — 用于归一化的图像均值。仅当do_normalize设置为True时才有效。 - image_std (
floatorList[float], optional, defaults toself.image_std) — 用于归一化的图像标准差。仅当do_normalize设置为True时才有效。 - do_convert_rgb (
bool, optional, defaults toself.do_convert_rgb) — 是否将图像转换为 RGB 格式。 - return_tensors (
strorTensorType, optional) — 返回张量的类型。可以是以下之一：- Unset：返回
np.ndarray列表。 TensorType.TENSORFLOW或'tf'：返回tf.Tensor类型的批次。TensorType.PYTORCH或'pt'：返回torch.Tensor类型的批次。TensorType.NUMPY或'np'：返回np.ndarray类型的批次。TensorType.JAX或'jax'：返回jax.numpy.ndarray类型的批次。
- Unset：返回
- data_format (
ChannelDimensionorstr, optional, defaults toChannelDimension.FIRST) — 输出图像的通道维度格式。可以是以下之一："channels_first"或ChannelDimension.FIRST：图像格式为 (num_channels, height, width)。"channels_last"或ChannelDimension.LAST：图像格式为 (height, width, num_channels)。- Unset：使用输入图像的通道维度格式。
- input_data_format (
ChannelDimensionorstr, optional) — 输入图像的通道维度格式。如果未设置，则通道维度格式从输入图像推断。可以是以下之一："channels_first"或ChannelDimension.FIRST：图像格式为 (num_channels, height, width)。"channels_last"或ChannelDimension.LAST：图像格式为 (height, width, num_channels)。"none"或ChannelDimension.NONE：图像格式为 (height, width)。
预处理单个图像或一批图像。
CLIPFeatureExtractor
CLIPProcessor
class transformers.CLIPProcessor
< source >( image_processor = None tokenizer = None **kwargs )
参数
- image_processor (CLIPImageProcessor, optional) — 图像处理器是必需的输入。
- tokenizer (CLIPTokenizerFast, optional) — 分词器是必需的输入。
构建一个 CLIP 处理器，它将 CLIP 图像处理器和 CLIP 分词器包装到单个处理器中。
CLIPProcessor 提供了 CLIPImageProcessor 和 CLIPTokenizerFast 的所有功能。 有关更多信息，请参阅 __call__() 和 decode()。
此方法将其所有参数转发到 CLIPTokenizerFast 的 batch_decode()。 有关更多信息，请参阅此方法的文档字符串。
此方法将其所有参数转发到 CLIPTokenizerFast 的 decode()。 有关更多信息，请参阅此方法的文档字符串。
CLIPModel
class transformers.CLIPModel
< source >( config: CLIPConfig )
参数
- config (CLIPConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
此模型继承自 PreTrainedModel。查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参阅 PyTorch 文档，了解与常规用法和行为相关的所有事项。
forward
< source >( input_ids: Optional = None pixel_values: Optional = None attention_mask: Optional = None position_ids: Optional = None return_loss: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → transformers.models.clip.modeling_clip.CLIPOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。如果您提供 padding，默认情况下将被忽略。索引可以使用 AutoTokenizer 获得。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — 用于避免在 padding token 索引上执行 attention 的 Mask。Mask 值在[0, 1]中选择：- 1 代表 未被 mask 的 tokens，
- 0 代表 被 mask 的 tokens。
- position_ids (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 位置 embeddings 中每个输入序列 tokens 的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。 - pixel_values (
torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 像素值。如果您提供 padding，默认情况下将被忽略。像素值可以使用 AutoImageProcessor 获得。 有关详细信息，请参阅 CLIPImageProcessor.call()。 - return_loss (
bool，可选) — 是否返回对比损失。 - output_attentions (
bool，可选) — 是否返回所有 attention 层的 attentions tensors。 有关更多详细信息，请参阅返回的 tensors 下的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的 hidden states。 有关更多详细信息，请参阅返回的 tensors 下的hidden_states。 - return_dict (
bool，可选) — 是否返回 ModelOutput 而不是普通的 tuple。
返回：
transformers.models.clip.modeling_clip.CLIPOutput 或 tuple(torch.FloatTensor)
一个 transformers.models.clip.modeling_clip.CLIPOutput 或一个 torch.FloatTensor 的 tuple（如果传递 return_dict=False 或当 config.return_dict=False 时），包含各种元素，具体取决于配置 (<class 'transformers.models.clip.configuration_clip.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 的 pooled output 获得的文本 embeddings。 - image_embeds (
torch.FloatTensor，形状为(batch_size, output_dim) — 通过将投影层应用于 CLIPVisionModel 的 pooled output 获得的图像 embeddings。 - text_model_output (
BaseModelOutputWithPooling) — CLIPTextModel 的输出。 - vision_model_output (
BaseModelOutputWithPooling) — CLIPVisionModel 的输出。
CLIPModel 的 forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的 recipe 需要在此函数中定义，但应该在之后调用 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 probabilitiesget_text_features
< source >( input_ids: Optional = None attention_mask: Optional = None position_ids: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → text_features (torch.FloatTensor，形状为 (batch_size, output_dim)
参数
- input_ids (
torch.LongTensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。如果您提供 padding，默认情况下将被忽略。索引可以使用 AutoTokenizer 获得。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — 用于避免在 padding token 索引上执行 attention 的 Mask。Mask 值在[0, 1]中选择：- 1 代表 未被 mask 的 tokens，
- 0 代表 被 mask 的 tokens。
- position_ids (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 位置 embeddings 中每个输入序列 tokens 的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。 - output_attentions (
bool，可选) — 是否返回所有 attention 层的 attentions tensors。 有关更多详细信息，请参阅返回的 tensors 下的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的 hidden states。 有关更多详细信息，请参阅返回的 tensors 下的hidden_states。 - return_dict (
bool，可选) — 是否返回 ModelOutput 而不是普通的 tuple。
返回：
text_features (torch.FloatTensor，形状为 (batch_size, output_dim)
通过将投影层应用于 CLIPTextModel 的 pooled output 获得的文本 embeddings。
CLIPModel 的 forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的 recipe 需要在此函数中定义，但应该在之后调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> 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: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → image_features (torch.FloatTensor，形状为 (batch_size, output_dim)
参数
- pixel_values (
torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 像素值。如果您提供 padding，默认情况下将被忽略。像素值可以使用 AutoImageProcessor 获得。 有关详细信息，请参阅 CLIPImageProcessor.call()。 - output_attentions (
bool，可选) — 是否返回所有 attention 层的 attentions tensors。 有关更多详细信息，请参阅返回的 tensors 下的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的 hidden states。 有关更多详细信息，请参阅返回的 tensors 下的hidden_states。 - return_dict (
bool，可选) — 是否返回 ModelOutput 而不是普通的 tuple。
返回：
image_features (torch.FloatTensor，形状为 (batch_size, output_dim)
通过将投影层应用于 CLIPVisionModel 的 pooled output 获得的图像 embeddings。
CLIPModel 的 forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的 recipe 需要在此函数中定义，但应该在之后调用 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(images=image, return_tensors="pt")
>>> image_features = model.get_image_features(**inputs)CLIPTextModel
class transformers.CLIPTextModel
< source >( config: CLIPTextConfig )
参数
- config (CLIPConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
来自 CLIP 的文本模型，顶部没有任何 head 或 projection。此模型继承自 PreTrainedModel。 查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入 embeddings 大小、剪枝 heads 等）。
此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参阅 PyTorch 文档，了解与常规用法和行为相关的所有事项。
forward
< source >( input_ids: 可选 = None attention_mask: 可选 = None position_ids: 可选 = None output_attentions: 可选 = None output_hidden_states: 可选 = None return_dict: 可选 = None ) → transformers.modeling_outputs.BaseModelOutputWithPooling 或 tuple(torch.FloatTensor)
参数
- input_ids (形状为
(batch_size, sequence_length)的torch.LongTensor) — 词汇表中输入序列 tokens 的索引。如果您提供 padding，默认情况下将被忽略。索引可以使用 AutoTokenizer 获得。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (形状为
(batch_size, sequence_length)的torch.Tensor, 可选) — 掩码以避免对 padding token 索引执行 attention。掩码值在[0, 1]中选择：- 1 表示未被掩码的 tokens，
- 0 表示已被掩码的 tokens。
- position_ids (形状为
(batch_size, sequence_length)的torch.LongTensor, 可选) — 位置 embeddings 中每个输入序列 tokens 的位置索引。在 `[0, config.max_position_embeddings - 1]` 范围内选择。 - output_attentions (
bool, 可选) — 是否返回所有 attention 层的 attentions tensors。有关更多详细信息，请参阅返回的 tensors 下的 attentions。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回的 tensors 下的 hidden_states。 - return_dict (
bool, 可选) — 是否返回一个 ModelOutput 而不是一个 plain tuple。
返回：
transformers.modeling_outputs.BaseModelOutputWithPooling 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.BaseModelOutputWithPooling 或 `torch.FloatTensor` 的 tuple (如果传递了 return_dict=False 或当 config.return_dict=False 时)，包含各种元素，具体取决于配置 (`<class 'transformers.models.clip.configuration_clip.CLIPTextConfig'>) 和输入。
-
last_hidden_state (形状为
(batch_size, sequence_length, hidden_size)的torch.FloatTensor) — 模型最后一层的输出处的隐藏状态序列。 -
pooler_output (形状为
(batch_size, hidden_size)的torch.FloatTensor) — 序列的第一个 token（分类 token）的最后一层隐藏状态，在通过用于辅助预训练任务的层进一步处理之后。例如，对于 BERT 系列模型，这会返回通过线性层和 tanh 激活函数处理后的分类 token。线性层权重通过预训练期间的下一句预测（分类）目标进行训练。 -
hidden_states (
tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) — `torch.FloatTensor` 的 tuple（如果模型有 embedding 层，则一个用于 embeddings 的输出；+ 每个层的输出一个），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出处的隐藏状态，加上可选的初始 embedding 输出。
-
attentions (
tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) — `torch.FloatTensor` 的 tuple（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的 attentions 权重，用于计算自注意力头中的加权平均值。
`CLIPTextModel` 的 forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的 recipe 需要在此函数中定义，但应该在之后调用 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) statesCLIPTextModelWithProjection
class transformers.CLIPTextModelWithProjection
< source >( config: CLIPTextConfig )
参数
- config (CLIPConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
带有顶部投影层的 CLIP 文本模型（池化输出顶部的线性层）。
此模型继承自 PreTrainedModel。查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参阅 PyTorch 文档，了解与常规用法和行为相关的所有事项。
forward
< source >( input_ids: 可选 = None attention_mask: 可选 = None position_ids: 可选 = None output_attentions: 可选 = None output_hidden_states: 可选 = None return_dict: 可选 = None ) → transformers.models.clip.modeling_clip.CLIPTextModelOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (形状为
(batch_size, sequence_length)的torch.LongTensor) — 词汇表中输入序列 tokens 的索引。如果您提供 padding，默认情况下将被忽略。索引可以使用 AutoTokenizer 获得。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (形状为
(batch_size, sequence_length)的torch.Tensor, 可选) — 掩码以避免对 padding token 索引执行 attention。掩码值在[0, 1]中选择：- 1 表示未被掩码的 tokens，
- 0 表示已被掩码的 tokens。
- position_ids (形状为
(batch_size, sequence_length)的torch.LongTensor, 可选) — 位置 embeddings 中每个输入序列 tokens 的位置索引。在 `[0, config.max_position_embeddings - 1]` 范围内选择。 - output_attentions (
bool, 可选) — 是否返回所有 attention 层的 attentions tensors。有关更多详细信息，请参阅返回的 tensors 下的 attentions。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回的 tensors 下的 hidden_states。 - return_dict (
bool, 可选) — 是否返回一个 ModelOutput 而不是一个 plain tuple。
返回：
transformers.models.clip.modeling_clip.CLIPTextModelOutput 或 tuple(torch.FloatTensor)
一个 transformers.models.clip.modeling_clip.CLIPTextModelOutput 或 `torch.FloatTensor` 的 tuple (如果传递了 return_dict=False 或当 config.return_dict=False 时)，包含各种元素，具体取决于配置 (`<class 'transformers.models.clip.configuration_clip.CLIPTextConfig'>) 和输入。
-
text_embeds (形状为
(batch_size, output_dim)的torch.FloatTensor可选 当模型使用with_projection=True初始化时返回) — 通过将投影层应用于 pooler_output 获得的文本 embeddings。 -
last_hidden_state (形状为
(batch_size, sequence_length, hidden_size)的torch.FloatTensor) — 模型最后一层的输出处的隐藏状态序列。 -
hidden_states (
tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) — `torch.FloatTensor` 的 tuple（如果模型有 embedding 层，则一个用于 embeddings 的输出；+ 每个层的输出一个），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出处的隐藏状态，加上可选的初始 embedding 输出。
-
attentions (
tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) — `torch.FloatTensor` 的 tuple（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的 attentions 权重，用于计算自注意力头中的加权平均值。
`CLIPTextModelWithProjection` 的 forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的 recipe 需要在此函数中定义，但应该在之后调用 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_embedsCLIPVisionModelWithProjection
class transformers.CLIPVisionModelWithProjection
< source >( config: CLIPVisionConfig )
参数
- config (CLIPConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
带有顶部投影层的 CLIP 视觉模型（池化输出顶部的线性层）。
此模型继承自 PreTrainedModel。查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参阅 PyTorch 文档，了解与常规用法和行为相关的所有事项。
forward
< source >( pixel_values: 可选 = None output_attentions: 可选 = None output_hidden_states: 可选 = None return_dict: 可选 = None ) → transformers.models.clip.modeling_clip.CLIPVisionModelOutput 或 tuple(torch.FloatTensor)
参数
- pixel_values (形状为
(batch_size, num_channels, height, width)的torch.FloatTensor) — 像素值。如果您提供 padding，默认情况下将被忽略。像素值可以使用 AutoImageProcessor 获得。有关详细信息，请参阅 CLIPImageProcessor.call()。 - output_attentions (
bool, 可选) — 是否返回所有 attention 层的 attentions tensors。有关更多详细信息，请参阅返回的 tensors 下的 attentions。 - output_hidden_states (
bool, optional) — 是否返回所有层的隐藏状态。 更多细节请查看返回张量下的hidden_states。 - return_dict (
bool, optional) — 是否返回 ModelOutput 而不是纯粹的元组。
返回：
transformers.models.clip.modeling_clip.CLIPVisionModelOutput 或 tuple(torch.FloatTensor)
一个 transformers.models.clip.modeling_clip.CLIPVisionModelOutput 或一个 torch.FloatTensor 元组 (如果传递了 return_dict=False 或者当 config.return_dict=False 时)，包含各种元素，具体取决于配置 (<class 'transformers.models.clip.configuration_clip.CLIPVisionConfig'>) 和输入。
-
image_embeds (
torch.FloatTensor，形状为(batch_size, output_dim)可选，当模型使用with_projection=True初始化时返回) — 通过将投影层应用于 pooler_output 获得的图像嵌入。 -
last_hidden_state (形状为
(batch_size, sequence_length, hidden_size)的torch.FloatTensor) — 模型最后一层的输出处的隐藏状态序列。 -
hidden_states (
tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) — `torch.FloatTensor` 的 tuple（如果模型有 embedding 层，则一个用于 embeddings 的输出；+ 每个层的输出一个），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出处的隐藏状态，加上可选的初始 embedding 输出。
-
attentions (
tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) — `torch.FloatTensor` 的 tuple（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的 attentions 权重，用于计算自注意力头中的加权平均值。
CLIPVisionModelWithProjection 的前向传播方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的 recipe 需要在此函数中定义，但应该在之后调用 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_embedsCLIPVisionModel
class transformers.CLIPVisionModel
< source >( config: CLIPVisionConfig )
参数
- config (CLIPConfig) — 带有模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型关联的权重，仅加载配置。 查看 from_pretrained() 方法来加载模型权重。
来自 CLIP 的视觉模型，顶部没有任何 head 或 projection。 此模型继承自 PreTrainedModel。 查看超类文档以获取库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝 head 等）。
此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参阅 PyTorch 文档，了解与常规用法和行为相关的所有事项。
forward
< source >( pixel_values: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → transformers.modeling_outputs.BaseModelOutputWithPooling 或 tuple(torch.FloatTensor)
参数
- pixel_values (
torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 像素值。 默认情况下，如果您提供填充，则会忽略填充。 像素值可以使用 AutoImageProcessor 获得。 有关详细信息，请参阅 CLIPImageProcessor.call()。 - output_attentions (
bool, optional) — 是否返回所有注意力层的注意力张量。 更多细节请查看返回张量下的attentions。 - output_hidden_states (
bool, optional) — 是否返回所有层的隐藏状态。 更多细节请查看返回张量下的hidden_states。 - return_dict (
bool, optional) — 是否返回 ModelOutput 而不是纯粹的元组。
返回：
transformers.modeling_outputs.BaseModelOutputWithPooling 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.BaseModelOutputWithPooling 或一个 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)的torch.FloatTensor) — 模型最后一层的输出处的隐藏状态序列。 -
pooler_output (形状为
(batch_size, hidden_size)的torch.FloatTensor) — 序列的第一个 token（分类 token）的最后一层隐藏状态，在通过用于辅助预训练任务的层进一步处理之后。例如，对于 BERT 系列模型，这会返回通过线性层和 tanh 激活函数处理后的分类 token。线性层权重通过预训练期间的下一句预测（分类）目标进行训练。 -
hidden_states (
tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) — `torch.FloatTensor` 的 tuple（如果模型有 embedding 层，则一个用于 embeddings 的输出；+ 每个层的输出一个），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出处的隐藏状态，加上可选的初始 embedding 输出。
-
attentions (
tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) — `torch.FloatTensor` 的 tuple（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的 attentions 权重，用于计算自注意力头中的加权平均值。
CLIPVisionModel 的前向传播方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的 recipe 需要在此函数中定义，但应该在之后调用 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 statesCLIPForImageClassification
class transformers.CLIPForImageClassification
< source >( config: CLIPConfig )
参数
- config (CLIPConfig) — 带有模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型关联的权重，仅加载配置。 查看 from_pretrained() 方法来加载模型权重。
带有图像分类 head 的 CLIP 视觉编码器（patch tokens 的 pooled final hidden states 顶部的线性层），例如用于 ImageNet。
此模型继承自 PreTrainedModel。查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参阅 PyTorch 文档，了解与常规用法和行为相关的所有事项。
forward
< source >( pixel_values: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → transformers.modeling_outputs.ImageClassifierOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。 默认情况下，如果您提供填充，则会忽略填充。索引可以使用 AutoTokenizer 获得。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor，形状为(batch_size, sequence_length), 可选) — 用于避免在 padding token 索引上执行 attention 的 Mask。 Mask 值在[0, 1]中选择：- 1 表示 未被 mask 的 tokens，
- 0 表示 被 mask 的 tokens。
- position_ids (
torch.LongTensor，形状为(batch_size, sequence_length), 可选) — 每个输入序列 tokens 在位置嵌入中的位置索引。 在范围[0, config.max_position_embeddings - 1]中选择。 - pixel_values (
torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 像素值。 默认情况下，如果您提供填充，则会忽略填充。 像素值可以使用 AutoImageProcessor 获得。 有关详细信息，请参阅 CLIPImageProcessor.call()。 - return_loss (
bool, optional) — 是否返回对比损失。 - output_attentions (
bool, optional) — 是否返回所有注意力层的注意力张量。 更多细节请查看返回张量下的attentions。 - output_hidden_states (
bool, optional) — 是否返回所有层的隐藏状态。 更多细节请查看返回张量下的hidden_states。 - return_dict (
bool, optional) — 是否返回 ModelOutput 而不是纯粹的元组。 - labels (
torch.LongTensor，形状为(batch_size,)，可选) — 用于计算图像分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]中。如果config.num_labels == 1，则计算回归损失（均方误差损失）；如果config.num_labels > 1，则计算分类损失（交叉熵损失）。
返回：
transformers.modeling_outputs.ImageClassifierOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.ImageClassifierOutput 或一个 torch.FloatTensor 元组（如果传递 return_dict=False 或当 config.return_dict=False 时），包含各种元素，具体取决于配置 (CLIPConfig) 和输入。
-
loss (
torch.FloatTensor，形状为(1,)，可选，当提供labels时返回) — 分类（或回归，如果 config.num_labels==1）损失。 -
logits (
torch.FloatTensor，形状为(batch_size, config.num_labels)) — 分类（或回归，如果 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 之后的 attentions 权重，用于计算自注意力头中的加权平均值。
CLIPForImageClassification forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的 recipe 需要在此函数中定义，但应该在之后调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import AutoImageProcessor, CLIPForImageClassification
>>> import torch
>>> from datasets import load_dataset
>>> dataset = load_dataset("huggingface/cats-image", trust_remote_code=True)
>>> 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])
LABEL_0TFCLIPModel
class transformers.TFCLIPModel
< source >( 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() 支持的任何格式传递您的输入和标签即可！但是，如果您想在 Keras 方法（如 fit() 和 predict()）之外使用第二种格式，例如在使用 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 函数一样传递输入！
call
< source >( 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 模式下使用，在 graph 模式下，将使用配置中的值。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。此参数只能在 eager 模式下使用，在 graph 模式下，将使用配置中的值。 - return_dict (
bool，可选) — 是否返回 ModelOutput 而不是普通元组。此参数可以在 eager 模式下使用，在 graph 模式下，该值将始终设置为 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__ 特殊方法。
尽管 forward 传递的 recipe 需要在此函数中定义，但应该在之后调用 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 probabilitiesget_text_features
< source >( 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 模式下使用，在 graph 模式下，将使用配置中的值。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。 详见返回张量下的hidden_states以获取更多细节。 此参数仅在即时模式下可用，在图模式下将使用配置中的值。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。 此参数可以在即时模式下使用，在图模式下该值将始终设置为 True。 - training (
bool, 可选, 默认为 `False`) — 是否在训练模式下使用模型（某些模块，如 dropout 模块，在训练和评估之间有不同的行为）。
返回：
text_features (tf.Tensor，形状为 (batch_size, output_dim)
通过将投影层应用于 TFCLIPTextModel 的池化输出而获得的文本嵌入。
TFCLIPModel forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的 recipe 需要在此函数中定义，但应该在之后调用 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
< source >( 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以获取更多细节。 此参数仅在即时模式下可用，在图模式下将使用配置中的值。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。 详见返回张量下的hidden_states以获取更多细节。 此参数仅在即时模式下可用，在图模式下将使用配置中的值。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。 此参数可以在即时模式下使用，在图模式下该值将始终设置为 True。 - training (
bool, 可选, 默认为 `False`) — 是否在训练模式下使用模型（某些模块，如 dropout 模块，在训练和评估之间有不同的行为）。
返回：
image_features (tf.Tensor，形状为 (batch_size, output_dim)
通过将投影层应用于 TFCLIPVisionModel 的池化输出而获得的图像嵌入。
TFCLIPModel forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的 recipe 需要在此函数中定义，但应该在之后调用 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
call
< source >( 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), 可选) — 用于避免对 padding 标记索引执行注意力的掩码。 掩码值在[0, 1]中选择：- 1 表示未被掩盖的标记，
- 0 表示被掩盖的标记。
- position_ids (
np.ndarray或tf.Tensor，形状为(batch_size, sequence_length), 可选) — 每个输入序列标记在位置嵌入中的位置索引。 在[0, config.max_position_embeddings - 1]范围内选择。 - output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。 详见返回张量下的attentions以获取更多细节。 此参数仅在即时模式下可用，在图模式下将使用配置中的值。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。 详见返回张量下的hidden_states以获取更多细节。 此参数仅在即时模式下可用，在图模式下将使用配置中的值。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。 此参数可以在即时模式下使用，在图模式下该值将始终设置为 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，形状为(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 之后的 attentions 权重，用于计算自注意力头中的加权平均值。
TFCLIPTextModel 前向方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的 recipe 需要在此函数中定义，但应该在之后调用 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) statesTFCLIPVisionModel
call
< source >( 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 模式下使用，在 graph 模式下将使用配置中的值。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。 有关更多详细信息，请参阅返回张量下的hidden_states。 此参数只能在 eager 模式下使用，在 graph 模式下将使用配置中的值。 - return_dict (
bool，可选) — 是否返回 ModelOutput 而不是普通元组。 此参数可以在 eager 模式下使用，在 graph 模式下，该值将始终设置为 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，形状为(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 之后的 attentions 权重，用于计算自注意力头中的加权平均值。
TFCLIPVisionModel 前向方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的 recipe 需要在此函数中定义，但应该在之后调用 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 statesFlaxCLIPModel
class transformers.FlaxCLIPModel
< source >( config: CLIPConfig input_shape: Optional = 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执行。请注意，这仅指定计算的 dtype，并不影响模型参数的 dtype。
此模型继承自 FlaxPreTrainedModel。 查看超类文档，了解库为其所有模型实现的通用方法（例如，从 PyTorch 模型下载、保存和转换权重）
此模型也是 flax.linen.Module 子类。 将其用作常规 Flax linen Module，并参阅 Flax 文档，了解与一般用法和行为相关的所有事项。
最后，此模型支持固有的 JAX 功能，例如
__call__
< source >( input_ids pixel_values attention_mask = None position_ids = None params: dict = None dropout_rng: PRNGKey = None train: bool = False output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → transformers.models.clip.modeling_flax_clip.FlaxCLIPOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (形状为
(batch_size, sequence_length)的numpy.ndarray) — 词汇表中输入序列 tokens 的索引。 如果您提供填充，默认情况下将忽略填充。索引可以使用 AutoTokenizer 获得。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (形状为
(batch_size, sequence_length)的numpy.ndarray, 可选) — Mask，用于避免对填充 token 索引执行注意力机制。 Mask 值在[0, 1]中选择：- 1 表示 未被 mask 的 tokens，
- 0 表示 被 mask 的 tokens。
- position_ids (形状为
(batch_size, sequence_length)的numpy.ndarray, 可选) — 每个输入序列 tokens 在位置嵌入中的位置索引。 在范围[0, config.max_position_embeddings - 1]中选择。 - pixel_values (形状为
(batch_size, num_channels, height, width)的numpy.ndarray) — 像素值。 如果您提供填充，默认情况下将忽略填充。 像素值可以使用 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 的 pooled 输出而获得的文本嵌入。 - image_embeds(
jnp.ndarray，形状为(batch_size, output_dim) — 通过将投影层应用于 FlaxCLIPVisionModel 的 pooled 输出而获得的图像嵌入。 - text_model_output(
FlaxBaseModelOutputWithPooling): FlaxCLIPTextModel 的输出。 - vision_model_output(
FlaxBaseModelOutputWithPooling): FlaxCLIPVisionModel 的输出。
FlaxCLIPPreTrainedModel 前向方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的 recipe 需要在此函数中定义，但应该在之后调用 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 probabilitiesget_text_features
< source >( input_ids attention_mask = None position_ids = None params: dict = None dropout_rng: PRNGKey = None train = False ) → text_features (形状为 (batch_size, output_dim) 的 jnp.ndarray)
参数
- input_ids (形状为
(batch_size, sequence_length)的numpy.ndarray) — 词汇表中输入序列 tokens 的索引。 如果您提供填充，默认情况下将忽略填充。索引可以使用 AutoTokenizer 获得。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
返回：
text_features (形状为 (batch_size, output_dim) 的 jnp.ndarray)
通过将投影层应用于 FlaxCLIPTextModel 的 pooled 输出而获得的文本嵌入。
示例
>>> 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
< source >( pixel_values params: dict = None dropout_rng: PRNGKey = None train = False ) → image_features (形状为 (batch_size, output_dim) 的 jnp.ndarray)
参数
- pixel_values (形状为
(batch_size, num_channels, height, width)的numpy.ndarray) — 像素值。 如果您提供填充，默认情况下将忽略填充。 像素值可以使用 AutoImageProcessor 获得。 有关详细信息，请参阅 CLIPImageProcessor.call()。
返回：
image_features (形状为 (batch_size, output_dim) 的 jnp.ndarray)
通过将投影层应用于 FlaxCLIPVisionModel 的 pooled 输出而获得的图像嵌入
示例
>>> 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
< source >( config: CLIPTextConfig input_shape = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )
__call__
< source >( input_ids attention_mask = None position_ids = None params: dict = None dropout_rng: PRNGKey = None train: bool = False output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPooling or tuple(torch.FloatTensor)
参数
- input_ids (
numpy.ndarrayof shape(batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。如果提供 padding，默认情况下将被忽略。可以使用 AutoTokenizer 获取索引。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
numpy.ndarrayof shape(batch_size, sequence_length), optional) — 掩码，用于避免在 padding token 索引上执行 attention。 掩码值在[0, 1]中选择：- 1 表示 未被掩盖 的 tokens，
- 0 表示 被掩盖 的 tokens。
- position_ids (
numpy.ndarrayof shape(batch_size, sequence_length), optional) — 每个输入序列 tokens 在 position embeddings 中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。 - output_attentions (
bool, optional) — 是否返回所有 attention 层的 attentions 张量。 有关更多详细信息，请参阅返回张量下的attentions。 - output_hidden_states (
bool, optional) — 是否返回所有层的 hidden states。 有关更多详细信息，请参阅返回张量下的hidden_states。 - return_dict (
bool, optional) — 是否返回 ModelOutput 而不是普通的 tuple。
返回：
transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPooling 或 tuple(torch.FloatTensor)
一个 transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPooling 或一个 torch.FloatTensor 的 tuple （如果传递了 return_dict=False 或当 config.return_dict=False 时），包含各种元素，具体取决于配置 (<class 'transformers.models.clip.configuration_clip.CLIPTextConfig'>) 和输入。
-
last_hidden_state (
jnp.ndarrayof shape(batch_size, sequence_length, hidden_size)) — 模型最后一层的输出处的 hidden-states 序列。 -
pooler_output (
jnp.ndarrayof shape(batch_size, hidden_size)) — 序列的第一个 token（分类 token）的最后一层 hidden-state，通过线性层和 Tanh 激活函数进一步处理。 线性层权重在预训练期间从下一个句子预测（分类）目标中训练而来。 -
hidden_states (
tuple(jnp.ndarray), optional, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —jnp.ndarray的 tuple （每个嵌入输出一个 + 每层输出一个），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出端的隐藏状态加上初始嵌入输出。
-
attentions (
tuple(jnp.ndarray), optional, 当传递output_attentions=True或当config.output_attentions=True时返回) —jnp.ndarray的 tuple （每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的 attentions 权重，用于计算自注意力头中的加权平均值。
FlaxCLIPTextPreTrainedModel 的 forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的 recipe 需要在此函数中定义，但应该在之后调用 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) statesFlaxCLIPTextModelWithProjection
class transformers.FlaxCLIPTextModelWithProjection
< source >( config: CLIPTextConfig input_shape = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )
__call__
< source >( input_ids attention_mask = None position_ids = None params: dict = None dropout_rng: PRNGKey = None train: bool = False output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → transformers.models.clip.modeling_flax_clip.FlaxCLIPTextModelOutput or tuple(torch.FloatTensor)
参数
- input_ids (
numpy.ndarrayof shape(batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。如果提供 padding，默认情况下将被忽略。可以使用 AutoTokenizer 获取索引。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
numpy.ndarrayof shape(batch_size, sequence_length), optional) — 掩码，用于避免在 padding token 索引上执行 attention。 掩码值在[0, 1]中选择：- 1 表示 未被掩盖 的 tokens，
- 0 表示 被掩盖 的 tokens。
- position_ids (
numpy.ndarrayof shape(batch_size, sequence_length), optional) — 每个输入序列 tokens 在 position embeddings 中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。 - output_attentions (
bool, optional) — 是否返回所有 attention 层的 attentions 张量。 有关更多详细信息，请参阅返回张量下的attentions。 - output_hidden_states (
bool, optional) — 是否返回所有层的 hidden states。 有关更多详细信息，请参阅返回张量下的hidden_states。 - return_dict (
bool, optional) — 是否返回 ModelOutput 而不是普通的 tuple。
返回：
transformers.models.clip.modeling_flax_clip.FlaxCLIPTextModelOutput 或 tuple(torch.FloatTensor)
一个 transformers.models.clip.modeling_flax_clip.FlaxCLIPTextModelOutput 或一个 torch.FloatTensor 的 tuple （如果传递了 return_dict=False 或当 config.return_dict=False 时），包含各种元素，具体取决于配置 (<class 'transformers.models.clip.configuration_clip.CLIPTextConfig'>) 和输入。
-
text_embeds (
jnp.ndarrayof shape(batch_size, output_dim) — 通过将 projection 层应用于 FlaxCLIPTextModel 的 pooled output 获得的文本 embeddings。 -
last_hidden_state (
jnp.ndarrayof shape(batch_size, sequence_length, hidden_size)) — 模型最后一层的输出处的 hidden-states 序列。 -
hidden_states (
tuple(jnp.ndarray), optional, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —jnp.ndarray的 tuple （每个嵌入输出一个 + 每层输出一个），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出端的隐藏状态加上初始嵌入输出。
-
attentions (
tuple(jnp.ndarray), optional, 当传递output_attentions=True或当config.output_attentions=True时返回) —jnp.ndarray的 tuple （每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的 attentions 权重，用于计算自注意力头中的加权平均值。
FlaxCLIPTextPreTrainedModel 的 forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的 recipe 需要在此函数中定义，但应该在之后调用 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_embedsFlaxCLIPVisionModel
class transformers.FlaxCLIPVisionModel
< source >( config: CLIPVisionConfig input_shape: Optional = None seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )
__call__
< source >( pixel_values params: dict = None dropout_rng: PRNGKey = None train: bool = False output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPooling or tuple(torch.FloatTensor)
参数
- pixel_values (
numpy.ndarrayof shape(batch_size, num_channels, height, width)) — 像素值。如果提供 padding，默认情况下将被忽略。 可以使用 AutoImageProcessor 获取像素值。 有关详细信息，请参阅 CLIPImageProcessor.call()。 - output_attentions (
bool, 可选) — 是否返回所有注意力层的 attention 张量。 有关更多详细信息，请参阅返回张量下的attentions。 - output_hidden_states (
bool, 可选) — 是否返回所有层的 hidden state。 有关更多详细信息，请参阅返回张量下的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 (
jnp.ndarrayof shape(batch_size, sequence_length, hidden_size)) — 模型最后一层的输出处的 hidden-states 序列。 -
pooler_output (
jnp.ndarrayof shape(batch_size, hidden_size)) — 序列的第一个 token（分类 token）的最后一层 hidden-state，通过线性层和 Tanh 激活函数进一步处理。 线性层权重在预训练期间从下一个句子预测（分类）目标中训练而来。 -
hidden_states (
tuple(jnp.ndarray), optional, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —jnp.ndarray的 tuple （每个嵌入输出一个 + 每层输出一个），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出端的隐藏状态加上初始嵌入输出。
-
attentions (
tuple(jnp.ndarray), optional, 当传递output_attentions=True或当config.output_attentions=True时返回) —jnp.ndarray的 tuple （每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的 attentions 权重，用于计算自注意力头中的加权平均值。
FlaxCLIPVisionPreTrainedModel 的 forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward 传递的 recipe 需要在此函数中定义，但应该在之后调用 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