Transformers 文档

SigLIP2

Hugging Face's logo
加入 Hugging Face 社区

并获得增强的文档体验

开始使用

PyTorch FlashAttention SDPA

SigLIP2

概述

SigLIP2 是一系列基于 SigLIP 训练方法的、多语言的视觉-语言编码器。它包括基于解码器的预训练、自蒸馏和掩码预测,以改进密集预测任务(如分割、深度估计等)。该模型提供两种变体:

  • NaFlex 支持不同的分辨率并保持原始图像宽高比
  • FixRes 支持固定分辨率并与 SigLIP 向后兼容

所有原始 SigLIP2 检查点均可在 SigLIP2 集合中找到。

点击右侧边栏的 SigLIP2 模型,可查看如何将 SigLIP2 应用于不同图像和文本任务的更多示例。

以下示例展示了使用 PipelineAutoModel 类进行零样本分类。

流水线
AutoModel (FixRes)
AutoModel (NaFlex)
import torch
from transformers import pipeline

image = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"
candidate_labels = ["a Pallas cat", "a lion", "a Siberian tiger"]

pipeline = pipeline(task="zero-shot-image-classification", model="google/siglip2-base-patch16-224", device=0, torch_dtype=torch.bfloat16)
pipeline(image, candidate_labels=candidate_labels)

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

以下示例使用 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/siglip2-large-patch16-512", quantization_config=bnb_config, device_map="auto", attn_implementation="sdpa")
processor = AutoProcessor.from_pretrained("google/siglip2-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"]

# follows the pipeline prompt template to get same results
texts = [f'This is a photo of {label}.' for label in candidate_labels]

# IMPORTANT: we pass `padding=max_length` and `max_length=64` since the model was trained with this
inputs = processor(text=texts, images=image, padding="max_length", max_length=64, 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 工具,这可能会限制批处理大小的可扩展性。

  • 使用独立的 GemmaTokenizerFast 时,请确保传入 padding="max_length"max_length=64,因为模型就是这样训练的。

  • 模型是使用小写文本训练的,因此请确保您的文本标签以相同的方式进行预处理。

  • 要获得与 Pipeline 相同的结果,应将提示模板 "This is a photo of {label}." 传递给处理器。

  • NaFlex 变体以适当的分辨率处理不同类型的图像(例如,使用更大的分辨率处理文档图像),同时最大限度地减少某些推理任务(如 OCR)中的宽高比失真影响。

    NaFlex 会调整输入图像的大小,使其高度和宽度在调整大小后是补丁大小的倍数。它尽可能保持宽高比失真低,并生成最多达到所需目标序列长度(max_num_patches)的序列长度。调整大小后,图像将分成一系列补丁,并添加带有填充信息的掩码。

  • attn_implementation 参数切换为 "sdpa""flash_attention_2" 以使用内存效率更高的注意力机制。

    # pip install -U flash-attn --no-build-isolation
    
    from transformers import SiglipModel
    
    model = SiglipModel.from_pretrained(
        "google/siglip2-so400m-patch14-384",
        attn_implementation="flash_attention_2",
        torch_dtype=torch.float16,
        device_map=device,
    )

Siglip2Config

class transformers.Siglip2Config

< >

( text_config = None vision_config = None **kwargs )

参数

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

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

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

示例

>>> from transformers import Siglip2Config, Siglip2Model

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

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

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

>>> # We can also initialize a Siglip2Config from a Siglip2TextConfig and a Siglip2VisionConfig
>>> from transformers import Siglip2TextConfig, Siglip2VisionConfig

>>> # Initializing a Siglip2Text and Siglip2Vision configuration
>>> config_text = Siglip2TextConfig()
>>> config_vision = Siglip2VisionConfig()

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

from_text_vision_configs

< >

( text_config: Siglip2TextConfig vision_config: Siglip2VisionConfig **kwargs ) Siglip2Config

返回

Siglip2Config

一个配置对象的实例

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

Siglip2TextConfig

class transformers.Siglip2TextConfig

< >

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

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

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

示例

>>> from transformers import Siglip2TextConfig, Siglip2TextModel

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

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

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

Siglip2VisionConfig

class transformers.Siglip2VisionConfig

< >

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

参数

  • hidden_size (int, optional, defaults to 768) — 编码器层和池化层的维度。
  • intermediate_size (int, optional, defaults to 3072) — Transformer 编码器中“中间”(即前馈)层的维度。
  • 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) — 输入图像中的通道数量。
  • num_patches (int, optional, defaults to 256) — 图像中补丁的数量,大小为(patch_size, patch_size)。图像将被调整大小以填充最大数量的补丁,并保持宽高比。如果结果补丁数量较少,则图像将在“补丁”维度上进行填充。
  • patch_size (int, optional, defaults to 16) — 每个补丁的大小(分辨率)。
  • hidden_act (str or function, optional, defaults to "gelu_pytorch_tanh") — 编码器和池化器中的非线性激活函数(函数或字符串)。如果为字符串,则支持 "gelu""relu""selu""gelu_new" "quick_gelu"
  • layer_norm_eps (float, optional, defaults to 1e-06) — 层归一化层使用的 epsilon 值。
  • attention_dropout (float, optional, defaults to 0.0) — 注意力概率的 dropout 比率。

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

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

