Transformers 文档

SigLIP

Hugging Face's logo
加入Hugging Face社区

并获得增强型文档体验

开始使用

SigLIP

概述

SigLIP 模型在 Xiaohua Zhai、Basil Mustafa、Alexander Kolesnikov 和 Lucas Beyer 发表的论文 Sigmoid Loss for Language Image Pre-Training 中被提出。SigLIP 建议用简单的成对 sigmoid 损失函数替换 CLIP 中使用的损失函数。这导致 ImageNet 零样本分类准确率方面性能的提升。

论文摘要如下:

我们提出了一种用于语言图像预训练的简单成对 Sigmoid 损失函数 (SigLIP)。与使用 softmax 归一化的标准对比学习不同,sigmoid 损失仅作用于图像-文本对,不需要全局查看成对相似度以进行归一化。sigmoid 损失同时允许进一步扩大批量大小,并且在较小的批量大小下也表现更好。结合锁定图像微调,仅使用四个 TPUv4 芯片,我们在两天内训练了一个 SigLiT 模型,在 ImageNet 上实现了 84.5% 的零样本准确率。批量大小与损失函数的解耦使我们能够进一步研究示例与对以及负样本与正样本比率的影响。最后,我们将批量大小推向极端,高达一百万,发现批量大小增长的益处迅速减弱,更合理的批量大小为 32k 就足够了。

使用技巧

  • SigLIP 的使用方式与 CLIP 类似。主要区别在于训练损失函数,它不需要全局查看批次中所有图像和文本的成对相似度。需要对 logits 应用 sigmoid 激活函数,而不是 softmax。
  • 支持训练,但未使用 torch.distributed 工具,这可能会限制批量大小的可扩展性。但是,DDP 和 FDSP 在单节点多 GPU 设置上有效。
  • 当使用独立的 SiglipTokenizerSiglipProcessor 时,请确保传递 padding="max_length",因为模型就是以此方式进行训练的。
  • 要获得与管道相同的结果,应使用提示模板“This is a photo of {label}.”。
drawing SigLIP 评估结果与 CLIP 的对比。摘自 原始论文

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

使用示例

使用 SigLIP 主要有两种方法:一种是使用管道 API,它可以为您抽象化所有复杂性;另一种是自行使用 SiglipModel 类。

管道 API

管道允许您在几行代码中使用模型

>>> from transformers import pipeline
>>> from PIL import Image
>>> import requests

>>> # load pipe
>>> image_classifier = pipeline(task="zero-shot-image-classification", model="google/siglip-base-patch16-224")

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

>>> # inference
>>> candidate_labels = ["2 cats", "a plane", "a remote"]
>>> outputs = image_classifier(image, candidate_labels=candidate_labels)
>>> outputs = [{"score": round(output["score"], 4), "label": output["label"] } for output in outputs]
>>> print(outputs)
[{'score': 0.1979, 'label': '2 cats'}, {'score': 0.0, 'label': 'a remote'}, {'score': 0.0, 'label': 'a plane'}]

自行使用模型

如果您想自行进行预处理和后处理,以下是操作方法:

>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, AutoModel
>>> import torch

>>> model = AutoModel.from_pretrained("google/siglip-base-patch16-224")
>>> processor = AutoProcessor.from_pretrained("google/siglip-base-patch16-224")

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

>>> candidate_labels = ["2 cats", "2 dogs"]
# follows the pipeline prompt template to get same results
>>> candidate_labels = [f'This is a photo of {label}.' for label in candidate_labels]
>>> # important: we pass `padding=max_length` since the model was trained with this
>>> inputs = processor(text=texts, images=image, padding="max_length", return_tensors="pt")

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

>>> logits_per_image = outputs.logits_per_image
>>> probs = torch.sigmoid(logits_per_image) # these are the probabilities
>>> print(f"{probs[0][0]:.1%} that image 0 is '{texts[0]}'")
31.9% that image 0 is 'a photo of 2 cats'

资源

一系列官方 Hugging Face 和社区(以 🌎 表示)资源,可帮助您开始使用 SigLIP。

如果您有兴趣提交要包含在此处的资源,请随时提交拉取请求,我们将对其进行审查!理想情况下,该资源应展示一些新内容,而不是重复现有资源。

结合 SigLIP 和 Flash Attention 2

首先,请确保安装最新版本的 Flash Attention 2。

pip install -U flash-attn --no-build-isolation

