SigLIP

SigLIP 是一个多模态图像-文本模型，类似于 CLIP。它使用独立的图像和文本编码器来生成两种模态的表示。

与 CLIP 不同，SigLIP 在训练期间对图像-文本对使用成对 sigmoid 损失。这种训练损失消除了对批处理中图像和文本之间所有成对相似性的全局视图的需求。因此，它能够更有效地扩展到更大的批量大小，同时在更小的批量大小下也能提供卓越的性能。

您可以在 SigLIP 集合中找到所有原始 SigLIP 检查点。

单击右侧边栏中的 SigLIP 模型，查看更多将 SigLIP 应用于不同图像和文本任务的示例。

以下示例演示了如何使用 Pipeline 或 AutoModel 类生成文本与图像之间的相似度分数。

流水线

自动模型

量化通过以较低精度表示权重来减少大型模型的内存负担。有关更多可用量化后端，请参阅量化概述。

以下示例使用 bitsandbytes 将权重仅量化为 int4。

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

bnb_config = BitsAndBytesConfig(load_in_4bit=True)
model = AutoModel.from_pretrained("google/siglip-base-patch16-224", quantization_config=bnb_config, device_map="auto", attn_implementation="sdpa")
processor = AutoProcessor.from_pretrained("google/siglip-base-patch16-224")

url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"
image = Image.open(requests.get(url, stream=True).raw)
candidate_labels = ["a Pallas cat", "a lion", "a Siberian tiger"]
texts = [f'This is a photo of {label}.' for label in candidate_labels]
inputs = processor(text=texts, images=image, padding="max_length", return_tensors="pt").to("cuda")

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

logits_per_image = outputs.logits_per_image
probs = torch.sigmoid(logits_per_image)
print(f"{probs[0][0]:.1%} that image 0 is '{candidate_labels[0]}'")

注意事项

支持单节点多 GPU 设置上的 DDP 和 FSDP 训练。但是，它不使用 torch.distributed 工具，这可能会限制批量大小的可扩展性。
使用独立的 SiglipTokenizer 或 SiglipProcessor 时，请务必传入 padding="max_length"，因为这是模型训练时的方式。
为了获得与 Pipeline 相同的结果，应将提示模板 "This is a photo of {label}." 传递给处理器。

切换 attn_implementation 参数为 "sdpa" 或 "flash_attention_2" 以使用更节省内存的注意力。

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

from transformers import SiglipModel

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

SiglipConfig

class 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

class 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 projection_size = None **kwargs )

参数

vocab_size (int, 可选, 默认为 32000) — Siglip 文本模型的词汇表大小。定义了调用 SiglipModel 时传递的 inputs_ids 可以表示的不同 token 的数量。
hidden_size (int, 可选, 默认为 768) — 编码器层和池化层维度。
intermediate_size (int, 可选, 默认为 3072) — Transformer 编码器中“中间”（即前馈）层的维度。
num_hidden_layers (int, 可选, 默认为 12) — Transformer 编码器中的隐藏层数量。
num_attention_heads (int, 可选, 默认为 12) — Transformer 编码器中每个注意力层的注意力头数量。
max_position_embeddings (int, 可选, 默认为 64) — 此模型可能使用的最大序列长度。通常设置为一个较大的值以防万一（例如 512、1024 或 2048）。
hidden_act (str 或 function, 可选, 默认为 "gelu_pytorch_tanh") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持 "gelu"、"relu"、"selu" 和 "gelu_new" "quick_gelu"。
layer_norm_eps (float, 可选, 默认为 1e-06) — 层归一化层使用的 epsilon 值。
attention_dropout (float, 可选, 默认为 0.0) — 注意力概率的 dropout 比率。
pad_token_id (int, 可选, 默认为 1) — 词汇表中的填充 token ID。
bos_token_id (int, 可选, 默认为 49406) — 词汇表中的序列开始 token ID。
eos_token_id (int, 可选, 默认为 49407) — 词汇表中的序列结束 token ID。
projection_size (int, 可选, 默认为 hidden_size) — 投影头的尺寸。

这是用于存储 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