示例

>>> from transformers import Siglip2VisionConfig, Siglip2VisionModel

>>> # Initializing a Siglip2VisionConfig with google/siglip2-base-patch16-naflex style configuration
>>> configuration = Siglip2VisionConfig()

>>> # Initializing a Siglip2VisionModel (with random weights) from the google/siglip2-base-patch16-naflex style configuration
>>> model = Siglip2VisionModel(configuration)

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

Siglip2ImageProcessor

class transformers.Siglip2ImageProcessor

< >

( do_resize: bool = True resample: PILImageResampling = <Resampling.BILINEAR: 2> do_rescale: bool = True rescale_factor: 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 patch_size: int = 16 max_num_patches: int = 256 **kwargs )

参数

  • do_resize (bool, 可选, 默认为 True) — 是否根据给定的 patch_size 调整图像尺寸以适应 max_num_patches。可在 preprocess 方法中的 do_resize 参数覆盖。
  • resample (PILImageResampling, 可选, 默认为 Resampling.BILINEAR) — 如果调整图像尺寸,要使用的重采样滤镜。可在 preprocess 方法中的 resample 参数覆盖。
  • do_rescale (bool, 可选, 默认为 True) — 是否按指定的比例因子 rescale_factor 缩放图像。可在 preprocess 方法中的 do_rescale 参数覆盖。
  • rescale_factor (intfloat, 可选, 默认为 1/255) — 如果缩放图像,要使用的比例因子。可在 preprocess 方法中的 rescale_factor 参数覆盖。
  • do_normalize (bool, 可选, 默认为 True) — 是否按指定的均值和标准差对图像进行归一化。可在 preprocess 方法中的 do_normalize 参数覆盖。
  • image_mean (floatlist[float], 可选, 默认为 [0.5, 0.5, 0.5]) — 如果对图像进行归一化,要使用的均值。这是一个浮点数或浮点数列表,长度与图像中的通道数相同。可在 preprocess 方法中的 image_mean 参数覆盖。
  • image_std (floatlist[float], 可选, 默认为 [0.5, 0.5, 0.5]) — 如果对图像进行归一化,要使用的标准差。这是一个浮点数或浮点数列表,长度与图像中的通道数相同。可在 preprocess 方法中的 image_std 参数覆盖。可在 preprocess 方法中的 image_std 参数覆盖。
  • do_convert_rgb (bool, 可选, 默认为 True) — 是否将图像转换为 RGB。
  • patch_size (int, 可选, 默认为 16) — 图像将被分割成每个补丁的大小(分辨率)。
  • max_num_patches (int, 可选, 默认为 256) — 图像将被调整大小,使其最多包含此数量的补丁,然后在“补丁”维度上进行填充以精确匹配此数量。

构造 SigLIP2 图像处理器。

预处理

< >

