Transformers 文档
CLIP
并获得增强的文档体验
开始使用
CLIP
概述
CLIP 模型由 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 在论文 Learning Transferable Visual Models From Natural Language Supervision 中提出。CLIP (Contrastive Language-Image Pre-Training，对比语言-图像预训练) 是一个在各种（图像，文本）对上训练的神经网络。它可以被自然语言指示，以预测给定图像的最相关的文本片段，而无需直接针对任务进行优化，类似于 GPT-2 和 3 的零样本能力。
以下是论文的摘要
最先进的计算机视觉系统被训练来预测一组固定的预定对象类别。这种受限的监督形式限制了它们的通用性和可用性，因为需要额外的标记数据来指定任何其他视觉概念。直接从关于图像的原始文本中学习是一种有希望的替代方案，它可以利用更广泛的监督来源。我们证明，预测哪个标题与哪个图像匹配的简单预训练任务是一种高效且可扩展的方式，可以在从互联网收集的 4 亿（图像，文本）对的数据集上从头开始学习 SOTA 图像表示。在预训练之后，自然语言被用来引用学习到的视觉概念（或描述新的概念），从而实现模型到下游任务的零样本迁移。我们通过在超过 30 个不同的现有计算机视觉数据集上进行基准测试来研究这种方法的性能，涵盖了诸如 OCR、视频中的动作识别、地理定位和多种类型的细粒度对象分类等任务。该模型非平凡地迁移到大多数任务，并且通常与完全监督的基线竞争，而无需任何数据集特定的训练。例如，我们在 ImageNet 上零样本匹配了原始 ResNet-50 的准确率，而无需使用它训练的 128 万个训练示例中的任何一个。我们在此 https URL 上发布了我们的代码和预训练模型权重。
此模型由 valhalla 贡献。 原始代码可以在这里找到。
使用技巧和示例
CLIP 是一种多模态视觉和语言模型。它可用于图像-文本相似性和零样本图像分类。CLIP 使用类似 ViT 的 Transformer 来获取视觉特征，并使用因果语言模型来获取文本特征。然后，文本和视觉特征都被投影到具有相同维度的潜在空间。投影的图像和文本特征之间的点积然后被用作相似度分数。
为了将图像输入到 Transformer 编码器，每张图像被分割成一系列固定大小的非重叠patches，然后进行线性嵌入。[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 的预期加速 部分，并选择合适的注意力实现。
要加载和运行使用 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 推理 页面。
当实现可用时，SDPA 默认用于 torch>=2.1.1，但您也可以在 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。 🌎
- 关于如何使用 Unsplash 和 TMDB 数据集在语义图像搜索上运行 CLIP 的 notebook。 🌎
可解释性
- 关于如何可视化输入 token 和图像片段之间相似性的 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, 可选, 默认为 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) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。 - initializer_factor (
float, 可选, 默认为 1.0) — 用于初始化所有权重矩阵的因子（应保持为 1，内部用于初始化测试）。 - pad_token_id (
int, 可选, 默认为 1) — Padding token id。 - bos_token_id (
int, 可选, 默认为 49406) — Beginning of stream token id。 - eos_token_id (
int, 可选, 默认为 49407) — End of stream 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) — 每个图像块的大小（分辨率）。 - 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，内部用于初始化测试）。
这是一个配置类，用于存储 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。 - 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|>") — 用于填充的 token，例如在对不同长度的序列进行批处理时。
构建 CLIP tokenizer。基于字节级字节对编码 (Byte-Pair-Encoding)。
此 tokenizer 继承自 PreTrainedTokenizer，其中包含大多数主要方法。 用户应参考此超类以获取有关这些方法的更多信息。
build_inputs_with_special_tokens
< source >( token_ids_0: typing.List[int] token_ids_1: typing.Optional[typing.List[int]] = 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: typing.List[int] token_ids_1: typing.Optional[typing.List[int]] = 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: typing.List[int] token_ids_1: typing.Optional[typing.List[int]] = None ) → List[int]
从传递的两个序列创建掩码。 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。默认为"<|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（由 HuggingFace 的 tokenizers 库支持）。基于字节级字节对编码（Byte-Pair-Encoding）。
此 tokenizer 继承自 PreTrainedTokenizerFast，其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。
build_inputs_with_special_tokens
< source >( token_ids_0: typing.List[int] token_ids_1: typing.Optional[typing.List[int]] = 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: typing.List[int] token_ids_1: typing.Optional[typing.List[int]] = None ) → List[int]
从传递的两个序列创建掩码。 CLIP 不使用 token 类型 ID，因此返回零列表。
CLIPImageProcessor
class transformers.CLIPImageProcessor
< source >( do_resize: bool = True size: typing.Dict[str, int] = None resample: Resampling = <Resampling.BICUBIC: 3> do_center_crop: bool = True crop_size: typing.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, typing.List[float], NoneType] = None image_std: typing.Union[float, typing.List[float], NoneType] = None do_convert_rgb: bool = True **kwargs )
参数
- do_resize (
bool, optional, defaults 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: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']] do_resize: bool = None size: typing.Dict[str, int] = 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: typing.Union[float, typing.List[float], NoneType] = None image_std: typing.Union[float, typing.List[float], NoneType] = None do_convert_rgb: 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[transformers.image_utils.ChannelDimension, str, NoneType] = 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 (
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] )
参数
- do_resize (
bool, 可选, 默认为self.do_resize) — 是否将图像的 (height, width) 尺寸调整为指定的size。可以被preprocess方法中的do_resize参数覆盖。 - size (
dict, 可选, 默认为self.size) — 调整大小后输出图像的尺寸。可以被preprocess方法中的size参数覆盖。 - default_to_square (
bool, 可选, 默认为self.default_to_square) — 当调整大小时，如果 size 是整数，是否默认使用方形图像。 - resample (
PILImageResampling, 可选, 默认为self.resample) — 如果调整图像大小，则使用的重采样滤波器。仅当do_resize设置为True时才有效。可以被preprocess方法中的resample参数覆盖。 - do_center_crop (
bool, 可选, 默认为self.do_center_crop) — 是否将图像中心裁剪为指定的crop_size。可以被preprocess方法中的do_center_crop参数覆盖。 - crop_size (
Dict[str, int]可选, 默认为self.crop_size) — 应用center_crop后输出图像的尺寸。可以被preprocess方法中的crop_size参数覆盖。 - do_rescale (
bool, 可选, 默认为self.do_rescale) — 是否按指定的比例rescale_factor缩放图像。可以被preprocess方法中的do_rescale参数覆盖。 - rescale_factor (
int或float, 可选, 默认为self.rescale_factor) — 如果缩放图像，则使用的缩放因子。仅当do_rescale设置为True时才有效。可以被preprocess方法中的rescale_factor参数覆盖。 - do_normalize (
bool, 可选, 默认为self.do_normalize) — 是否对图像进行归一化。可以被preprocess方法中的do_normalize参数覆盖。 可以被preprocess方法中的do_normalize参数覆盖。 - image_mean (
float或List[float], 可选, 默认为self.image_mean) — 如果对图像进行归一化，则使用的均值。这是一个浮点数或浮点数列表，其长度等于图像中的通道数。可以被preprocess方法中的image_mean参数覆盖。 可以被preprocess方法中的image_mean参数覆盖。 - image_std (
float或List[float], 可选, 默认为self.image_std) — 如果对图像进行归一化，则使用的标准差。这是一个浮点数或浮点数列表，其长度等于图像中的通道数。可以被preprocess方法中的image_std参数覆盖。 可以被preprocess方法中的image_std参数覆盖。 - do_convert_rgb (
bool, 可选, 默认为self.do_convert_rgb) — 是否将图像转换为 RGB 格式。 - return_tensors (
str或TensorType, 可选, 默认为self.return_tensors) — 如果设置为 `pt`，则返回堆叠的张量，否则返回张量列表。 - data_format (
ChannelDimension或str, 可选, 默认为self.data_format) — 仅支持ChannelDimension.FIRST。为了与慢速处理器兼容而添加。 - input_data_format (
ChannelDimension或str, 可选, 默认为self.input_data_format) — 输入图像的通道维度格式。如果未设置，则通道维度格式将从输入图像中推断。可以是以下之一："channels_first"或ChannelDimension.FIRST：图像格式为 (num_channels, height, width)。"channels_last"或ChannelDimension.LAST：图像格式为 (height, width, num_channels)。"none"或ChannelDimension.NONE：图像格式为 (height, width)。
- device (
torch.device, 可选, 默认为self.device) — 用于处理图像的设备。如果未设置，则设备将从输入图像中推断。
构建快速 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']] **kwargs: typing_extensions.Unpack[transformers.image_processing_utils_fast.DefaultFastImageProcessorKwargs] )
参数
- images (
ImageInput) — 要预处理的图像。期望是像素值范围为 0 到 255 的单个或批量图像。如果传入的图像像素值介于 0 和 1 之间，请设置do_rescale=False。 - do_resize (
bool, 可选, 默认为self.do_resize) — 是否调整图像大小。 - size (
Dict[str, int], 可选, 默认为self.size) — 描述模型的最大输入尺寸。 - resample (
PILImageResampling或InterpolationMode, 可选, 默认为self.resample) — 如果调整图像大小，则使用的重采样滤波器。可以是枚举PILImageResampling中的一个。仅当do_resize设置为True时才有效。 - do_center_crop (
bool, 可选, 默认为self.do_center_crop) — 是否对图像进行中心裁剪。 - crop_size (
Dict[str, int], 可选, 默认为self.crop_size) — 应用center_crop后输出图像的尺寸。 - do_rescale (
bool, 可选, 默认为self.do_rescale) — 是否缩放图像。 - rescale_factor (
float, 可选, 默认为self.rescale_factor) — 如果do_rescale设置为True，则用于缩放图像的缩放因子。 - do_normalize (
bool, 可选, 默认为self.do_normalize) — 是否对图像进行归一化。 - image_mean (
float或List[float], 可选, 默认为self.image_mean) — 用于归一化的图像均值。仅当do_normalize设置为True时才有效。 - image_std (
float或List[float], 可选, 默认为self.image_std) — 用于归一化的图像标准差。仅当do_normalize设置为True时有效。 - do_convert_rgb (
bool, 可选, 默认为self.do_convert_rgb) — 是否将图像转换为 RGB 格式。 - return_tensors (
str或TensorType, 可选, 默认为self.return_tensors) — 如果设置为 `pt`，则返回堆叠的张量，否则返回张量列表。 - data_format (
ChannelDimension或str, 可选, 默认为self.data_format) — 仅支持ChannelDimension.FIRST。 为了与慢速处理器兼容而添加。 - input_data_format (
ChannelDimension或str, 可选, 默认为self.input_data_format) — 输入图像的通道维度格式。 如果未设置，则通道维度格式将从输入图像中推断。 可以是以下之一："channels_first"或ChannelDimension.FIRST：图像格式为 (num_channels, height, width)。"channels_last"或ChannelDimension.LAST：图像格式为 (height, width, num_channels)。"none"或ChannelDimension.NONE：图像格式为 (height, width)。
- device (
torch.device, 可选, 默认为self.device) — 用于处理图像的设备。 如果未设置，则设备将从输入图像中推断。
预处理图像或批量图像。
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() 方法加载模型权重。
此模型继承自 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 return_dict: typing.Optional[bool] = None ) → transformers.models.clip.modeling_clip.CLIPOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (形状为
(batch_size, sequence_length)的torch.LongTensor) — 词汇表中输入序列标记的索引。 默认情况下，如果您提供填充，填充将被忽略。索引可以使用 AutoTokenizer 获得。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (形状为
(batch_size, sequence_length)的torch.Tensor, 可选) — 掩码，以避免对填充标记索引执行注意力机制。 掩码值在[0, 1]中选择：- 1 表示未被掩盖的标记，
- 0 表示被掩盖的标记。
- position_ids (形状为
(batch_size, sequence_length)的torch.LongTensor, 可选) — 每个输入序列标记在位置嵌入中的位置索引。 在范围[0, config.max_position_embeddings - 1]中选择。 - pixel_values (形状为
(batch_size, num_channels, height, width)的torch.FloatTensor) — 像素值。 默认情况下，如果您提供填充，填充将被忽略。 像素值可以使用 AutoImageProcessor 获得。 有关详细信息，请参阅 CLIPImageProcessor.call()。 - return_loss (
bool, 可选) — 是否返回对比损失。 - output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。 有关更多详细信息，请参阅返回张量下的attentions。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。 更多细节请查看返回张量下的hidden_states。 - interpolate_pos_encoding (
bool, 可选, 默认值False) — 是否插值预训练的位置编码。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通的元组。
返回值
transformers.models.clip.modeling_clip.CLIPOutput 或 tuple(torch.FloatTensor)
一个 transformers.models.clip.modeling_clip.CLIPOutput 或一个 torch.FloatTensor 元组 (如果传递了 return_dict=False 或者当 config.return_dict=False 时)，包含各种元素，具体取决于配置 (<class 'transformers.models.clip.configuration_clip.CLIPConfig'>) 和输入。
- loss (形状为
(1,)的torch.FloatTensor，可选，当return_loss为True时返回) — 图像-文本相似度的对比损失。 - logits_per_image (形状为
(image_batch_size, text_batch_size)的torch.FloatTensor) —image_embeds和text_embeds之间缩放的点积分数。 这表示图像-文本相似度分数。 - logits_per_text (形状为
(text_batch_size, image_batch_size)的torch.FloatTensor) —text_embeds和image_embeds之间缩放的点积分数。 这表示文本-图像相似度分数。 - text_embeds (形状为
(batch_size, output_dim) 的torch.FloatTensor) — 通过将投影层应用于 CLIPTextModel 的池化输出而获得的文本嵌入。 - image_embeds (形状为
(batch_size, output_dim) 的torch.FloatTensor) — 通过将投影层应用于 CLIPVisionModel 的池化输出而获得的图像嵌入。 - text_model_output (
BaseModelOutputWithPooling) — CLIPTextModel 的输出。 - vision_model_output (
BaseModelOutputWithPooling) — CLIPVisionModel 的输出。
CLIPModel 的前向传播方法，覆盖了 __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 probabilitiesget_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 return_dict: typing.Optional[bool] = None ) → text_features (torch.FloatTensor of shape (batch_size, output_dim)
参数
- input_ids (形状为
(batch_size, sequence_length)的torch.LongTensor) — 词汇表中输入序列 tokens 的索引。 默认情况下，如果您提供填充，则会忽略填充。可以使用 AutoTokenizer 获取索引。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (形状为
(batch_size, sequence_length)的torch.Tensor，可选) — 用于避免在填充 token 索引上执行 attention 的 Mask。 Mask 值在[0, 1]中选择：- 1 表示 未被屏蔽 的 tokens，
- 0 表示 被屏蔽 的 tokens。
- position_ids (形状为
(batch_size, sequence_length)的torch.LongTensor，可选) — 每个输入序列 tokens 在位置嵌入中的位置索引。 在范围[0, config.max_position_embeddings - 1]中选择。 - output_attentions (
bool, 可选) — 是否返回所有 attention 层的 attention 张量。 更多细节请查看返回张量下的attentions。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。 更多细节请查看返回张量下的hidden_states。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通的元组。
返回值
text_features (形状为 (batch_size, output_dim) 的 torch.FloatTensor)
通过将投影层应用于 CLIPTextModel 的池化输出而获得的文本嵌入。
CLIPModel 的前向传播方法，覆盖了 __call__ 特殊方法。
虽然前向传播的配方需要在该函数内定义，但应该在之后调用 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: typing.Optional[torch.FloatTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None interpolate_pos_encoding: bool = False return_dict: typing.Optional[bool] = None ) → image_features (torch.FloatTensor of shape (batch_size, output_dim)
参数
- pixel_values (形状为
(batch_size, num_channels, height, width)的torch.FloatTensor) — 像素值。 默认情况下，如果您提供填充，则会忽略填充。 可以使用 AutoImageProcessor 获取像素值。 有关详细信息，请参阅 CLIPImageProcessor.call()。 - output_attentions (
bool, 可选) — 是否返回所有 attention 层的 attention 张量。 更多细节请查看返回张量下的attentions。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。 更多细节请查看返回张量下的hidden_states。 - interpolate_pos_encoding (
bool, 可选, 默认值False) — 是否插值预训练的位置编码。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通的元组。
返回值
image_features (形状为 (batch_size, output_dim) 的 torch.FloatTensor)
通过将投影层应用于 CLIPVisionModel 的池化输出而获得的图像嵌入。
CLIPModel 的前向传播方法，覆盖了 __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(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。 查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝 head 等）。
此模型也是 PyTorch torch.nn.Module 子类。 将其用作常规 PyTorch 模块，并参阅 PyTorch 文档，了解与常规用法和行为相关的所有事项。
forward
< 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 return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.BaseModelOutputWithPooling 或 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 索引上执行注意力机制。 掩码值在[0, 1]中选择：- 1 表示 未被掩盖 的 tokens，
- 0 表示 被掩盖 的 tokens。
- position_ids (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 位置嵌入中每个输入序列 tokens 的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。 - output_attentions (
bool，可选) — 是否返回所有注意力层的注意力张量。 有关更多详细信息，请参阅返回张量下的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。 有关更多详细信息，请参阅返回张量下的hidden_states。 - return_dict (
bool，可选) — 是否返回 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.CLIPTextConfig'>) 和输入。
-
last_hidden_state (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层的输出处的隐藏状态序列。 -
pooler_output (
torch.FloatTensor，形状为(batch_size, hidden_size)) — 序列的第一个 token（分类 token）的最后一层隐藏状态，在经过用于辅助预训练任务的层进一步处理之后。例如，对于 BERT 系列模型，这返回通过线性层和 tanh 激活函数处理后的分类 token。线性层权重在预训练期间从下一句预测（分类）目标中训练而来。 -
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 forward 方法，覆盖了 __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) statesCLIPTextModelWithProjection
class transformers.CLIPTextModelWithProjection
< source >( config: CLIPTextConfig )
参数
- config (CLIPConfig) — 带有模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型关联的权重，仅加载配置。 查看 from_pretrained() 方法以加载模型权重。
带有顶部投影层的 CLIP 文本模型（池化输出顶部的线性层）。
此模型继承自 PreTrainedModel。 查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
此模型也是 PyTorch torch.nn.Module 子类。 将其用作常规 PyTorch 模块，并参阅 PyTorch 文档，了解与常规用法和行为相关的所有事项。
forward
< 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 return_dict: typing.Optional[bool] = None ) → transformers.models.clip.modeling_clip.CLIPTextModelOutput 或 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 索引上执行注意力机制。 掩码值在[0, 1]中选择：- 1 表示 未被掩盖 的 tokens，
- 0 表示 被掩盖 的 tokens。
- position_ids (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 位置嵌入中每个输入序列 tokens 的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。 - output_attentions (
bool，可选) — 是否返回所有注意力层的注意力张量。 有关更多详细信息，请参阅返回张量下的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。 有关更多详细信息，请参阅返回张量下的hidden_states。 - return_dict (
bool，可选) — 是否返回 ModelOutput 而不是普通元组。
返回值
transformers.models.clip.modeling_clip.CLIPTextModelOutput 或 tuple(torch.FloatTensor)
一个 transformers.models.clip.modeling_clip.CLIPTextModelOutput 或一个 torch.FloatTensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），包含各种元素，具体取决于配置 (<class 'transformers.models.clip.configuration_clip.CLIPTextConfig'>) 和输入。
-
text_embeds (
torch.FloatTensor，形状为(batch_size, output_dim)可选，当模型使用with_projection=True初始化时返回) — 通过将投影层应用于 pooler_output 获得的文本嵌入。 -
last_hidden_state (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层的输出处的隐藏状态序列。 -
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 forward 方法，覆盖了 __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_embedsCLIPVisionModelWithProjection
class transformers.CLIPVisionModelWithProjection
< source >( config: CLIPVisionConfig )
参数
- config (CLIPConfig) — 带有模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型关联的权重，仅加载配置。 查看 from_pretrained() 方法以加载模型权重。
带有顶部投影层的 CLIP 视觉模型（池化输出顶部的线性层）。
此模型继承自 PreTrainedModel。 查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
此模型也是 PyTorch torch.nn.Module 子类。 将其用作常规 PyTorch 模块，并参阅 PyTorch 文档，了解与常规用法和行为相关的所有事项。
forward
< 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 return_dict: typing.Optional[bool] = None ) → transformers.models.clip.modeling_clip.CLIPVisionModelOutput 或 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。 - interpolate_pos_encoding (
bool, optional, defaultsFalse) — 是否插值预训练的位置编码。(默认:False) - 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 (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层的输出处的隐藏状态序列。 -
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 的 forward 方法，覆盖了 __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_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: typing.Optional[torch.FloatTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None interpolate_pos_encoding: bool = False return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.BaseModelOutputWithPooling 或 tuple(torch.FloatTensor)
参数
- pixel_values (
torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 像素值。 默认情况下，如果您提供 padding，则会被忽略。 像素值可以使用 AutoImageProcessor 获得。 有关详细信息，请参阅 CLIPImageProcessor.call()。 - output_attentions (
bool, optional) — 是否返回所有注意力层的注意力张量。 详见返回张量下的attentions。 - output_hidden_states (
bool, optional) — 是否返回所有层的隐藏状态。 详见返回张量下的hidden_states。 - interpolate_pos_encoding (
bool, optional, defaultsFalse) — 是否插值预训练的位置编码。(默认:False) - 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 (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层的输出处的隐藏状态序列。 -
pooler_output (
torch.FloatTensor，形状为(batch_size, hidden_size)) — 序列的第一个 token（分类 token）的最后一层隐藏状态，在经过用于辅助预训练任务的层进一步处理之后。例如，对于 BERT 系列模型，这返回通过线性层和 tanh 激活函数处理后的分类 token。线性层权重在预训练期间从下一句预测（分类）目标中训练而来。 -
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 的 forward 方法，覆盖了 __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 statesCLIPForImageClassification
class transformers.CLIPForImageClassification
< source >( config: CLIPConfig )
参数
- config (CLIPConfig) — 带有模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型关联的权重，仅加载配置。 查看 from_pretrained() 方法来加载模型权重。
CLIP 视觉编码器，顶部带有一个图像分类 head（patch tokens 的池化最终隐藏状态之上的线性层），例如用于 ImageNet。
此模型继承自 PreTrainedModel。 查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
此模型也是 PyTorch torch.nn.Module 子类。 将其用作常规 PyTorch 模块，并参阅 PyTorch 文档，了解与常规用法和行为相关的所有事项。
forward
< source >( 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 return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.ImageClassifierOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor，形状为(batch_size, sequence_length)) — 输入序列 token 在词汇表中的索引。 默认情况下，如果您提供 padding，则会被忽略。索引可以使用 AutoTokenizer 获得。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor，形状为(batch_size, sequence_length), optional) — Mask，用于避免在 padding token 索引上执行注意力机制。 Mask 值在[0, 1]中选择：- 1 表示 未被 mask 的 token，
- 0 表示 被 mask 的 token。
- position_ids (
torch.LongTensor，形状为(batch_size, sequence_length), optional) — 每个输入序列 token 在位置嵌入中的位置索引。 在范围[0, config.max_position_embeddings - 1]中选择。 - pixel_values (
torch.FloatTensor，形状为(batch_size, num_channels, height, width)) — 像素值。 默认情况下，如果您提供 padding，则会被忽略。 像素值可以使用 AutoImageProcessor 获得。 有关详细信息，请参阅 CLIPImageProcessor.call()。 - return_loss (
bool, optional) — 是否返回对比损失。 - output_attentions (
bool, optional) — 是否返回所有注意力层的注意力张量。 详见返回张量下的attentions。 - output_hidden_states (
bool, optional) — 是否返回所有层的隐藏状态。 详见返回张量下的hidden_states。 - interpolate_pos_encoding (
bool, 可选, 默认值False) — 是否插值预训练的位置编码。 - return_dict (
bool, 可选) — 是否返回 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 之后的注意力权重，用于计算自注意力头中的加权平均值。
CLIPForImageClassification 的 forward 方法，覆盖了 __call__ 特殊方法。
虽然前向传播的配方需要在该函数内定义，但应该在之后调用 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__ 特殊方法。
虽然前向传播的配方需要在该函数内定义，但应该在之后调用 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)，可选) — 用于避免在 padding 标记索引上执行 attention 的掩码。掩码值在[0, 1]中选择：- 1 表示未被掩盖的标记，
- 0 表示被掩盖的标记。
- position_ids (
np.ndarray或tf.Tensor，形状为(batch_size, sequence_length)，可选) — 位置嵌入中每个输入序列标记的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。 - output_attentions (
bool，可选) — 是否返回所有 attention 层的 attentions 张量。 更多详细信息，请参阅返回张量下的attentions。 此参数只能在 eager 模式下使用，在 graph 模式下将使用配置中的值。 - output_hidden_states (
bool，可选) — 是否返回所有层的 hidden states。 更多详细信息，请参阅返回张量下的hidden_states。 此参数只能在 eager 模式下使用，在 graph 模式下将使用配置中的值。 - return_dict (
bool，可选) — 是否返回 ModelOutput 而不是纯粹的元组。 此参数可以在 eager 模式下使用，在 graph 模式下该值将始终设置为 True。 - training (
bool，可选，默认为 `False`) — 是否在训练模式下使用模型（dropout 模块等某些模块在训练和评估之间具有不同的行为）。
返回值
text_features (tf.Tensor，形状为 (batch_size, output_dim)
通过将投影层应用于 TFCLIPTextModel 的 pooled output 获得的文本嵌入。
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
< 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，可选): 是否返回所有 attention 层的 attentions 张量。 更多详细信息，请参阅返回张量下的attentions。 此参数只能在 eager 模式下使用，在 graph 模式下将使用配置中的值。 - output_hidden_states (
bool，可选) — 是否返回所有层的 hidden states。 更多详细信息，请参阅返回张量下的hidden_states。 此参数只能在 eager 模式下使用，在 graph 模式下将使用配置中的值。 - return_dict (
bool，可选) — 是否返回 ModelOutput 而不是纯粹的元组。 此参数可以在 eager 模式下使用，在 graph 模式下该值将始终设置为 True。 - training (
bool，可选，默认为 `False`) — 是否在训练模式下使用模型（dropout 模块等某些模块在训练和评估之间具有不同的行为）。
返回值
image_features (tf.Tensor，形状为 (batch_size, output_dim)
通过将投影层应用于 TFCLIPVisionModel 的 pooled output 获得的图像嵌入。
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
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 标记索引上执行 attention 的掩码。掩码值在[0, 1]中选择：- 1 表示未被掩盖的标记，
- 0 表示被掩盖的标记。
- position_ids (
np.ndarray或tf.Tensor，形状为(batch_size, sequence_length)，可选) — 位置嵌入中每个输入序列标记的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。 - output_attentions (
bool，可选) — 是否返回所有 attention 层的 attentions 张量。 更多详细信息，请参阅返回张量下的attentions。 此参数只能在 eager 模式下使用，在 graph 模式下将使用配置中的值。 - output_hidden_states (
bool，可选) — 是否返回所有层的 hidden states。 更多详细信息，请参阅返回张量下的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.CLIPTextConfig'>) 和输入。
-
last_hidden_state (
tf.Tensor，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层的输出处的 hidden-states 序列。 -
pooler_output (
tf.Tensor，形状为(batch_size, hidden_size)) — 序列的第一个标记（分类标记）的最后一层 hidden-state，通过线性层和 Tanh 激活函数进一步处理。 线性层权重在预训练期间从下一句预测（分类）目标中训练而来。此输出通常不是输入语义内容的良好摘要，对于整个输入序列，您通常最好使用平均或池化 hidden-states 序列。
-
hidden_states (
tuple(tf.Tensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —tf.Tensor元组（每个嵌入的输出一个 + 每个层的输出一个），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出以及初始嵌入输出处的 Hidden-states。
-
attentions (
tuple(tf.Tensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回) —tf.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
TFCLIPTextModel 前向方法，覆盖了 __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) 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 or tuple(tf.Tensor)
参数
- pixel_values (
np.ndarray,tf.Tensor,List[tf.Tensor]`Dict[str, tf.Tensor]orDict[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)) — 模型最后一层的输出处的 hidden-states 序列。 -
pooler_output (
tf.Tensor，形状为(batch_size, hidden_size)) — 序列的第一个标记（分类标记）的最后一层 hidden-state，通过线性层和 Tanh 激活函数进一步处理。 线性层权重在预训练期间从下一句预测（分类）目标中训练而来。此输出通常不是输入语义内容的良好摘要，对于整个输入序列，您通常最好使用平均或池化 hidden-states 序列。
-
hidden_states (
tuple(tf.Tensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —tf.Tensor元组（每个嵌入的输出一个 + 每个层的输出一个），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出以及初始嵌入输出处的 Hidden-states。
-
attentions (
tuple(tf.Tensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回) —tf.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
TFCLIPVisionModel 前向方法，覆盖了 __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 statesFlaxCLIPModel
class transformers.FlaxCLIPModel
< source >( config: CLIPConfig input_shape: typing.Optional[typing.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执行。请注意，这仅指定计算的 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: <function PRNGKey at 0x7f787eb14310> = 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 (形状为
(batch_size, sequence_length)的numpy.ndarray) — 词汇表中输入序列标记的索引。 如果您提供填充，默认情况下将忽略填充。索引可以使用 AutoTokenizer 获得。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (形状为
(batch_size, sequence_length)的numpy.ndarray, 可选) — 掩码，以避免对填充令牌索引执行注意力。 在[0, 1]中选择的掩码值：- 1 表示未被掩码的令牌，
- 0 表示被掩码的令牌。
- position_ids (形状为
(batch_size, sequence_length)的numpy.ndarray, 可选) — 每个输入序列标记在位置嵌入中的位置索引。 在范围[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 的池化输出而获得的文本嵌入。 - 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 probabilitiesget_text_features
< source >( input_ids attention_mask = None position_ids = None params: dict = None dropout_rng: <function PRNGKey at 0x7f787eb14310> = None train = False ) → text_features (形状为 (batch_size, output_dim) 的 jnp.ndarray)
参数
- input_ids (形状为
(batch_size, sequence_length)的numpy.ndarray) — 词汇表中输入序列标记的索引。 如果您提供填充，默认情况下将忽略填充。索引可以使用 AutoTokenizer 获得。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
返回值
text_features (形状为 (batch_size, output_dim) 的 jnp.ndarray)
通过将投影层应用于 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
< source >( pixel_values params: dict = None dropout_rng: <function PRNGKey at 0x7f787eb14310> = None train = False ) → image_features (形状为 (batch_size, output_dim) 的 jnp.ndarray)
参数
- 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
< 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: <function PRNGKey at 0x7f787eb14310> = 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)) — 词汇表中输入序列 tokens 的索引。默认情况下，如果您提供填充，则填充将被忽略。索引可以使用 AutoTokenizer 获得。 有关详细信息，请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
numpy.ndarray，形状为(batch_size, sequence_length)，可选) — 用于避免对 padding token 索引执行 attention 的掩码。掩码值在[0, 1]中选择：- 1 表示 未被掩蔽 的 tokens，
- 0 表示 被掩蔽 的 tokens。
- position_ids (
numpy.ndarray，形状为(batch_size, sequence_length)，可选) — 位置嵌入中每个输入序列 tokens 的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。 - output_attentions (
bool, 可选) — 是否返回所有 attention 层的 attentions 张量。 有关更多详细信息，请参见返回张量下的attentions。 - output_hidden_states (
bool, 可选) — 是否返回所有层的 hidden states。 有关更多详细信息，请参见返回张量下的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 (
jnp.ndarray，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层输出端的 hidden-states 序列。 -
pooler_output (
jnp.ndarray，形状为(batch_size, hidden_size)) — 序列的第一个 token（分类 token）的最后一层 hidden-state，通过线性层和 Tanh 激活函数进一步处理。 线性层权重通过预训练期间的下一句预测（分类）目标进行训练。 -
hidden_states (
tuple(jnp.ndarray), 可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的jnp.ndarray元组（一个用于嵌入的输出 + 一个用于每层的输出）。模型在每一层输出以及初始嵌入输出处的 Hidden-states。
-
attentions (
tuple(jnp.ndarray), 可选，当传递output_attentions=True或当config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元组（每层一个）。注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
FlaxCLIPTextPreTrainedModel 的 forward 方法，覆盖了 __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) 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: <function PRNGKey at 0x7f787eb14310> = 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)) — 词汇表中输入序列 tokens 的索引。默认情况下，如果您提供填充，则填充将被忽略。索引可以使用 AutoTokenizer 获得。 有关详细信息，请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
numpy.ndarray，形状为(batch_size, sequence_length)，可选) — 用于避免对 padding token 索引执行 attention 的掩码。掩码值在[0, 1]中选择：- 1 表示 未被掩蔽 的 tokens，
- 0 表示 被掩蔽 的 tokens。
- position_ids (
numpy.ndarray，形状为(batch_size, sequence_length)，可选) — 位置嵌入中每个输入序列 tokens 的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。 - output_attentions (
bool, 可选) — 是否返回所有 attention 层的 attentions 张量。 有关更多详细信息，请参见返回张量下的attentions。 - output_hidden_states (
bool, 可选) — 是否返回所有层的 hidden states。 有关更多详细信息，请参见返回张量下的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 (
jnp.ndarray，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层输出端的 hidden-states 序列。 -
hidden_states (
tuple(jnp.ndarray), 可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的jnp.ndarray元组（一个用于嵌入的输出 + 一个用于每层的输出）。模型在每一层输出以及初始嵌入输出处的 Hidden-states。
-
attentions (
tuple(jnp.ndarray), 可选，当传递output_attentions=True或当config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元组（每层一个）。注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
FlaxCLIPTextPreTrainedModel 的 forward 方法，覆盖了 __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_embedsFlaxCLIPVisionModel
class transformers.FlaxCLIPVisionModel
< source >( config: CLIPVisionConfig input_shape: typing.Optional[typing.Tuple] = None seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )
__call__
< source >( pixel_values params: dict = None dropout_rng: <function PRNGKey at 0x7f787eb14310> = 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)) — 像素值。默认情况下，如果您提供填充，则会忽略填充。像素值可以使用 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 (
jnp.ndarray，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层输出端的 hidden-states 序列。 -
pooler_output (
jnp.ndarray，形状为(batch_size, hidden_size)) — 序列的第一个 token（分类 token）的最后一层 hidden-state，通过线性层和 Tanh 激活函数进一步处理。 线性层权重通过预训练期间的下一句预测（分类）目标进行训练。 -
hidden_states (
tuple(jnp.ndarray), 可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的jnp.ndarray元组（一个用于嵌入的输出 + 一个用于每层的输出）。模型在每一层输出以及初始嵌入输出处的 Hidden-states。
-
attentions (
tuple(jnp.ndarray), 可选，当传递output_attentions=True或当config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元组（每层一个）。注意力 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