还要确保您的硬件与 Flash Attention 2 兼容。请在 flash-attn 存储库的官方文档中阅读更多相关信息。还要确保以半精度加载模型(例如 torch.float16)。

要使用 Flash Attention 2 加载和运行模型,请参考以下代码片段:

>>> import torch
>>> import requests
>>> from PIL import Image
>>> from transformers import SiglipProcessor, SiglipModel
>>> device = "cuda" # the device to load the model onto

>>> model = SiglipModel.from_pretrained(
...     "google/siglip-so400m-patch14-384",
...     attn_implementation="flash_attention_2",
...     torch_dtype=torch.float16,
...     device_map=device,
... )
>>> processor = SiglipProcessor.from_pretrained("google/siglip-so400m-patch14-384")

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

>>> candidate_labels = ["2 cats", "2 dogs"]
# follows the pipeline prompt template to get same results
>>> candidate_labels = [f'This is a photo of {label}.' for label in candidate_labels]
# important: we pass `padding=max_length` since the model was trained with this
>>> inputs = processor(text=candidate_labels, images=image, padding="max_length", return_tensors="pt")
>>> inputs.to(device)

>>> with torch.no_grad():
...     with torch.autocast(device):
...         outputs = model(**inputs)

>>> logits_per_image = outputs.logits_per_image
>>> probs = torch.sigmoid(logits_per_image) # these are the probabilities
>>> print(f"{probs[0][0]:.1%} that image 0 is '{candidate_labels[0]}'")
51.3% that image 0 is 'This is a photo of 2 cats.'

使用缩放点积注意力 (SDPA)

PyTorch 将本机缩放点积注意力 (SDPA) 运算符作为 torch.nn.functional 的一部分包含在内。此函数包含多个实现,可以根据输入和使用的硬件应用。请参阅 官方文档GPU 推理 页面以获取更多信息。

您可以在 from_pretrained() 中设置 attn_implementation="sdpa" 以显式请求使用 SDPA。请确保您拥有 torch>=2.1.1

>>> from transformers import SiglipModel

>>> model = SiglipModel.from_pretrained(
...     "google/siglip-so400m-patch14-384",
...     attn_implementation="sdpa",
...     torch_dtype=torch.float16,
...     device_map=device,
... )

为了获得最佳加速效果,我们建议以半精度加载模型(例如 torch.float16torch.bfloat16)。

预期加速

下图显示了预期加速情况,比较了使用 google/siglip-so400m-patch14-384 检查点以 float16 精度在 transformers 中进行原生实现的推理时间与使用不同批量大小的模型的 Flash Attention 2/SDPA 版本的推理时间。

SiglipConfig

transformers.SiglipConfig

< >

( text_config = None vision_config = None **kwargs )

参数

  • text_config (dict, 可选) — 用于初始化 SiglipTextConfig 的配置选项字典。
  • vision_config (dict, 可选) — 用于初始化 SiglipVisionConfig 的配置选项字典。
  • kwargs (可选) — 关键字参数字典。

SiglipConfig 是用于存储 SiglipModel 配置的配置类。它用于根据指定的参数实例化 Siglip 模型,定义文本模型和视觉模型的配置。使用默认值实例化配置将产生与 Siglip google/siglip-base-patch16-224 架构类似的配置。

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

示例

>>> from transformers import SiglipConfig, SiglipModel

>>> # Initializing a SiglipConfig with google/siglip-base-patch16-224 style configuration
>>> configuration = SiglipConfig()

>>> # Initializing a SiglipModel (with random weights) from the google/siglip-base-patch16-224 style configuration
>>> model = SiglipModel(configuration)

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

>>> # We can also initialize a SiglipConfig from a SiglipTextConfig and a SiglipVisionConfig
>>> from transformers import SiglipTextConfig, SiglipVisionConfig

>>> # Initializing a SiglipText and SiglipVision configuration
>>> config_text = SiglipTextConfig()
>>> config_vision = SiglipVisionConfig()

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

from_text_vision_configs

< >

( text_config: SiglipTextConfig vision_config: SiglipVisionConfig **kwargs ) SiglipConfig

返回值

SiglipConfig

配置对象的实例

从 siglip 文本模型配置和 siglip 视觉模型配置实例化 SiglipConfig(或派生类)。

SiglipTextConfig

transformers.SiglipTextConfig

< >