( 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 resample: typing.Optional[ForwardRef('PILImageResampling')] = 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[str, transformers.utils.generic.TensorType, NoneType] = None input_data_format: typing.Union[str, transformers.image_utils.ChannelDimension, NoneType] = None do_convert_rgb: typing.Optional[bool] = None patch_size: typing.Optional[int] = None max_num_patches: typing.Optional[int] = 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 (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 的批次。
  • input_data_format (ChannelDimensionstr, 可选) — 输入图像的通道维度格式。如果未设置,通道维度格式将从输入图像推断。可以是以下之一:
    • "channels_first"ChannelDimension.FIRST:图像格式为 (num_channels, height, width)。
    • "channels_last"ChannelDimension.LAST:图像格式为 (height, width, num_channels)。
    • "none"ChannelDimension.NONE:图像格式为 (height, width)。
  • do_convert_rgb (bool, 可选, 默认为 self.do_convert_rgb) — 是否将图像转换为 RGB。
  • patch_size (int, 可选, 默认为 self.patch_size) — 用于处理的补丁大小,与模型中使用的补丁大小相同。
  • max_num_patches (int, 可选, 默认为 self.max_num_patches) — 每张图像的最大补丁数,图像将被调整大小以最多包含此数量的补丁。

预处理一张或一批图像。

Siglip2ImageProcessorFast

class transformers.Siglip2ImageProcessorFast

< >

( **kwargs: typing_extensions.Unpack[transformers.models.siglip2.image_processing_siglip2_fast.Siglip2FastImageProcessorKwargs] )

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

预处理

< >

( 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.models.siglip2.image_processing_siglip2_fast.Siglip2FastImageProcessorKwargs] ) <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], 可选) — 应用 center_crop 后输出图像的尺寸。
  • do_rescale (bool, 可选) — 是否缩放图像。
  • rescale_factor (Union[int, float, NoneType]) — 如果 do_rescale 设置为 True,用于缩放图像的比例因子。
  • do_normalize (bool, 可选) — 是否对图像进行归一化。
  • image_mean (Union[float, list[float], NoneType]) — 用于归一化的图像均值。仅在 do_normalize 设置为 True 时有效。
  • image_std (Union[float, list[float], NoneType]) — 用于归一化的图像标准差。仅在 do_normalize 设置为 True 时有效。
  • do_convert_rgb (bool, 可选) — 是否将图像转换为 RGB。
  • return_tensors (str~utils.generic.TensorType, 可选) — 如果设置为 `pt`,则返回堆叠张量,否则返回张量列表。
  • data_format (~image_utils.ChannelDimension, 可选) — 仅支持 ChannelDimension.FIRST。为与慢速处理器兼容而添加。
  • input_data_format (Union[str, ~image_utils.ChannelDimension, NoneType]) — 输入图像的通道维度格式。如果未设置,通道维度格式将从输入图像推断。可以是以下之一:
    • "channels_first"ChannelDimension.FIRST:图像格式为 (num_channels, height, width)。
    • "channels_last"ChannelDimension.LAST:图像格式为 (height, width, num_channels)。
    • "none"ChannelDimension.NONE:图像格式为 (height, width)。
  • device (torch.device, 可选) — 处理图像的设备。如果未设置,设备将从输入图像推断。
  • disable_grouping (bool, 可选) — 是否禁用图像按大小分组以单独处理而不是批量处理。如果为 None,则如果图像在 CPU 上,则设置为 True,否则设置为 False。此选择基于经验观察,详情如下:https://github.com/huggingface/transformers/pull/38157
  • patch_size (int, 可选, 默认为 16) — 图像将分割成的每个补丁的大小(分辨率)。
  • max_num_patches (int, 可选, 默认为 256) — 图像将被调整大小,使其最多包含此数量的补丁,然后在“补丁”维度上进行填充以精确匹配此数量。

返回

<class 'transformers.image_processing_base.BatchFeature'>

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

Siglip2Processor

class transformers.Siglip2Processor

< >

( image_processor tokenizer )

参数

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

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

批解码

< >

( *args **kwargs )

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

解码

< >

( *args **kwargs )

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

Siglip2Model

class transformers.Siglip2Model

< >

( config: Siglip2Config )

参数

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

不带任何特定头部输出原始隐藏状态的裸 Siglip2 模型。

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

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

前向传播

< >

