Transformers 文档
SigLIP2
并获得增强的文档体验
开始使用
SigLIP2
概述
SigLIP2 是一系列基于 SigLIP 训练方法的、多语言的视觉-语言编码器。它包括基于解码器的预训练、自蒸馏和掩码预测,以改进密集预测任务(如分割、深度估计等)。该模型提供两种变体:
- NaFlex 支持不同的分辨率并保持原始图像宽高比
- FixRes 支持固定分辨率并与 SigLIP 向后兼容
所有原始 SigLIP2 检查点均可在 SigLIP2 集合中找到。
点击右侧边栏的 SigLIP2 模型,可查看如何将 SigLIP2 应用于不同图像和文本任务的更多示例。
以下示例展示了使用 Pipeline 或 AutoModel 类进行零样本分类。
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
< source >( 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
< source >( text_config: Siglip2TextConfig vision_config: Siglip2VisionConfig **kwargs ) → Siglip2Config
从 siglip2 文本模型配置和 siglip2 视觉模型配置实例化 Siglip2Config(或派生类)。
Siglip2TextConfig
class transformers.Siglip2TextConfig
< source >( 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
orfunction
, 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 tohidden_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
< source >( 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
orfunction
, 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
< source >( 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 (
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
参数覆盖。可在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 (
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
的批次。
- 未设置:返回
- input_data_format (
ChannelDimension
或str
, 可选) — 输入图像的通道维度格式。如果未设置,通道维度格式将从输入图像推断。可以是以下之一:"channels_first"
或ChannelDimension.FIRST
:图像格式为 (num_channels, height, width)。"channels_last"
或ChannelDimension.LAST
:图像格式为 (height, width, num_channels)。"none"
或ChannelDimension.NONE
:图像格式为 (height, width)。
- 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
< source >( image_processor tokenizer )
参数
- image_processor (Siglip2ImageProcessor) — 图像处理器是必需的输入。
- tokenizer (GemmaTokenizerFast) — 分词器是必需的输入。
构建一个 Siglip2 处理器,它将 Siglip2 图像处理器和 Gemma 分词器封装到一个处理器中。
Siglip2Processor 提供 Siglip2ImageProcessor 和 GemmaTokenizerFast 的所有功能。有关更多信息,请参阅 __call__()
和 decode()。
此方法将其所有参数转发给 Siglip2Tokenizer 的 batch_decode()。有关更多信息,请参阅此方法的文档字符串。
此方法将其所有参数转发给 Siglip2Tokenizer 的 decode()。有关更多信息,请参阅此方法的文档字符串。
Siglip2Model
class transformers.Siglip2Model
< source >( config: Siglip2Config )
参数
- config (Siglip2Config) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只会加载配置。查看 from_pretrained() 方法以加载模型权重。
不带任何特定头部输出原始隐藏状态的裸 Siglip2 模型。
此模型继承自 PreTrainedModel。查看超类文档,了解库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、修剪头部等)。
此模型也是 PyTorch torch.nn.Module 子类。将其作为常规 PyTorch 模块使用,并参考 PyTorch 文档,了解所有与一般使用和行为相关的事项。
前向传播
< source >( 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.Siglip2Output
或 tuple(torch.FloatTensor)
参数
- input_ids (形状为
(batch_size, sequence_length)
的torch.LongTensor
,可选) — 词汇表中输入序列标记的索引。默认情况下会忽略填充。可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- 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]
。 - return_loss (
bool
,可选) — 是否返回对比损失。 - output_attentions (
bool
,可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions
。 - output_hidden_states (
bool
,可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
。
返回
transformers.models.siglip2.modeling_siglip2.Siglip2Output
或 tuple(torch.FloatTensor)
一个 transformers.models.siglip2.modeling_siglip2.Siglip2Output
或一个 torch.FloatTensor
元组(如果传递 return_dict=False
或当 config.return_dict=False
时),包含根据配置(Siglip2Config)和输入的不同元素。
- loss (
torch.FloatTensor
,形状为(1,)
, 可选, 当return_loss
为True
时返回) — 图像-文本相似度的对比损失。 - logits_per_image (形状为
(image_batch_size, text_batch_size)
的torch.FloatTensor
) —image_embeds
和text_embeds
之间的缩放点积分数。这表示图像-文本相似性分数。 - logits_per_text (形状为
(text_batch_size, image_batch_size)
的torch.FloatTensor
) —text_embeds
和image_embeds
之间的缩放点积分数。这表示文本-图像相似性分数。 - text_embeds (形状为
(batch_size, output_dim
) 的torch.FloatTensor
) — 通过将投影层应用于 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'
获取文本特征
< 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 (形状为 (batch_size, output_dim
) 的 torch.FloatTensor
)
参数
- input_ids (形状为
(batch_size, sequence_length)
的torch.Tensor
,可选) — 词汇表中输入序列标记的索引。默认情况下会忽略填充。可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- 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]
。 - 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)
获取图像特征
< source >( 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
< source >( config: Siglip2TextConfig )
参数
- config (Siglip2TextConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只会加载配置。查看 from_pretrained() 方法以加载模型权重。
Siglip2 的文本模型,不带任何头部或投影。
此模型继承自 PreTrainedModel。查看超类文档,了解库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、修剪头部等)。
此模型也是 PyTorch torch.nn.Module 子类。将其作为常规 PyTorch 模块使用,并参考 PyTorch 文档,了解所有与一般使用和行为相关的事项。
前向传播
< 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 (形状为
(batch_size, sequence_length)
的torch.Tensor
,可选) — 词汇表中输入序列标记的索引。默认情况下会忽略填充。可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- 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]
。 - 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
时),包含根据配置(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=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(如果模型有嵌入层,则为嵌入层输出一个 + 每个层输出一个)。模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.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
< source >( config: Siglip2VisionConfig )
参数
- config (Siglip2VisionConfig) — 模型配置类,包含模型的所有参数。用配置文件初始化不会加载与模型相关的权重,只加载配置。请查看 from_pretrained() 方法来加载模型权重。
Siglip2 的视觉模型,顶部没有任何头部或投影层。
此模型继承自 PreTrainedModel。查看超类文档,了解库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、修剪头部等)。
此模型也是 PyTorch torch.nn.Module 子类。将其作为常规 PyTorch 模块使用,并参考 PyTorch 文档,了解所有与一般使用和行为相关的事项。
前向传播
< source >( 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.BaseModelOutputWithPooling 或 tuple(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=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(如果模型有嵌入层,则为嵌入层输出一个 + 每个层输出一个)。模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.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
< source >( config: Siglip2Config )
参数
- config (Siglip2Config) — 模型配置类,包含模型的所有参数。用配置文件初始化不会加载与模型相关的权重,只加载配置。请查看 from_pretrained() 方法来加载模型权重。
Siglip2 视觉编码器,顶部带有图像分类头(在 patch token 的池化最终隐藏状态之上的线性层),例如用于 ImageNet。
此模型继承自 PreTrainedModel。查看超类文档,了解库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、修剪头部等)。
此模型也是 PyTorch torch.nn.Module 子类。将其作为常规 PyTorch 模块使用,并参考 PyTorch 文档,了解所有与一般使用和行为相关的事项。
前向传播
< source >( 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.ImageClassifierOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.ImageClassifierOutput 或一个 torch.FloatTensor
的元组(如果传入 return_dict=False
或 config.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=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 后的注意力权重,用于计算自注意力头中的加权平均值。
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