( vocab_size = 32000 hidden_size = 768 intermediate_size = 3072 num_hidden_layers = 12 num_attention_heads = 12 max_position_embeddings = 64 hidden_act = 'gelu_pytorch_tanh' layer_norm_eps = 1e-06 attention_dropout = 0.0 pad_token_id = 1 bos_token_id = 49406 eos_token_id = 49407 **kwargs )

参数

  • 词汇量 (int, 可选, 默认为 32000) — Siglip 文本模型的词汇量。定义了调用 SiglipModel 时传递的 inputs_ids 可以表示的不同标记的数量。
  • 隐藏层大小 (int, 可选, 默认为 768) — 编码器层和池化层的维度。
  • 中间层大小 (int, 可选, 默认为 3072) — Transformer 编码器中“中间”(即前馈)层的维度。
  • 隐藏层数量 (int, 可选, 默认为 12) — Transformer 编码器中的隐藏层数量。
  • 注意力头数量 (int, 可选, 默认为 12) — Transformer 编码器中每个注意力层的注意力头数量。
  • 最大位置嵌入数 (int, 可选, 默认为 64) — 此模型可能使用的最大序列长度。通常将此设置为一个较大的值以防万一(例如,512 或 1024 或 2048)。
  • 隐藏层激活函数 (strfunction, 可选, 默认为 "gelu_pytorch_tanh") — 编码器和池化器中的非线性激活函数(函数或字符串)。如果为字符串,则支持 "gelu""relu""selu""gelu_new" "quick_gelu"
  • 层归一化ε (float, 可选, 默认为 1e-06) — 层归一化层使用的ε。
  • 注意力dropout (float, 可选, 默认为 0.0) — 注意力概率的dropout比率。
  • bos_token_id (int, 可选, 默认为 49406) — 词汇表中序列开始标记的 ID。
  • eos_token_id (int, 可选, 默认为 49407) — 词汇表中序列结束标记的 ID。

这是用于存储 SiglipTextModel 配置的配置类。它用于根据指定的参数实例化 Siglip 文本编码器,定义模型架构。使用默认值实例化配置将产生与 Siglip google/siglip-base-patch16-224 架构的文本编码器的配置类似的配置。

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

示例

>>> from transformers import SiglipTextConfig, SiglipTextModel

>>> # Initializing a SiglipTextConfig with google/siglip-base-patch16-224 style configuration
>>> configuration = SiglipTextConfig()

>>> # Initializing a SiglipTextModel (with random weights) from the google/siglip-base-patch16-224 style configuration
>>> model = SiglipTextModel(configuration)

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

SiglipVisionConfig

transformers.SiglipVisionConfig

< >

( hidden_size = 768 intermediate_size = 3072 num_hidden_layers = 12 num_attention_heads = 12 num_channels = 3 image_size = 224 patch_size = 16 hidden_act = 'gelu_pytorch_tanh' layer_norm_eps = 1e-06 attention_dropout = 0.0 **kwargs )

参数

  • hidden_size (int, 可选, 默认为 768) — 编码器层和池化层的维度。
  • intermediate_size (int, 可选, 默认为 3072) — Transformer 编码器中“中间”(即前馈)层的维度。
  • num_hidden_layers (int, 可选, 默认为 12) — Transformer 编码器中隐藏层的数量。
  • num_attention_heads (int, 可选, 默认为 12) — Transformer 编码器中每个注意力层的注意力头的数量。
  • num_channels (int, 可选, 默认为 3) — 输入图像中的通道数。
  • patch_size (int可选,默认为 16) — 每个补丁的大小(分辨率)。
  • hidden_act (strfunction可选,默认为 "gelu_pytorch_tanh") — 编码器和池化器中的非线性激活函数(函数或字符串)。如果为字符串,则支持 "gelu""relu""selu""gelu_new" "quick_gelu"
  • layer_norm_eps (float可选,默认为 1e-06) — 层归一化层使用的 epsilon。
  • attention_dropout (float可选,默认为 0.0) — 注意力概率的 dropout 比率。

这是用于存储 SiglipVisionModel 配置的配置类。它用于根据指定的参数实例化 Siglip 视觉编码器,定义模型架构。使用默认值实例化配置将产生与 Siglip google/siglip-base-patch16-224 架构的视觉编码器的配置类似的配置。

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

示例

>>> from transformers import SiglipVisionConfig, SiglipVisionModel