( input_ids: typing.Optional[torch.LongTensor] = None pixel_values: typing.Optional[torch.FloatTensor] = None pixel_attention_mask: typing.Optional[torch.Tensor] = None spatial_shapes: typing.Optional[torch.LongTensor] = 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 ) transformers.models.siglip2.modeling_siglip2.Siglip2Outputtuple(torch.FloatTensor)

参数

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

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

    什么是输入 ID?

  • pixel_values (形状为 (batch_size, num_channels, image_size, image_size)torch.FloatTensor可选) — 对应于输入图像的张量。像素值可以使用 {image_processor_class} 获取。有关详细信息,请参阅 {image_processor_class}.__call__{processor_class} 使用 {image_processor_class} 处理图像)。
  • pixel_attention_mask (形状为 (batch_size, image_size, image_size)torch.Tensor可选) — 用于避免对填充像素索引执行注意力操作的掩码。
  • spatial_shapes (形状为 (batch_size, 2)torch.LongTensor) — 包含输入图像空间尺寸(高度、宽度)的张量。
  • attention_mask (形状为 (batch_size, sequence_length)torch.Tensor可选) — 用于避免对填充标记索引执行注意力操作的掩码。掩码值选择在 [0, 1] 中:

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

    什么是注意力掩码?

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

    什么是位置 ID?

  • return_loss (bool可选) — 是否返回对比损失。
  • output_attentions (bool可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的 attentions
  • output_hidden_states (bool可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的 hidden_states

返回

transformers.models.siglip2.modeling_siglip2.Siglip2Outputtuple(torch.FloatTensor)

一个 transformers.models.siglip2.modeling_siglip2.Siglip2Output 或一个 torch.FloatTensor 元组(如果传递 return_dict=False 或当 config.return_dict=False 时),包含根据配置(Siglip2Config)和输入的不同元素。

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

Siglip2Model 前向传播方法,覆盖了 __call__ 特殊方法。

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

示例

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

>>> model = AutoModel.from_pretrained("google/siglip2-base-patch16-224")
>>> processor = AutoProcessor.from_pretrained("google/siglip2-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: 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 (形状为 (batch_size, output_dim) 的 torch.FloatTensor)

参数

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

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

    什么是输入 ID?

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

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

    什么是注意力掩码?

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

    什么是位置 ID?

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

返回

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

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

示例

>>> from transformers import AutoTokenizer, AutoModel
>>> import torch

>>> model = AutoModel.from_pretrained("google/siglip2-base-patch16-224")
>>> tokenizer = AutoTokenizer.from_pretrained("google/siglip2-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)

获取图像特征

< >

( pixel_values: typing.Optional[torch.FloatTensor] = None pixel_attention_mask: typing.Optional[torch.Tensor] = None spatial_shapes: typing.Optional[torch.LongTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None ) image_features (形状为 (batch_size, output_dim) 的 torch.FloatTensor)

参数

  • pixel_values (形状为 (batch_size, num_channels, image_size, image_size)torch.FloatTensor可选) — 对应于输入图像的张量。像素值可以使用 {image_processor_class} 获取。有关详细信息,请参阅 {image_processor_class}.__call__{processor_class} 使用 {image_processor_class} 处理图像)。
  • pixel_attention_mask (形状为 (batch_size, image_size, image_size)torch.Tensor可选) — 用于避免对填充像素索引执行注意力操作的掩码。
  • spatial_shapes (形状为 (batch_size, 2)torch.LongTensor) — 包含输入图像空间尺寸(高度、宽度)的张量。
  • output_attentions (bool可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的 attentions
  • output_hidden_states (bool可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的 hidden_states

返回

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

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

示例

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

>>> model = AutoModel.from_pretrained("google/siglip2-base-patch16-224")
>>> processor = AutoProcessor.from_pretrained("google/siglip2-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)

Siglip2TextModel

class transformers.Siglip2TextModel

< >

( config: Siglip2TextConfig )

参数

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

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

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

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

前向传播

< >

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

参数

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

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

    什么是输入 ID?

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

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

    什么是注意力掩码?

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

    什么是位置 ID?

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

返回

transformers.modeling_outputs.BaseModelOutputWithPoolingtuple(torch.FloatTensor)

一个 transformers.modeling_outputs.BaseModelOutputWithPooling 或一个 torch.FloatTensor 元组(如果传递 return_dict=False 或当 config.return_dict=False 时),包含根据配置(Siglip2Config)和输入的不同元素。

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

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

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

    模型在每个层输出的隐藏状态以及可选的初始嵌入输出。

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

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

Siglip2TextModel 前向传播方法,覆盖了 __call__ 特殊方法。

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

示例

>>> from transformers import AutoTokenizer, Siglip2TextModel

>>> model = Siglip2TextModel.from_pretrained("google/siglip2-base-patch16-224")
>>> tokenizer = AutoTokenizer.from_pretrained("google/siglip2-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

Siglip2VisionModel

class transformers.Siglip2VisionModel

< >

( config: Siglip2VisionConfig )

参数

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

Siglip2 的视觉模型,顶部没有任何头部或投影层。

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

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

前向传播

< >

( pixel_values: FloatTensor pixel_attention_mask: Tensor spatial_shapes: LongTensor output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None ) transformers.modeling_outputs.BaseModelOutputWithPooling or tuple(torch.FloatTensor)

参数

  • pixel_values (torch.FloatTensor,形状为 (batch_size, num_channels, image_size, image_size)) — 对应于输入图像的张量。像素值可以使用 {image_processor_class} 获取。详情请参见 {image_processor_class}.__call__{processor_class} 使用 {image_processor_class} 来处理图像)。
  • pixel_attention_mask (torch.Tensor,形状为 (batch_size, image_size, image_size), 可选) — 用于避免在填充像素索引上执行注意力操作的掩码。
  • spatial_shapes (torch.LongTensor,形状为 (batch_size, 2)) — 包含输入图像空间维度(高度,宽度)的张量。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。更多详情请参见返回张量中的 attentions
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。更多详情请参见返回张量中的 hidden_states

返回

transformers.modeling_outputs.BaseModelOutputWithPoolingtuple(torch.FloatTensor)

一个 transformers.modeling_outputs.BaseModelOutputWithPooling 或一个 torch.FloatTensor 元组(如果传递 return_dict=False 或当 config.return_dict=False 时),包含根据配置(Siglip2Config)和输入的不同元素。

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

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

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

    模型在每个层输出的隐藏状态以及可选的初始嵌入输出。

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

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

Siglip2VisionModel 的 forward 方法,重写了 __call__ 特殊方法。

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

示例

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

>>> model = Siglip2VisionModel.from_pretrained("google/siglip2-base-patch16-224")
>>> processor = AutoProcessor.from_pretrained("google/siglip2-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

Siglip2ForImageClassification

class transformers.Siglip2ForImageClassification

< >

( config: Siglip2Config )

参数

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

Siglip2 视觉编码器,顶部带有图像分类头(在 patch token 的池化最终隐藏状态之上的线性层),例如用于 ImageNet。

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

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

前向传播

< >

( pixel_values: typing.Optional[torch.Tensor] = None pixel_attention_mask: typing.Optional[torch.Tensor] = None spatial_shapes: typing.Optional[torch.LongTensor] = None labels: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None ) transformers.modeling_outputs.ImageClassifierOutput or 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} 来处理图像)。
  • pixel_attention_mask (torch.Tensor,形状为 (batch_size, image_size, image_size), 可选) — 用于避免在填充像素索引上执行注意力操作的掩码。
  • spatial_shapes (torch.LongTensor,形状为 (batch_size, 2)) — 包含输入图像空间维度(高度,宽度)的张量。
  • 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

返回

transformers.modeling_outputs.ImageClassifierOutputtuple(torch.FloatTensor)

一个 transformers.modeling_outputs.ImageClassifierOutput 或一个 torch.FloatTensor 的元组(如果传入 return_dict=Falseconfig.return_dict=False),包含根据配置 (Siglip2Config) 和输入而定的各种元素。

  • 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=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, patch_size, sequence_length)

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

Siglip2ForImageClassification 的 forward 方法,重写了 __call__ 特殊方法。

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

示例

>>> from transformers import AutoImageProcessor, Siglip2ForImageClassification
>>> 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 `Siglip2Model` 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/siglip2-base-patch16-224")
>>> model = Siglip2ForImageClassification.from_pretrained("google/siglip2-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 上更新