class 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) — 输入图像中的通道数量。
image_size (int, 可选, 默认为 224) — 每张图像的大小（分辨率）。
patch_size (int, 可选, 默认为 16) — 每个补丁的大小（分辨率）。
hidden_act (str 或 function, 可选, 默认为 "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

class transformers.SiglipTokenizer

< 来源 >

( vocab_file eos_token = '</s>' unk_token = '<unk>' pad_token = '</s>' additional_special_tokens = None sp_model_kwargs: typing.Optional[dict[str, typing.Any]] = None model_max_length = 64 do_lower_case = True **kwargs )

参数

vocab_file (str) — SentencePiece 文件（通常具有 _*.spm_ 扩展名），其中包含实例化分词器所需的词汇表。
eos_token (str, 可选, 默认为 "</s>") — 序列结束符。
unk_token (str, 可选, 默认为 "<unk>") — 未知标记。不在词汇表中的标记不能转换为 ID，而是设置为此标记。
pad_token (str, 可选, 默认为 "</s>") — 用于填充的标记，例如在对不同长度的序列进行批处理时。
additional_special_tokens (list[str], 可选) — 分词器使用的额外特殊标记。
sp_model_kwargs (dict, 可选) — 将传递给 SentencePieceProcessor.__init__() 方法。 SentencePiece 的 Python 封装器可以用于设置，其中包括：
- enable_sampling: 启用子词正则化。
- nbest_size: Unigram 的采样参数。对于 BPE-Dropout 无效。
  - nbest_size = {0,1}: 不执行采样。
  - nbest_size > 1: 从 nbest_size 结果中采样。
  - nbest_size < 0: 假设 nbest_size 是无限的，并使用前向滤波和后向采样算法从所有假设（格）中采样。
- alpha: 用于 unigram 采样的平滑参数，以及 BPE-dropout 中合并操作的 dropout 概率。
model_max_length (int, 可选, 默认为 64) — 模型输入的tokens最大长度。
do_lower_case (bool, 可选, 默认为 True) — 分词时是否将输入转为小写。

构造 Siglip 分词器。基于 SentencePiece。

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

build_inputs_with_special_tokens

< 来源 >

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

参数

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

list[int]

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

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

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

get_special_tokens_mask

< 来源 >

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

参数

token_ids_0 (list[int]) — ID 列表。
token_ids_1 (list[int], 可选) — 序列对的第二个 ID 列表（可选）。
already_has_special_tokens (bool, 可选, 默认为 False) — 标记列表是否已使用模型的特殊标记进行格式化。

list[int]

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

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

create_token_type_ids_from_sequences

< 来源 >

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

参数

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

list[int]

零列表。

根据传入的两个序列创建掩码，用于序列对分类任务。T5 不使用令牌类型 ID，因此返回零列表。

save_vocabulary

< 来源 >

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

SiglipImageProcessor

class transformers.SiglipImageProcessor

< 来源 >

( do_resize: bool = True size: typing.Optional[dict[str, int]] = None resample: Resampling = <Resampling.BICUBIC: 3> do_rescale: bool = True rescale_factor: typing.Union[int, float] = 0.00392156862745098 do_normalize: bool = True image_mean: typing.Union[float, list[float], NoneType] = None image_std: typing.Union[float, list[float], NoneType] = None do_convert_rgb: typing.Optional[bool] = None **kwargs )

参数

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

构造 SigLIP 图像处理器。

preprocess

< 来源 >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']] do_resize: typing.Optional[bool] = None size: typing.Optional[dict[str, int]] = None resample: Resampling = None do_rescale: typing.Optional[bool] = None rescale_factor: typing.Optional[float] = None do_normalize: typing.Optional[bool] = None image_mean: typing.Union[float, list[float], NoneType] = None image_std: typing.Union[float, list[float], NoneType] = None return_tensors: typing.Union[transformers.utils.generic.TensorType, str, NoneType] = None data_format: typing.Optional[transformers.image_utils.ChannelDimension] = <ChannelDimension.FIRST: 'channels_first'> input_data_format: typing.Union[str, transformers.image_utils.ChannelDimension, NoneType] = None do_convert_rgb: typing.Optional[bool] = None )

参数

images (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 (float 或 list[float], 可选, 默认为 self.image_mean) — 用于归一化的图像均值。仅在 do_normalize 设置为 True 时有效。
image_std (float 或 list[float], 可选, 默认为 self.image_std) — 用于归一化的图像标准差。仅在 do_normalize 设置为 True 时有效。
return_tensors (str 或 TensorType, 可选) — 返回张量的类型。可以是以下之一：
- 未设置：返回 np.ndarray 列表。
- TensorType.TENSORFLOW 或 'tf': 返回 tf.Tensor 类型的批次。
- TensorType.PYTORCH 或 'pt': 返回 torch.Tensor 类型的批次。
- TensorType.NUMPY 或 'np': 返回 np.ndarray 类型的批次。
- TensorType.JAX 或 'jax': 返回 jax.numpy.ndarray 类型的批次。
data_format (ChannelDimension 或 str, 可选, 默认为 ChannelDimension.FIRST) — 输出图像的通道维度格式。可以是以下之一：
- "channels_first" 或 ChannelDimension.FIRST: 图像为 (通道数, 高度, 宽度) 格式。
- "channels_last" 或 ChannelDimension.LAST: 图像为 (高度, 宽度, 通道数) 格式。
- 未设置：使用输入图像的通道维度格式。
input_data_format (ChannelDimension 或 str, 可选) — 输入图像的通道维度格式。如果未设置，则从输入图像推断通道维度格式。可以是以下之一：
- "channels_first" 或 ChannelDimension.FIRST: 图像为 (通道数, 高度, 宽度) 格式。
- "channels_last" 或 ChannelDimension.LAST: 图像为 (高度, 宽度, 通道数) 格式。
- "none" 或 ChannelDimension.NONE: 图像为 (高度, 宽度) 格式。
do_convert_rgb (bool, 可选, 默认为 self.do_convert_rgb) — 是否将图像转换为 RGB。

预处理一张或一批图像。

SiglipImageProcessorFast

class transformers.SiglipImageProcessorFast

< 来源 >

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

构造一个快速 Siglip 图像处理器。

preprocess

< 来源 >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']] *args **kwargs: typing_extensions.Unpack[transformers.image_processing_utils_fast.DefaultFastImageProcessorKwargs] ) → <class 'transformers.image_processing_base.BatchFeature'>

参数

images (Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]) — 要预处理的图像。期望单个或批次图像，像素值范围为 0 到 255。如果传入的图像像素值在 0 到 1 之间，请设置 do_rescale=False。
do_resize (bool, 可选) — 是否调整图像大小。
size (dict[str, int], 可选) — 模型的最大输入尺寸。
default_to_square (bool, 可选) — 调整大小后，如果大小为整数，是否默认为正方形图像。
resample (Union[PILImageResampling, F.InterpolationMode, NoneType]) — 如果调整图像大小，则使用的重采样滤波器。可以是枚举 PILImageResampling 之一。仅在 do_resize 设置为 True 时有效。
do_center_crop (bool, 可选) — 是否对图像进行中心裁剪。
crop_size (dict[str, int], optional) — 应用 center_crop 后输出图像的大小。
do_rescale (bool, optional) — 是否对图像进行缩放。
rescale_factor (Union[int, float, NoneType]) — 如果 do_rescale 设置为 True，则图像的缩放因子。
do_normalize (bool, optional) — 是否对图像进行标准化。
image_mean (Union[float, list[float], NoneType]) — 用于标准化的图像平均值。仅当 do_normalize 设置为 True 时生效。
image_std (Union[float, list[float], NoneType]) — 用于标准化的图像标准差。仅当 do_normalize 设置为 True 时生效。
do_convert_rgb (bool, optional) — 是否将图像转换为 RGB 格式。
return_tensors (Union[str, ~utils.generic.TensorType, NoneType]) — 如果设置为 `pt`，则返回堆叠的张量，否则返回张量列表。
data_format (~image_utils.ChannelDimension, optional) — 仅支持 ChannelDimension.FIRST。为与慢速处理器兼容而添加。
input_data_format (Union[str, ~image_utils.ChannelDimension, NoneType]) — 输入图像的通道维度格式。如果未设置，则从输入图像推断通道维度格式。可以是以下之一：
- "channels_first" 或 ChannelDimension.FIRST：图像格式为 (num_channels, height, width)。
- "channels_last" 或 ChannelDimension.LAST：图像格式为 (height, width, num_channels)。
- "none" 或 ChannelDimension.NONE：图像格式为 (height, width)。
device (torch.device, optional) — 处理图像的设备。如果未设置，则从输入图像推断设备。
disable_grouping (bool, optional) — 是否禁用按大小对图像进行分组以单独处理而不是批量处理。如果为 None，则如果图像位于 CPU 上则设置为 True，否则设置为 False。此选择基于经验观察，详细信息请参见此处：https://github.com/huggingface/transformers/pull/38157

<class 'transformers.image_processing_base.BatchFeature'>

data (dict) — 由 call 方法返回的列表/数组/张量字典（“pixel_values”等）。
tensor_type (Union[None, str, TensorType], 可选) — 您可以在此处提供一个`tensor_type`，以便在初始化时将整数列表转换为PyTorch/TensorFlow/Numpy张量。

SiglipProcessor

class transformers.SiglipProcessor

< source >

( image_processor tokenizer )

参数

image_processor (SiglipImageProcessor) — 图像处理器是必需输入。
tokenizer (SiglipTokenizer) — 分词器是必需输入。

构造一个 Siglip 处理器，它将 Siglip 图像处理器和 Siglip 分词器封装到一个单独的处理器中。

SiglipProcessor 提供了 SiglipImageProcessor 和 SiglipTokenizer 的所有功能。有关更多信息，请参阅 __call__() 和 decode()。

batch_decode

< source >

( *args **kwargs )

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

decode

< source >

( *args **kwargs )

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

SiglipModel

class transformers.SiglipModel

< source >

( config: SiglipConfig )

参数

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

裸 Siglip 模型，输出原始隐藏状态，顶部没有任何特定头部。

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

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

forward

< source >

( input_ids: typing.Optional[torch.LongTensor] = None pixel_values: typing.Optional[torch.FloatTensor] = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.LongTensor] = None return_loss: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None interpolate_pos_encoding: bool = False ) → transformers.models.siglip.modeling_siglip.SiglipOutput or tuple(torch.FloatTensor)