>>> # Initializing a SiglipVisionConfig with google/siglip-base-patch16-224 style configuration
>>> configuration = SiglipVisionConfig()

>>> # Initializing a SiglipVisionModel (with random weights) from the google/siglip-base-patch16-224 style configuration
>>> model = SiglipVisionModel(configuration)

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

SiglipTokenizer

transformers.SiglipTokenizer

< >

( vocab_file eos_token = '</s>' unk_token = '<unk>' pad_token = '</s>' additional_special_tokens = None sp_model_kwargs: Optional = None model_max_length = 64 do_lower_case = True **kwargs )

参数

  • vocab_file (str) — 包含实例化分词器所需的词汇表的 SentencePiece 文件(通常具有 .spm 扩展名)。
  • eos_token (str可选,默认为 "</s>") — 序列结束标记。
  • unk_token (str可选,默认为 "<unk>") — 未知标记。不在词汇表中的标记无法转换为 ID,而是设置为此标记。
  • additional_special_tokens (List[str], 可选) — 分词器使用的额外特殊标记。
  • sp_model_kwargs (dict, 可选) — 将传递给 SentencePieceProcessor.__init__() 方法。 SentencePiece 的 Python 包装器 可用于设置以下内容:

    • enable_sampling: 启用子词正则化。

    • nbest_size: 一元模型的采样参数。对于 BPE-Dropout 无效。

      • nbest_size = {0,1}: 不执行采样。
      • nbest_size > 1: 从 nbest_size 个结果中采样。
      • nbest_size < 0: 假设 nbest_size 为无限大,并使用前向过滤和后向采样算法从所有假设(格)中采样。
    • alpha: 一元模型采样的平滑参数,以及 BPE-dropout 合并操作的 dropout 概率。

  • model_max_length (int, 可选, 默认为 64) — 模型输入的最大长度(以标记数表示)。
  • do_lower_case (bool, 可选, 默认为 True) — 在分词时是否将输入转换为小写。

构建 Siglip 分词器。基于 SentencePiece

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

build_inputs_with_special_tokens

< >

( token_ids_0: List token_ids_1: Optional = None ) List[int]

参数

  • token_ids_0 (List[int]) — 将添加特殊标记的 ID 列表。
  • token_ids_1 (List[int], 可选) — 序列对的可选第二个 ID 列表。

返回值

List[int]

包含相应特殊标记的 输入 ID 列表。

通过连接和添加特殊标记,从序列或一对序列构建用于序列分类任务的模型输入。序列具有以下格式

  • 单个序列: X </s>
  • 序列对: A </s> B </s>

get_special_tokens_mask

< >

( token_ids_0: List token_ids_1: Optional = None already_has_special_tokens: bool = False ) List[int]

参数

  • token_ids_0 (List[int]) — ID 列表。
  • already_has_special_tokens (bool可选,默认为 False) — 令牌列表是否已使用模型的特殊令牌进行格式化。

返回值

List[int]

一个范围在 [0, 1] 内的整数列表:1 代表特殊令牌,0 代表序列令牌。

从没有添加特殊令牌的令牌列表中检索序列 ID。当使用分词器 prepare_for_model 方法添加特殊令牌时,会调用此方法。

create_token_type_ids_from_sequences

< >

( token_ids_0: List token_ids_1: Optional = None ) List[int]

参数

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

返回值

List[int]

零列表。

为序列对分类任务创建从两个序列传递的掩码。T5 不使用令牌类型 ID,因此返回零列表。

save_vocabulary

< >

( save_directory: str filename_prefix: Optional = None )

SiglipImageProcessor

transformers.SiglipImageProcessor

< >

( do_resize: bool = True size: Dict = None resample: Resampling = <Resampling.BICUBIC: 3> 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 = None **kwargs )

参数

  • do_resize (bool可选,默认为 True) — 是否将图像的(高度,宽度)尺寸调整为指定的 size。可以在 preprocess 方法中通过 do_resize 覆盖。
  • size (Dict[str, int] 可选,默认为 {"height" -- 224, "width": 224}) — 调整大小后图像的大小。可以在 preprocess 方法中通过 size 覆盖。
  • 重采样 (PILImageResampling, 可选, 默认为 Resampling.BICUBIC) — 如果调整图像大小,则使用哪个重采样过滤器。可以在 preprocess 方法中通过 resample 覆盖。
  • 是否重新缩放 (bool, 可选, 默认为 True) — 是否根据指定的比例 rescale_factor 重新缩放图像。可以在 preprocess 方法中通过 do_rescale 覆盖。
  • 重新缩放因子 (intfloat, 可选, 默认为 1/255) — 如果重新缩放图像,则使用哪个缩放因子。可以在 preprocess 方法中通过 rescale_factor 覆盖。
  • 是否标准化 (bool, 可选, 默认为 True) — 是否根据指定的均值和标准差标准化图像。可以在 preprocess 方法中通过 do_normalize 覆盖。
  • 图像均值 (floatList[float], 可选, 默认为 [0.5, 0.5, 0.5]) — 如果标准化图像,则使用哪个均值。这是一个浮点数或浮点数列表,其长度与图像中通道的数量相同。可以在 preprocess 方法中的 image_mean 参数中覆盖。
  • 图像标准差 (floatList[float], 可选, 默认为 [0.5, 0.5, 0.5]) — 如果标准化图像,则使用哪个标准差。这是一个浮点数或浮点数列表,其长度与图像中通道的数量相同。可以在 preprocess 方法中的 image_std 参数中覆盖。可以在 preprocess 方法中的 image_std 参数中覆盖。
  • 是否转换为RGB (bool, 可选, 默认为 True) — 是否将图像转换为RGB。

构造一个SigLIP图像处理器。

预处理

< >

( 图像: Union 是否调整大小: bool = None 大小: Dict = None 重采样: Resampling = None 是否重新缩放: bool = None 重新缩放因子: float = None 是否标准化: bool = None 图像均值: Union = None 图像标准差: Union = None 返回张量: Union = None 数据格式: Optional = <ChannelDimension.FIRST: 'channels_first'> 输入数据格式: Union = None 是否转换为RGB: bool = None )

参数

  • 图像 (ImageInput) — 要预处理的图像。需要单个或一批像素值范围在 0 到 255 之间的图像。如果传递像素值在 0 到 1 之间的图像,请设置 do_rescale=False
  • do_resize (bool可选,默认为 self.do_resize) — 是否调整图像大小。
  • size (Dict[str, int]可选,默认为 self.size) — 调整大小后图像的大小。
  • resample (int可选,默认为 self.resample) — 如果调整图像大小,则使用重采样过滤器。这可以是枚举 PILImageResampling 中的一个。只有当 do_resize 设置为 True 时才有效。
  • do_rescale (bool可选,默认为 self.do_rescale) — 是否重新缩放图像。
  • rescale_factor (float可选,默认为 self.rescale_factor) — 如果 do_rescale 设置为 True,则用于重新缩放图像的缩放因子。
  • do_normalize (bool可选,默认为 self.do_normalize) — 是否标准化图像。
  • image_mean (floatList[float]可选,默认为 self.image_mean) — 用于标准化的图像均值。只有当 do_normalize 设置为 True 时才有效。
  • image_std (floatList[float]可选,默认为 self.image_std) — 用于标准化的图像标准差。只有当 do_normalize 设置为 True 时才有效。
  • return_tensors (strTensorType可选) — 要返回的张量类型。可以是以下之一:
    • 未设置:返回 np.ndarray 列表。
    • TensorType.TENSORFLOW'tf':返回类型为 tf.Tensor 的批次。
    • TensorType.PYTORCH'pt':返回类型为 torch.Tensor 的批次。
    • TensorType.NUMPY'np':返回类型为 np.ndarray 的批次。
    • TensorType.JAX'jax':返回类型为 jax.numpy.ndarray 的批次。
  • data_format (ChannelDimensionstr可选,默认为 ChannelDimension.FIRST) — 输出图像的通道维度格式。可以是以下之一:
    • "channels_first"ChannelDimension.FIRST:图像格式为 (num_channels, height, width)。
    • "channels_last"ChannelDimension.LAST:图像格式为 (height, width, num_channels)。
    • 未设置:使用输入图像的通道维度格式。
  • do_convert_rgb (bool, 可选, 默认为 self.do_convert_rgb) — 是否将图像转换为RGB。

预处理图像或图像批次。

SiglipProcessor

transformers.SiglipProcessor

< >

( image_processor tokenizer )

参数

构建一个Siglip处理器,它将Siglip图像处理器和Siglip分词器封装到单个处理器中。

SiglipProcessor 提供了 SiglipImageProcessorSiglipTokenizer 的所有功能。有关更多信息,请参阅 __call__()decode()