参数

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

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

什么是输入 ID？
pixel_values (torch.FloatTensor，形状为 (batch_size, num_channels, image_size, image_size)，可选) — 对应于输入图像的张量。像素值可以使用 {image_processor_class} 获取。有关详细信息，请参阅 {image_processor_class}.__call__（{processor_class} 使用 {image_processor_class} 处理图像）。
attention_mask (torch.Tensor，形状为 (batch_size, sequence_length)，可选) — 避免对填充 token 索引执行注意力操作的掩码。掩码值选择在 [0, 1] 之间：
- 1 表示 未被掩盖 的 token，
- 0 表示 被掩盖 的 token。
什么是注意力掩码？
position_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 每个输入序列 token 在位置嵌入中的位置索引。选择范围为 [0, config.n_positions - 1]。

什么是位置 ID？
return_loss (bool, optional) — 是否返回对比损失。
output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的 attentions。
output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的 hidden_states。
interpolate_pos_encoding (bool, 默认为 False) — 是否插值预训练位置编码。

transformers.models.siglip.modeling_siglip.SiglipOutput 或 tuple(torch.FloatTensor)

一个 transformers.models.siglip.modeling_siglip.SiglipOutput 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），其中包含取决于配置 (SiglipConfig) 和输入的不同元素。

loss (torch.FloatTensor，形状为 (1,), 可选, 当 return_loss 为 True 时返回) — 图像-文本相似度的对比损失。
logits_per_image (torch.FloatTensor，形状为 (image_batch_size, text_batch_size)) — image_embeds 和 text_embeds 之间的缩放点积分数。这表示图像-文本相似度分数。
logits_per_text (torch.FloatTensor，形状为 (text_batch_size, image_batch_size)) — text_embeds 和 image_embeds 之间的缩放点积分数。这表示文本-图像相似度分数。
text_embeds (torch.FloatTensor，形状为 (batch_size, output_dim) — 通过将投影层应用于 SiglipTextModel 的池化输出而获得的文本嵌入。
image_embeds (torch.FloatTensor，形状为 (batch_size, output_dim) — 通过将投影层应用于 SiglipVisionModel 的池化输出而获得的图像嵌入。
text_model_output (<class '~modeling_outputs.BaseModelOutputWithPooling'>.text_model_output，默认为 None) — SiglipTextModel 的输出。
vision_model_output (<class '~modeling_outputs.BaseModelOutputWithPooling'>.vision_model_output，默认为 None) — 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'

get_text_features

< source >

( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None ) → text_features (torch.FloatTensor，形状为 (batch_size, output_dim)

参数

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

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

什么是输入 ID？
attention_mask (torch.Tensor，形状为 (batch_size, sequence_length)，可选) — 避免对填充 token 索引执行注意力操作的掩码。掩码值选择在 [0, 1] 之间：
- 1 表示 未被掩盖 的 token，
- 0 表示 被掩盖 的 token。
什么是注意力掩码？
position_ids (torch.Tensor，形状为 (batch_size, sequence_length)，可选) — 每个输入序列 token 在位置嵌入中的位置索引。选择范围为 [0, config.n_positions - 1]。

什么是位置 ID？
output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的 attentions。
output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的 hidden_states。

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

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

示例

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

< source >

( pixel_values: typing.Optional[torch.FloatTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None interpolate_pos_encoding: bool = False ) → image_features (torch.FloatTensor，形状为 (batch_size, output_dim)

参数

pixel_values (torch.FloatTensor，形状为 (batch_size, num_channels, image_size, image_size)，可选) — 对应于输入图像的张量。像素值可以使用 {image_processor_class} 获取。有关详细信息，请参阅 {image_processor_class}.__call__（{processor_class} 使用 {image_processor_class} 处理图像）。
output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的 attentions。
output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的 hidden_states。
interpolate_pos_encoding (bool, 默认为 False) — 是否插值预训练位置编码。

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

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

示例

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

class transformers.SiglipTextModel

< source >

( config: SiglipTextConfig )

参数

config (SiglipTextConfig) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。请查阅 from_pretrained() 方法以加载模型权重。

不带任何头部或投影的 SigLIP 文本模型。

此模型继承自 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 ) → transformers.modeling_outputs.BaseModelOutputWithPooling 或 tuple(torch.FloatTensor)

参数

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

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

什么是输入 ID？
attention_mask (torch.Tensor，形状为 (batch_size, sequence_length)，可选) — 避免对填充 token 索引执行注意力操作的掩码。掩码值选择在 [0, 1] 之间：
- 1 表示 未被掩盖 的 token，
- 0 表示 被掩盖 的 token。
什么是注意力掩码？
position_ids (torch.Tensor, 形状为 (batch_size, sequence_length), 可选) — 每个输入序列词元在位置嵌入中的位置索引。选择范围为 [0, config.n_positions - 1]。

什么是位置 ID？
output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。更多详情请参见返回张量中的 attentions。
output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。更多详情请参见返回张量中的 hidden_states。

transformers.modeling_outputs.BaseModelOutputWithPooling 或 tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.BaseModelOutputWithPooling 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或 config.return_dict=False），包含根据配置（SiglipConfig）和输入而定的各种元素。

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

SiglipTextModel 的 forward 方法，重写了 __call__ 特殊方法。

示例

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

class transformers.SiglipVisionModel

< source >

( config: SiglipVisionConfig )

参数

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

SigLIP 的视觉模型，没有任何头部或投影层。

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

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

forward

< source >

( pixel_values output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None interpolate_pos_encoding: bool = False ) → transformers.modeling_outputs.BaseModelOutputWithPooling 或 tuple(torch.FloatTensor)

参数

pixel_values (`形状为 `(batch_size, num_channels, image_size, image_size)` 的张量) -- 对应于输入图像的张量。像素值可以使用 `{image_processor_class}` 获得。有关详细信息，请参阅 `{image_processor_class}.__call__` （`{processor_class}` 使用 `{image_processor_class}` 进行图像处理）。
output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。更多详情请参见返回张量中的 attentions。
output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。更多详情请参见返回张量中的 hidden_states。
interpolate_pos_encoding (bool, 默认为 False) — 是否对预训练的位置编码进行插值。

transformers.modeling_outputs.BaseModelOutputWithPooling 或 tuple(torch.FloatTensor)

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

SiglipVisionModel 的 forward 方法，重写了 __call__ 特殊方法。

示例

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

class transformers.SiglipForImageClassification

< source >

( config: SiglipConfig )

参数

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

SigLIP 视觉编码器，顶部带有图像分类头（对补丁词元的池化最终隐藏状态进行线性层处理），例如用于 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 interpolate_pos_encoding: bool = False ) → transformers.modeling_outputs.ImageClassifierOutput 或 tuple(torch.FloatTensor)

参数

pixel_values (torch.Tensor 形状为 (batch_size, num_channels, image_size, image_size), 可选) — 对应于输入图像的张量。像素值可以使用 {image_processor_class} 获得。有关详细信息，请参阅 {image_processor_class}.__call__ （{processor_class} 使用 {image_processor_class} 进行图像处理）。
labels (torch.LongTensor 形状为 (batch_size,), 可选) — 用于计算图像分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1] 范围内。如果 config.num_labels == 1，则计算回归损失（均方损失），如果 config.num_labels > 1，则计算分类损失（交叉熵）。
output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。更多详情请参见返回张量中的 attentions。
output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。更多详情请参见返回张量中的 hidden_states。
interpolate_pos_encoding (bool, 默认为 False) — 是否对预训练的位置编码进行插值。

transformers.modeling_outputs.ImageClassifierOutput 或 tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.ImageClassifierOutput 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或 config.return_dict=False），包含根据配置（SiglipConfig）和输入而定的各种元素。

loss (形状为 (1,) 的 torch.FloatTensor，可选，当提供 labels 时返回) — 分类损失（如果 config.num_labels==1，则为回归损失）。
logits (形状为 (batch_size, config.num_labels) 的 torch.FloatTensor) — 分类（如果 config.num_labels==1，则为回归）分数（SoftMax 之前）。
hidden_states (tuple(torch.FloatTensor), 可选, 当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — torch.FloatTensor 元组（如果模型有嵌入层，则包含一个用于嵌入层输出的张量，加上一个用于每个阶段输出的张量），形状为 (batch_size, sequence_length, hidden_size)。模型在每个阶段输出的隐藏状态（也称为特征图）。
attentions (tuple(torch.FloatTensor), 可选, 当传递 output_attentions=True 或 config.output_attentions=True 时返回) — torch.FloatTensor 元组（每个层一个），形状为 (batch_size, num_heads, patch_size, sequence_length)。

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

SiglipForImageClassification 的 forward 方法，重写了 __call__ 特殊方法。

示例

>>> 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 上更新

Transformers

SigLIP

注意事项

SiglipConfig

class transformers.SiglipConfig

from_text_vision_configs

SiglipTextConfig

class transformers.SiglipTextConfig

SiglipVisionConfig

class transformers.SiglipVisionConfig

SiglipTokenizer

class transformers.SiglipTokenizer

build_inputs_with_special_tokens

get_special_tokens_mask

create_token_type_ids_from_sequences

save_vocabulary

SiglipImageProcessor

class transformers.SiglipImageProcessor

preprocess

SiglipImageProcessorFast

class transformers.SiglipImageProcessorFast

preprocess

SiglipProcessor

class transformers.SiglipProcessor

batch_decode

decode

SiglipModel

class transformers.SiglipModel

forward

get_text_features

get_image_features

SiglipTextModel

class transformers.SiglipTextModel

forward

SiglipVisionModel

class transformers.SiglipVisionModel

forward

SiglipForImageClassification

class transformers.SiglipForImageClassification

forward