batch_decode

< >

( *args **kwargs )

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

decode

< >

( *args **kwargs )

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

SiglipModel

transformers.SiglipModel

< >

( config: SiglipConfig )

参数

  • 此模型也是 PyTorch torch.nn.Module 的子类。将其用作常规的 PyTorch 模块,并参考 PyTorch 文档以了解与一般用法和行为相关的所有事项。

    forward

    < >

    ( 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 interpolate_pos_encoding: bool = False ) transformers.models.siglip.modeling_siglip.SiglipOutputtuple(torch.FloatTensor)

    参数

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

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

      什么是输入 ID?

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

      • 1 表示未掩码的标记,
      • 0 表示掩码的标记。

      什么是注意力掩码?

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

      什么是位置 ID?

    • pixel_values (torch.FloatTensor 形状为 (batch_size, num_channels, height, width)) — 像素值。如果您提供填充,则默认情况下将忽略填充。可以使用 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.siglip.modeling_siglip.SiglipOutputtuple(torch.FloatTensor)

    一个 transformers.models.siglip.modeling_siglip.SiglipOutput 或一个 torch.FloatTensor 的元组(如果传递了 return_dict=False 或当 config.return_dict=False 时),包含根据配置(<class 'transformers.models.siglip.configuration_siglip.SiglipConfig'>)和输入而变化的各种元素。

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

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

    尽管前向传递的配方需要在此函数内定义,但此后应调用 Module 实例,而不是此函数,因为前者负责运行预处理和后处理步骤,而后者则静默地忽略它们。

    示例

    >>> from PIL import Image
    >>> import requests
    >>> from transformers import AutoProcessor, AutoModel
    >>> import torch
    
    >>> model = AutoModel.from_pretrained("google/siglip-base-patch16-224")
    >>> processor = AutoProcessor.from_pretrained("google/siglip-base-patch16-224")
    
    >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
    >>> image = Image.open(requests.get(url, stream=True).raw)
    
    >>> texts = ["a photo of 2 cats", "a photo of 2 dogs"]
    >>> # important: we pass `padding=max_length` since the model was trained with this
    >>> inputs = processor(text=texts, images=image, padding="max_length", return_tensors="pt")
    
    >>> with torch.no_grad():
    ...     outputs = model(**inputs)
    
    >>> logits_per_image = outputs.logits_per_image
    >>> probs = torch.sigmoid(logits_per_image) # these are the probabilities
    >>> print(f"{probs[0][0]:.1%} that image 0 is '{texts[0]}'")
    31.9% that image 0 is 'a photo of 2 cats'

    获取文本特征

    < >

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

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

      什么是输入 ID?

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

      • 1 表示未掩码的标记,
      • 0 表示掩码的标记。

      什么是注意力掩码?

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

      什么是位置 ID?

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

    返回值

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

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

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

    尽管前向传递的配方需要在此函数内定义,但此后应调用 Module 实例,而不是此函数,因为前者负责运行预处理和后处理步骤,而后者则静默地忽略它们。

    示例

    >>> from transformers import AutoTokenizer, AutoModel
    >>> import torch
    
    >>> model = AutoModel.from_pretrained("google/siglip-base-patch16-224")
    >>> tokenizer = AutoTokenizer.from_pretrained("google/siglip-base-patch16-224")
    
    >>> # important: make sure to set padding="max_length" as that's how the model was trained
    >>> inputs = tokenizer(["a photo of a cat", "a photo of a dog"], padding="max_length", return_tensors="pt")
    >>> with torch.no_grad():
    ...     text_features = model.get_text_features(**inputs)

    get_image_features

    < >

    ( pixel_values: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None interpolate_pos_encoding: bool = False ) image_features (形状为 (batch_size, output_dimtorch.FloatTensor)

    参数

    • pixel_values (形状为 (batch_size, num_channels, height, width)torch.FloatTensor) — 像素值。如果您提供填充,则默认情况下会忽略填充。可以使用 AutoImageProcessor 获取像素值。有关详细信息,请参阅 CLIPImageProcessor.call()
    • output_attentions (bool可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的 attentions
    • output_hidden_states (bool可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的 hidden_states
    • interpolate_pos_encoding (bool可选,默认为 False) — 是否插值预训练的位置编码。
    • return_dict (bool可选) — 是否返回 ModelOutput 而不是普通元组。

    返回值

    image_features (形状为 (batch_size, output_dimtorch.FloatTensor)

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

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

    尽管前向传递的配方需要在此函数内定义,但此后应调用 Module 实例,而不是此函数,因为前者负责运行预处理和后处理步骤,而后者则静默地忽略它们。

    示例

    >>> from PIL import Image
    >>> import requests
    >>> from transformers import AutoProcessor, AutoModel
    >>> import torch
    
    >>> model = AutoModel.from_pretrained("google/siglip-base-patch16-224")
    >>> processor = AutoProcessor.from_pretrained("google/siglip-base-patch16-224")
    
    >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
    >>> image = Image.open(requests.get(url, stream=True).raw)
    
    >>> inputs = processor(images=image, return_tensors="pt")
    
    >>> with torch.no_grad():
    ...     image_features = model.get_image_features(**inputs)

SiglipTextModel

transformers.SiglipTextModel

< >

( config: SiglipTextConfig )

参数

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

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

此模型也是 PyTorch torch.nn.Module 的子类。将其用作常规的 PyTorch 模块,并参考 PyTorch 文档以了解与一般用法和行为相关的所有事项。

forward

< >

( 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 ) transformers.modeling_outputs.BaseModelOutputWithPoolingtuple(torch.FloatTensor)

参数

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

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

    什么是输入 ID?

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

    • 1 表示未被掩码的标记,
    • 0 表示被掩码的标记。

    什么是注意力掩码?

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

    什么是位置 ID?

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

返回值

transformers.modeling_outputs.BaseModelOutputWithPoolingtuple(torch.FloatTensor)

一个 transformers.modeling_outputs.BaseModelOutputWithPooling 或一个 torch.FloatTensor 元组(如果传递了 return_dict=Falseconfig.return_dict=False),包含根据配置(<class 'transformers.models.siglip.configuration_siglip.SiglipTextConfig'>)和输入而变化的各种元素。

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

  • pooler_output (torch.FloatTensor 形状为 (batch_size, hidden_size)) — 序列第一个标记(分类标记)在经过用于辅助预训练任务的层进一步处理后的最后一层隐藏状态。例如,对于 BERT 系列模型,这会返回经过线性层和 tanh 激活函数处理后的分类标记。在预训练期间,线性层权重是从下一个句子预测(分类)目标训练得到的。

  • hidden_states (tuple(torch.FloatTensor)可选,当传递 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — torch.FloatTensor 元组(一个用于嵌入的输出,如果模型具有嵌入层,以及一个用于每一层的输出)形状为 (batch_size, sequence_length, hidden_size)

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

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

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

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

尽管前向传递的配方需要在此函数内定义,但此后应调用 Module 实例,而不是此函数,因为前者负责运行预处理和后处理步骤,而后者则静默地忽略它们。

示例

>>> from transformers import AutoTokenizer, SiglipTextModel

>>> model = SiglipTextModel.from_pretrained("google/siglip-base-patch16-224")
>>> tokenizer = AutoTokenizer.from_pretrained("google/siglip-base-patch16-224")

>>> # important: make sure to set padding="max_length" as that's how the model was trained
>>> inputs = tokenizer(["a photo of a cat", "a photo of a dog"], padding="max_length", return_tensors="pt")

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

SiglipVisionModel

transformers.SiglipVisionModel

< >

( config: SiglipVisionConfig )

参数

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

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

此模型也是 PyTorch torch.nn.Module 的子类。将其用作常规的 PyTorch 模块,并参考 PyTorch 文档以了解与一般用法和行为相关的所有事项。

forward

< >

( pixel_values output_attentions: 可选 = None output_hidden_states: 可选 = None return_dict: 可选 = None interpolate_pos_encoding: bool = False ) transformers.modeling_outputs.BaseModelOutputWithPoolingtuple(torch.FloatTensor)

参数

  • pixel_values (torch.FloatTensor 形状为 (batch_size, num_channels, height, width)) — 像素值。如果您提供填充,则默认情况下将忽略填充。可以使用 AutoImageProcessor 获取像素值。有关详细信息,请参阅 CLIPImageProcessor.call()
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量中的 attentions
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量中的 hidden_states
  • interpolate_pos_encoding (bool, 可选,默认为 False) — 是否插值预训练的位置编码。
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。

返回值

transformers.modeling_outputs.BaseModelOutputWithPoolingtuple(torch.FloatTensor)

一个 transformers.modeling_outputs.BaseModelOutputWithPoolingtorch.FloatTensor 的元组(如果传递了 return_dict=False 或当 config.return_dict=False 时),包含取决于配置(<class 'transformers.models.siglip.configuration_siglip.SiglipVisionConfig'>)和输入的各种元素。

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

  • pooler_output (torch.FloatTensor 形状为 (batch_size, hidden_size)) — 序列第一个标记(分类标记)在经过用于辅助预训练任务的层进一步处理后的最后一层隐藏状态。例如,对于 BERT 系列模型,这会返回经过线性层和 tanh 激活函数处理后的分类标记。在预训练期间,线性层权重是从下一个句子预测(分类)目标训练得到的。

  • hidden_states (tuple(torch.FloatTensor)可选,当传递 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — torch.FloatTensor 元组(一个用于嵌入的输出,如果模型具有嵌入层,以及一个用于每一层的输出)形状为 (batch_size, sequence_length, hidden_size)

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

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

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

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

尽管前向传递的配方需要在此函数内定义,但此后应调用 Module 实例,而不是此函数,因为前者负责运行预处理和后处理步骤,而后者则静默地忽略它们。

示例

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

>>> model = SiglipVisionModel.from_pretrained("google/siglip-base-patch16-224")
>>> processor = AutoProcessor.from_pretrained("google/siglip-base-patch16-224")

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

SiglipForImageClassification

transformers.SiglipForImageClassification

< >

( config: SiglipConfig )

参数

  • 配置 (SiglipConfig) — 模型配置类,包含模型的所有参数。使用配置文件初始化不会加载与模型关联的权重,仅加载配置。查看 from_pretrained() 方法以加载模型权重。

SigLIP 视觉编码器,在其顶部添加了一个图像分类头(补丁标记池化最终隐藏状态顶部的线性层),例如用于 ImageNet。

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

此模型也是 PyTorch torch.nn.Module 的子类。将其用作常规的 PyTorch 模块,并参考 PyTorch 文档以了解与一般用法和行为相关的所有事项。

forward

< >

( pixel_values: 可选 = None labels: 可选 = None output_attentions: 可选 = None output_hidden_states: 可选 = None return_dict: 可选 = None interpolate_pos_encoding: bool = False ) transformers.modeling_outputs.ImageClassifierOutputtuple(torch.FloatTensor)

参数

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

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

    什么是输入 ID?

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

    • 1 表示未掩盖的标记,
    • 0 表示掩盖的标记。

    什么是注意力掩码?

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

    什么是位置 ID?

  • pixel_values (torch.FloatTensor 形状为 (batch_size, num_channels, height, width)) — 像素值。如果您提供填充,则默认情况下会忽略填充。可以使用 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 而不是普通元组。
  • labels (torch.LongTensor 形状为 (batch_size,), 可选) — 用于计算图像分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1] 中。如果 config.num_labels == 1,则计算回归损失(均方误差损失),如果 config.num_labels > 1,则计算分类损失(交叉熵)。

返回值

transformers.modeling_outputs.ImageClassifierOutputtuple(torch.FloatTensor)

transformers.modeling_outputs.ImageClassifierOutputtorch.FloatTensor 的元组(如果传递了 return_dict=False 或当 config.return_dict=False 时),包含取决于配置 (SiglipConfig) 和输入的各种元素。

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

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

尽管前向传递的配方需要在此函数内定义,但此后应调用 Module 实例,而不是此函数,因为前者负责运行预处理和后处理步骤,而后者则静默地忽略它们。

示例

>>> from transformers import AutoImageProcessor, SiglipForImageClassification
>>> import torch
>>> from PIL import Image
>>> import requests

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

>>> # note: we are loading a `SiglipModel` from the hub here,
>>> # so the head will be randomly initialized, hence the predictions will be random if seed is not set above.
>>> image_processor = AutoImageProcessor.from_pretrained("google/siglip-base-patch16-224")
>>> model = SiglipForImageClassification.from_pretrained("google/siglip-base-patch16-224")

>>> inputs = image_processor(images=image, return_tensors="pt")
>>> outputs = model(**inputs)
>>> logits = outputs.logits
>>> # model predicts one of the two classes
>>> predicted_class_idx = logits.argmax(-1).item()
>>> print("Predicted class:", model.config.id2label[predicted_class_idx])
Predicted class: LABEL_1
< > 在 GitHub 上更新