OWLv2
概述
OWLv2 在 Matthias Minderer、Alexey Gritsenko 和 Neil Houlsby 的论文 Scaling Open-Vocabulary Object Detection 中被提出。OWLv2 使用自训练扩展了 OWL-ViT,该方法利用现有的检测器在图像-文本对上生成伪框标注。这使得零样本目标检测的性能大幅超越了之前最先进的技术。
论文摘要如下:
开放词汇目标检测受益于预训练的视觉-语言模型,但仍然受到可用检测训练数据量的限制。虽然可以通过使用网络图像-文本对作为弱监督来扩展检测训练数据,但这尚未达到与图像级预训练相当的规模。在这里,我们使用自训练来扩展检测数据,该方法利用现有的检测器在图像-文本对上生成伪框标注。自训练扩展面临的主要挑战包括标签空间的选择、伪标注过滤和训练效率。我们提出了 OWLv2 模型和 OWL-ST 自训练方案,以解决这些挑战。OWLv2 在可比的训练规模(约 1000 万个示例)下就超越了之前最先进的开放词汇检测器的性能。然而,通过 OWL-ST,我们可以扩展到超过 10 亿个示例,从而带来进一步的显著改进:使用 L/14 架构,OWL-ST 在 LVIS 稀有类别的 AP 上取得了改进,模型从未见过这些类别的任何人工框标注,从 31.2% 提高到 44.6%(相对提高 43%)。OWL-ST 为开放世界定位解锁了网络规模训练,类似于图像分类和语言建模领域所取得的成果。
OWLv2 高级概述。摘自 原始论文。该模型由 nielsr 贡献。原始代码可以在这里找到 这里。
使用示例
OWLv2 与其前身 OWL-ViT 一样,是一个零样本文本条件目标检测模型。OWL-ViT 使用 CLIP 作为其多模态骨干网络,并使用类似 ViT 的 Transformer 获取视觉特征,以及使用因果语言模型获取文本特征。为了使用 CLIP 进行检测,OWL-ViT 去除了视觉模型的最终 token 池化层,并在每个 Transformer 输出 token 上附加了一个轻量级的分类和框头。通过用从文本模型获得的类名嵌入替换固定的分类层权重,实现了开放词汇分类。作者首先从头开始训练 CLIP,然后使用二分匹配损失在标准检测数据集上对其进行端到端微调,并使用分类和框头。可以使用一个或多个图像的文本查询来执行零样本文本条件目标检测。
Owlv2ImageProcessor 可用于调整图像大小(或重新缩放)并为模型标准化图像,而 CLIPTokenizer 用于编码文本。 Owlv2Processor 将 Owlv2ImageProcessor 和 CLIPTokenizer 封装到一个实例中,以同时编码文本和准备图像。以下示例显示了如何使用 Owlv2Processor 和 Owlv2ForObjectDetection 执行目标检测。
>>> import requests
>>> from PIL import Image
>>> import torch
>>> from transformers import Owlv2Processor, Owlv2ForObjectDetection
>>> processor = Owlv2Processor.from_pretrained("google/owlv2-base-patch16-ensemble")
>>> model = Owlv2ForObjectDetection.from_pretrained("google/owlv2-base-patch16-ensemble")
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> texts = [["a photo of a cat", "a photo of a dog"]]
>>> inputs = processor(text=texts, images=image, return_tensors="pt")
>>> outputs = model(**inputs)
>>> # Target image sizes (height, width) to rescale box predictions [batch_size, 2]
>>> target_sizes = torch.Tensor([image.size[::-1]])
>>> # Convert outputs (bounding boxes and class logits) to Pascal VOC Format (xmin, ymin, xmax, ymax)
>>> results = processor.post_process_object_detection(outputs=outputs, target_sizes=target_sizes, threshold=0.1)
>>> i = 0 # Retrieve predictions for the first image for the corresponding text queries
>>> text = texts[i]
>>> boxes, scores, labels = results[i]["boxes"], results[i]["scores"], results[i]["labels"]
>>> for box, score, label in zip(boxes, scores, labels):
... box = [round(i, 2) for i in box.tolist()]
... print(f"Detected {text[label]} with confidence {round(score.item(), 3)} at location {box}")
Detected a photo of a cat with confidence 0.614 at location [341.67, 23.39, 642.32, 371.35]
Detected a photo of a cat with confidence 0.665 at location [6.75, 51.96, 326.62, 473.13]
资源
- 可以在 这里 找到一个关于使用 OWLv2 进行零样本和单样本(图像引导)目标检测的演示笔记本。
- 零样本目标检测任务指南
OWLv2 的架构与 OWL-ViT 相同,但是目标检测头现在还包括一个目标性分类器,该分类器预测预测框包含目标(而不是背景)的(与查询无关的)可能性。目标性分数可用于根据文本查询独立地对预测进行排序或过滤。OWLv2 的使用方法与 OWL-ViT 相同,但使用了一个新的、更新的图像处理器(Owlv2ImageProcessor)。
Owlv2Config
类 transformers.Owlv2Config
< 源代码 >( text_config = None vision_config = None projection_dim = 512 logit_scale_init_value = 2.6592 return_dict = True **kwargs )
参数
- text_config (
dict
, 可选) — 用于初始化 Owlv2TextConfig 的配置选项字典。 - vision_config (
dict
, 可选) — 用于初始化 Owlv2VisionConfig 的配置选项字典。 - projection_dim (
int
, 可选, 默认为 512) — 文本和视觉投影层的维度。 - logit_scale_init_value (
float
, 可选, 默认为 2.6592) — logit_scale 参数的初始值。默认值与原始 OWLv2 实现中使用的一致。 - return_dict (
bool
, 可选, 默认为True
) — 模型是否应该返回字典。如果为False
,则返回元组。 - kwargs (可选) — 关键字参数的字典。
Owlv2Config 是用于存储 Owlv2Model 配置的配置类。它用于根据指定的参数实例化 OWLv2 模型,定义文本模型和视觉模型的配置。使用默认值实例化配置将产生与 OWLv2 google/owlv2-base-patch16 架构类似的配置。
配置对象继承自 PretrainedConfig,可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。
从 owlv2 文本模型配置和 owlv2 视觉模型配置实例化 Owlv2Config(或派生类)。
Owlv2TextConfig
类 transformers.Owlv2TextConfig
< 源代码 >( vocab_size = 49408 hidden_size = 512 intermediate_size = 2048 num_hidden_layers = 12 num_attention_heads = 8 max_position_embeddings = 16 hidden_act = 'quick_gelu' layer_norm_eps = 1e-05 attention_dropout = 0.0 initializer_range = 0.02 initializer_factor = 1.0 pad_token_id = 0 bos_token_id = 49406 eos_token_id = 49407 **kwargs )
参数
- vocab_size (
int
, 可选, 默认为 49408) — OWLv2 文本模型的词汇量大小。定义了调用 Owlv2TextModel 时传递的inputs_ids
可以表示的不同标记的数量。 - hidden_size (
int
,可选,默认为 512) — 编码器层和池化层的维度。 - intermediate_size (
int
,可选,默认为 2048) — Transformer 编码器中“中间”(即前馈)层的维度。 - num_hidden_layers (
int
,可选,默认为 12) — Transformer 编码器中隐藏层的数量。 - num_attention_heads (
int
,可选,默认为 8) — Transformer 编码器中每个注意力层的注意力头的数量。 - max_position_embeddings (
int
,可选,默认为 16) — 此模型可能使用的最大序列长度。通常将此设置为一个较大的值以防万一(例如,512 或 1024 或 2048)。 - hidden_act (
str
或function
,可选,默认为"quick_gelu"
) — 编码器和池化器中的非线性激活函数(函数或字符串)。如果为字符串,则支持"gelu"
、"relu"
、"selu"
和"gelu_new"
"quick_gelu"
。 - layer_norm_eps (
float
,可选,默认为 1e-05) — 层归一化层使用的 epsilon。 - attention_dropout (
float
,可选,默认为 0.0) — 注意力概率的 dropout 比率。 - initializer_range (
float
,可选,默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。 - initializer_factor (
float
,可选,默认为 1.0) — 初始化所有权重矩阵的因子(应保持为 1,在内部用于初始化测试)。 - eos_token_id (
int
, 可选, 默认为 49407) — 输入序列中序列结束标记的 ID。
这是用于存储 Owlv2TextModel 配置的配置类。它用于根据指定的参数实例化 Owlv2 文本编码器,定义模型架构。使用默认值实例化配置将产生与 Owlv2 google/owlv2-base-patch16 架构类似的配置。
配置对象继承自 PretrainedConfig,可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。
示例
>>> from transformers import Owlv2TextConfig, Owlv2TextModel
>>> # Initializing a Owlv2TextModel with google/owlv2-base-patch16 style configuration
>>> configuration = Owlv2TextConfig()
>>> # Initializing a Owlv2TextConfig from the google/owlv2-base-patch16 style configuration
>>> model = Owlv2TextModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
Owlv2VisionConfig
类 transformers.Owlv2VisionConfig
< 源代码 >( hidden_size = 768 intermediate_size = 3072 num_hidden_layers = 12 num_attention_heads = 12 num_channels = 3 image_size = 768 patch_size = 16 hidden_act = 'quick_gelu' layer_norm_eps = 1e-05 attention_dropout = 0.0 initializer_range = 0.02 initializer_factor = 1.0 **kwargs )
参数
- hidden_size (
int
, 可选, 默认为 768) — 编码器层和池化层的维度。 - intermediate_size (
int
, 可选, 默认为 3072) — Transformer 编码器中“中间”(即前馈)层的维度。 - num_hidden_layers (
int
, 可选, 默认为 12) — Transformer 编码器中隐藏层的数量。 - num_attention_heads (
int
, 可选, 默认为 12) — Transformer 编码器中每个注意力层的注意力头的数量。 - num_channels (
int
, 可选, 默认为 3) — 输入图像中的通道数。 - hidden_act (
str
或function
,可选,默认为"quick_gelu"
) — 编码器和池化器中的非线性激活函数(函数或字符串)。如果为字符串,则支持"gelu"
、"relu"
、"selu"
和"gelu_new"
"quick_gelu"
。 - layer_norm_eps (
float
,可选,默认为 1e-05) — 层归一化层使用的 epsilon。 - attention_dropout (
float
,可选,默认为 0.0) — 注意力概率的 dropout 比率。 - initializer_range (
float
,可选,默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。 - initializer_factor (
float
,可选,默认为 1.0) — 用于初始化所有权重矩阵的因子(应保持为 1,在内部用于初始化测试)。
这是用于存储 Owlv2VisionModel 配置的配置类。它用于根据指定的参数实例化 OWLv2 图像编码器,定义模型架构。使用默认值实例化配置将生成与 OWLv2 google/owlv2-base-patch16 架构类似的配置。
配置对象继承自 PretrainedConfig,可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。
示例
>>> from transformers import Owlv2VisionConfig, Owlv2VisionModel
>>> # Initializing a Owlv2VisionModel with google/owlv2-base-patch16 style configuration
>>> configuration = Owlv2VisionConfig()
>>> # Initializing a Owlv2VisionModel model from the google/owlv2-base-patch16 style configuration
>>> model = Owlv2VisionModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
Owlv2ImageProcessor
类 transformers.Owlv2ImageProcessor
< 源代码 >( do_rescale: bool = True rescale_factor: Union = 0.00392156862745098 do_pad: bool = True do_resize: bool = True size: Dict = None resample: Resampling = <Resampling.BILINEAR: 2> do_normalize: bool = True image_mean: Union = None image_std: Union = None **kwargs )
参数
- do_rescale (
bool
,可选,默认为True
) — 是否按指定的比例rescale_factor
重新缩放图像。可以在preprocess
方法中的do_rescale
中覆盖。 - rescale_factor (
int
或float
, 可选,默认为1/255
) — 如果重新缩放图像,则使用的缩放因子。可以在preprocess
方法中的rescale_factor
中覆盖。 - do_pad (
bool
, 可选,默认为True
) — 是否将图像填充为正方形,底部和右侧使用灰色像素。可以在preprocess
方法中的do_pad
中覆盖。 - do_resize (
bool
, 可选,默认为True
) — 控制是否将图像的(高度,宽度)尺寸调整为指定的size
。可以在preprocess
方法中的do_resize
中覆盖。 - size (
Dict[str, int]
可选,默认为{"height" -- 960, "width": 960}
): 要将图像调整到的尺寸。可以在preprocess
方法中的size
中覆盖。 - resample (
PILImageResampling
, 可选,默认为Resampling.BILINEAR
) — 如果调整图像大小,则使用的重采样方法。可以在preprocess
方法中的resample
中覆盖。 - do_normalize (
bool
, 可选,默认为True
) — 是否标准化图像。可以在preprocess
方法中的do_normalize
参数中覆盖。 - image_mean (
float
或List[float]
, 可选,默认为OPENAI_CLIP_MEAN
) — 如果标准化图像,则使用的均值。这是一个浮点数或长度等于图像通道数的浮点数列表。可以在preprocess
方法中的image_mean
参数中覆盖。 - image_std (
float
或List[float]
, 可选,默认为OPENAI_CLIP_STD
) — 如果标准化图像,则使用的标准差。这是一个浮点数或长度等于图像通道数的浮点数列表。可以在preprocess
方法中的image_std
参数中覆盖。
构造一个 OWLv2 图像处理器。
预处理
< 源代码 > ( images: Union do_pad: bool = None do_resize: bool = None size: Dict = None do_rescale: bool = None rescale_factor: float = None do_normalize: bool = None image_mean: Union = None image_std: Union = None return_tensors: Union = None data_format: ChannelDimension = <ChannelDimension.FIRST: 'channels_first'> input_data_format: Union = None )
参数
- images (
ImageInput
) — 预处理的图像。预期为单个或批量的图像,像素值范围为 0 到 255。如果传入像素值介于 0 和 1 之间的图像,请设置do_rescale=False
。 - do_pad (
bool
, 可选, 默认为self.do_pad
) — 是否将图像填充为正方形,底部和右侧使用灰色像素填充。 - do_resize (
bool
, 可选, 默认为self.do_resize
) — 是否调整图像大小。 - size (
Dict[str, int]
, 可选, 默认为self.size
) — 将图像调整到的尺寸。 - do_rescale (
bool
, 可选, 默认为self.do_rescale
) — 是否将图像值重新缩放至 [0 - 1] 之间。 - rescale_factor (
float
, 可选, 默认为self.rescale_factor
) — 如果do_rescale
设置为True
,则用于重新缩放图像的缩放因子。 - do_normalize (
bool
, 可选, 默认为self.do_normalize
) — 是否标准化图像。 - image_mean (
float
或List[float]
, 可选, 默认为self.image_mean
) — 图像均值。 - image_std (
float
或List[float]
, 可选, 默认为self.image_std
) — 图像标准差。 - 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
类型的批次。
- 未设置:返回
预处理图像或图像批次。
post_process_object_detection
< 源代码 > ( outputs threshold: float = 0.1 target_sizes: Union = None ) → List[Dict]
将 OwlViTForObjectDetection 的原始输出转换为最终的边界框格式 (左上角x, 左上角y, 右下角x, 右下角y)。
post_process_image_guided_detection
< 源代码 > ( outputs threshold = 0.0 nms_threshold = 0.3 target_sizes = None ) → List[Dict]
参数
一个字典列表,每个字典包含模型预测的批次中图像的分数、标签和边界框。由于OwlViTForObjectDetection.image_guided_detection
执行单次目标检测,因此所有标签都设置为None。
将OwlViTForObjectDetection.image_guided_detection()的输出转换为COCO api期望的格式。
Owlv2Processor
类 transformers.Owlv2Processor
< 源代码 >( image_processor tokenizer **kwargs )
参数
- image_processor (Owlv2ImageProcessor) — 图像处理器是必需的输入。
- tokenizer ([
CLIPTokenizer
,CLIPTokenizerFast
]) — 分词器是必需的输入。
构建一个Owlv2处理器,它将Owlv2ImageProcessor和CLIPTokenizer/CLIPTokenizerFast封装到一个继承图像处理器和分词器功能的单个处理器中。有关更多信息,请参阅__call__()
和decode()。
此方法将其所有参数转发到CLIPTokenizerFast的batch_decode()。有关更多信息,请参阅此方法的文档字符串。
此方法将其所有参数转发到OwlViTImageProcessor.post_process_one_shot_object_detection
。有关更多信息,请参阅此方法的文档字符串。
此方法将其所有参数转发到OwlViTImageProcessor.post_process_object_detection()。有关更多信息,请参阅此方法的文档字符串。
Owlv2Model
类 transformers.Owlv2Model
< 源代码 >( config: Owlv2Config )
参数
- config (
Owvl2Config
) — 模型配置类,包含模型的所有参数。使用配置文件初始化不会加载与模型关联的权重,仅加载配置。查看 from_pretrained() 方法以加载模型权重。
此模型继承自 PreTrainedModel。查看超类文档以了解库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入的大小、剪枝 head 等)。
此模型也是 PyTorch torch.nn.Module 的子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取与一般用法和行为相关的所有事项。
前向传播
< 源代码 > ( input_ids: Optional = None pixel_values: Optional = None attention_mask: Optional = None return_loss: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_base_image_embeds: Optional = None return_dict: Optional = None ) → transformers.models.owlv2.modeling_owlv2.Owlv2Output
或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor
形状为(batch_size, sequence_length)
) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。 什么是输入 ID? - pixel_values (
torch.FloatTensor
形状为(batch_size, num_channels, height, width)
) — 像素值。 - attention_mask (
torch.Tensor
形状为(batch_size, sequence_length)
, 可选) — 用于避免对填充标记索引执行注意力操作的掩码。掩码值选择在[0, 1]
中:- 1 表示未掩码的标记,
- 0 表示掩码的标记。 什么是注意力掩码?
- return_loss (
bool
, 可选) — 是否返回对比损失。 - output_attentions (
bool
, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions
。 - output_hidden_states (
bool
, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量中的hidden_states
。 - return_base_image_embeds (
bool
, 可选) — 是否返回基本图像嵌入。 - return_dict (
bool
, 可选) — 是否返回 ModelOutput 而不是普通元组。
返回
transformers.models.owlv2.modeling_owlv2.Owlv2Output
或 tuple(torch.FloatTensor)
一个 transformers.models.owlv2.modeling_owlv2.Owlv2Output
或 torch.FloatTensor
的元组(如果传递了 return_dict=False
或当 config.return_dict=False
时),包含取决于配置(<class 'transformers.models.owlv2.configuration_owlv2.Owlv2Config'>
)和输入的各种元素。
- 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 * num_max_text_queries, output_dim
) — 通过将投影层应用于 Owlv2TextModel 的池化输出获得的文本嵌入。 - image_embeds (
torch.FloatTensor
形状为(batch_size, output_dim
) — 通过将投影层应用于 Owlv2VisionModel 的池化输出获得的图像嵌入。 - text_model_output (Tuple
BaseModelOutputWithPooling
) — Owlv2TextModel 的输出。 - vision_model_output (
BaseModelOutputWithPooling
) — Owlv2VisionModel 的输出。
Owlv2Model 的前向方法覆盖了 __call__
特殊方法。
虽然前向传递的配方需要在此函数内定义,但之后应该调用 Module
实例,而不是此函数,因为前者负责运行预处理和后处理步骤,而后者则默默地忽略它们。
示例
>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, Owlv2Model
>>> model = Owlv2Model.from_pretrained("google/owlv2-base-patch16-ensemble")
>>> processor = AutoProcessor.from_pretrained("google/owlv2-base-patch16-ensemble")
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> inputs = processor(text=[["a photo of a cat", "a photo of a dog"]], images=image, return_tensors="pt")
>>> outputs = model(**inputs)
>>> logits_per_image = outputs.logits_per_image # this is the image-text similarity score
>>> probs = logits_per_image.softmax(dim=1) # we can take the softmax to get the label probabilities
get_text_features
< 源代码 > ( input_ids: Optional = None attention_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → text_features (torch.FloatTensor
形状为 (batch_size, output_dim
)
参数
- input_ids (
torch.LongTensor
形状为(batch_size * num_max_text_queries, sequence_length)
) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。 什么是输入 ID? - attention_mask (
torch.Tensor
形状为(batch_size, num_max_text_queries, sequence_length)
,可选) — 用于避免对填充标记索引执行注意力的掩码。在[0, 1]
中选择掩码值:- 1 表示未掩盖的标记,
- 0 表示已掩盖的标记。什么是注意力掩码?
- output_attentions (
bool
, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量中的attentions
。 - output_hidden_states (
bool
, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量中的hidden_states
。 - return_dict (
bool
, 可选) — 是否返回 ModelOutput 而不是普通元组。
返回
text_features (torch.FloatTensor
形状为 (batch_size, output_dim
)
通过将 Owlv2TextModel 的池化输出应用投影层获得的文本嵌入。
Owlv2Model 的前向方法覆盖了 __call__
特殊方法。
虽然前向传递的配方需要在此函数内定义,但之后应该调用 Module
实例,而不是此函数,因为前者负责运行预处理和后处理步骤,而后者则默默地忽略它们。
示例
>>> from transformers import AutoProcessor, Owlv2Model
>>> model = Owlv2Model.from_pretrained("google/owlv2-base-patch16-ensemble")
>>> processor = AutoProcessor.from_pretrained("google/owlv2-base-patch16-ensemble")
>>> inputs = processor(
... text=[["a photo of a cat", "a photo of a dog"], ["photo of a astranaut"]], return_tensors="pt"
... )
>>> text_features = model.get_text_features(**inputs)
get_image_features
< 源代码 > ( pixel_values: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → image_features (torch.FloatTensor
形状为 (batch_size, output_dim
)
参数
- pixel_values (
torch.FloatTensor
形状为(batch_size, num_channels, height, width)
) — 像素值。 - output_attentions (
bool
, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions
。 - output_hidden_states (
bool
, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
。 - return_dict (
bool
, 可选) — 是否返回 ModelOutput 而不是普通元组。
返回
image_features (torch.FloatTensor
形状为 (batch_size, output_dim
)
通过将 Owlv2VisionModel 的池化输出应用投影层获得的图像嵌入。
Owlv2Model 的前向方法覆盖了 __call__
特殊方法。
虽然前向传递的配方需要在此函数内定义,但之后应该调用 Module
实例,而不是此函数,因为前者负责运行预处理和后处理步骤,而后者则默默地忽略它们。
示例
>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, Owlv2Model
>>> model = Owlv2Model.from_pretrained("google/owlv2-base-patch16-ensemble")
>>> processor = AutoProcessor.from_pretrained("google/owlv2-base-patch16-ensemble")
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> inputs = processor(images=image, return_tensors="pt")
>>> image_features = model.get_image_features(**inputs)
Owlv2TextModel
前向传播
< 源代码 > ( input_ids: Tensor attention_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) →
transformers.modeling_outputs.BaseModelOutputWithPooling 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.BaseModelOutputWithPooling 或一个 torch.FloatTensor
的元组(如果传递了return_dict=False
或当config.return_dict=False
时),包含取决于配置(<class 'transformers.models.owlv2.configuration_owlv2.Owlv2TextConfig'>
)和输入的各种元素。
-
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 之后的注意力权重,用于计算自注意力头中的加权平均值。
Owlv2TextModel 的前向方法,覆盖了__call__
特殊方法。
虽然前向传递的配方需要在此函数内定义,但之后应该调用 Module
实例,而不是此函数,因为前者负责运行预处理和后处理步骤,而后者则默默地忽略它们。
示例
>>> from transformers import AutoProcessor, Owlv2TextModel
>>> model = Owlv2TextModel.from_pretrained("google/owlv2-base-patch16")
>>> processor = AutoProcessor.from_pretrained("google/owlv2-base-patch16")
>>> inputs = processor(
... text=[["a photo of a cat", "a photo of a dog"], ["photo of a astranaut"]], return_tensors="pt"
... )
>>> outputs = model(**inputs)
>>> last_hidden_state = outputs.last_hidden_state
>>> pooled_output = outputs.pooler_output # pooled (EOS token) states
Owlv2VisionModel
前向传播
< 源代码 > ( pixel_values: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → transformers.modeling_outputs.BaseModelOutputWithPooling 或 tuple(torch.FloatTensor)
参数
- pixel_values (
torch.FloatTensor
形状为(batch_size, num_channels, height, width)
) — 像素值。 - output_attentions (
bool
, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量中的attentions
。 - output_hidden_states (
bool
, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量中的hidden_states
。 - return_dict (
bool
, 可选) — 是否返回 ModelOutput 而不是普通元组。
返回
transformers.modeling_outputs.BaseModelOutputWithPooling 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.BaseModelOutputWithPooling 或 torch.FloatTensor
的元组(如果传递了 return_dict=False
或当 config.return_dict=False
时),包含取决于配置(<class 'transformers.models.owlv2.configuration_owlv2.Owlv2VisionConfig'>
)和输入的各种元素。
-
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 之后的注意力权重,用于计算自注意力头中的加权平均值。
Owlv2VisionModel 的前向方法覆盖了 __call__
特殊方法。
虽然前向传递的配方需要在此函数内定义,但之后应该调用 Module
实例,而不是此函数,因为前者负责运行预处理和后处理步骤,而后者则默默地忽略它们。
示例
>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, Owlv2VisionModel
>>> model = Owlv2VisionModel.from_pretrained("google/owlv2-base-patch16")
>>> processor = AutoProcessor.from_pretrained("google/owlv2-base-patch16")
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> inputs = processor(images=image, return_tensors="pt")
>>> outputs = model(**inputs)
>>> last_hidden_state = outputs.last_hidden_state
>>> pooled_output = outputs.pooler_output # pooled CLS states
Owlv2ForObjectDetection
前向传播
< 源代码 > ( input_ids: Tensor pixel_values: FloatTensor attention_mask: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → transformers.models.owlv2.modeling_owlv2.Owlv2ObjectDetectionOutput
或 tuple(torch.FloatTensor)
参数
- pixel_values (
torch.FloatTensor
形状为(batch_size, num_channels, height, width)
) — 像素值。 - input_ids (
torch.LongTensor
形状为(batch_size * num_max_text_queries, sequence_length)
, 可选) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。 什么是输入 ID?。 - attention_mask (
torch.Tensor
形状为(batch_size, num_max_text_queries, sequence_length)
,可选) — 用于避免对填充标记索引执行注意力操作的掩码。掩码值选择在[0, 1]
中:- 1 表示未被掩码的标记,
- 0 表示被掩码的标记。 什么是注意力掩码?
- output_hidden_states (
bool
,可选) — 是否返回最后一个隐藏状态。有关更多详细信息,请参阅返回张量中的text_model_last_hidden_state
和vision_model_last_hidden_state
。 - return_dict (
bool
,可选) — 是否返回一个 ModelOutput 而不是一个普通元组。
返回
transformers.models.owlv2.modeling_owlv2.Owlv2ObjectDetectionOutput
或 tuple(torch.FloatTensor)
一个 transformers.models.owlv2.modeling_owlv2.Owlv2ObjectDetectionOutput
或一个 torch.FloatTensor
的元组(如果传递了 return_dict=False
或当 config.return_dict=False
时),包含取决于配置(<class 'transformers.models.owlv2.configuration_owlv2.Owlv2Config'>
)和输入的各种元素。
- loss (
torch.FloatTensor
形状为(1,)
,可选,在提供labels
时返回) — 作为类预测的负对数似然(交叉熵)和边界框损失的线性组合的总损失。后者定义为 L1 损失和广义尺度不变 IoU 损失的线性组合。 - loss_dict (
Dict
,可选) — 包含各个损失的字典。用于记录。 - logits (
torch.FloatTensor
形状为(batch_size, num_patches, num_queries)
) — 所有查询的分类 logits(包括无对象)。 - objectness_logits (
torch.FloatTensor
形状为(batch_size, num_patches, 1)
) — 所有图像块的对象性 logits。OWL-ViT 将图像表示为一组图像块,其中块的总数为 (image_size / patch_size)**2。 - pred_boxes (
torch.FloatTensor
形状为(batch_size, num_patches, 4)
) — 所有查询的归一化边界框坐标,表示为 (center_x, center_y, width, height)。这些值在 [0, 1] 中归一化,相对于批次中每个单独图像的大小(不考虑可能的填充)。可以使用 post_process_object_detection() 来检索未归一化的边界框。 - text_embeds (
torch.FloatTensor
形状为(batch_size, num_max_text_queries, output_dim
) — 通过将投影层应用于 Owlv2TextModel 的池化输出获得的文本嵌入。 - image_embeds (
torch.FloatTensor
形状为(batch_size, patch_size, patch_size, output_dim
) — Owlv2VisionModel 的池化输出。OWLv2 将图像表示为一组图像块,并计算每个块的图像嵌入。 - class_embeds (
torch.FloatTensor
形状为(batch_size, num_patches, hidden_size)
) — 所有图像块的类别嵌入。OWL-ViT 将图像表示为一组图像块,其中块的总数为 (image_size / patch_size)**2。 - text_model_output (Tuple
BaseModelOutputWithPooling
) — Owlv2TextModel 的输出。 - vision_model_output (
BaseModelOutputWithPooling
) — Owlv2VisionModel 的输出。
Owlv2ForObjectDetection 的前向方法覆盖了 __call__
特殊方法。
虽然前向传递的配方需要在此函数内定义,但之后应该调用 Module
实例,而不是此函数,因为前者负责运行预处理和后处理步骤,而后者则默默地忽略它们。
示例
>>> import requests
>>> from PIL import Image
>>> import torch
>>> from transformers import AutoProcessor, Owlv2ForObjectDetection
>>> processor = AutoProcessor.from_pretrained("google/owlv2-base-patch16-ensemble")
>>> model = Owlv2ForObjectDetection.from_pretrained("google/owlv2-base-patch16-ensemble")
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> texts = [["a photo of a cat", "a photo of a dog"]]
>>> inputs = processor(text=texts, images=image, return_tensors="pt")
>>> # forward pass
>>> with torch.no_grad():
... outputs = model(**inputs)
>>> target_sizes = torch.Tensor([image.size[::-1]])
>>> # Convert outputs (bounding boxes and class logits) to final bounding boxes and scores
>>> results = processor.post_process_object_detection(
... outputs=outputs, threshold=0.2, target_sizes=target_sizes
... )
>>> i = 0 # Retrieve predictions for the first image for the corresponding text queries
>>> text = texts[i]
>>> boxes, scores, labels = results[i]["boxes"], results[i]["scores"], results[i]["labels"]
>>> for box, score, label in zip(boxes, scores, labels):
... box = [round(i, 2) for i in box.tolist()]
... print(f"Detected {text[label]} with confidence {round(score.item(), 3)} at location {box}")
Detected a photo of a cat with confidence 0.614 at location [341.67, 23.39, 642.32, 371.35]
Detected a photo of a cat with confidence 0.665 at location [6.75, 51.96, 326.62, 473.13]
图像引导检测
< 源代码 > ( pixel_values: FloatTensor query_pixel_values: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → transformers.models.owlv2.modeling_owlv2.Owlv2ImageGuidedObjectDetectionOutput
或 tuple(torch.FloatTensor)
参数
- pixel_values (
torch.FloatTensor
形状为(batch_size, num_channels, height, width)
) — 像素值。 - query_pixel_values (
torch.FloatTensor
形状为(batch_size, num_channels, height, width)
) — 要检测的查询图像的像素值。每个目标图像传递一个查询图像。 - output_attentions (
bool
,可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量中的attentions
。 - output_hidden_states (
bool
,可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量中的hidden_states
。 - return_dict (
bool
, 可选) — 是否返回一个 ModelOutput 而不是一个普通元组。
返回
transformers.models.owlv2.modeling_owlv2.Owlv2ImageGuidedObjectDetectionOutput
或 tuple(torch.FloatTensor)
一个 transformers.models.owlv2.modeling_owlv2.Owlv2ImageGuidedObjectDetectionOutput
或一个 torch.FloatTensor
的元组(如果传递了 return_dict=False
或当 config.return_dict=False
时),包含根据配置 (<class 'transformers.models.owlv2.configuration_owlv2.Owlv2Config'>
) 和输入而变化的各种元素。
- logits (
torch.FloatTensor
形状为(batch_size, num_patches, num_queries)
) — 所有查询的分类 logits(包括无对象)。 - target_pred_boxes (
torch.FloatTensor
形状为(batch_size, num_patches, 4)
) — 所有查询的归一化边界框坐标,表示为 (中心 x,中心 y,宽度,高度)。这些值在 [0, 1] 范围内归一化,相对于批次中每个目标图像的大小(不考虑可能的填充)。可以使用 post_process_object_detection() 获取未归一化的边界框。 - query_pred_boxes (
torch.FloatTensor
形状为(batch_size, num_patches, 4)
) — 所有查询的归一化边界框坐标,表示为 (中心 x,中心 y,宽度,高度)。这些值在 [0, 1] 范围内归一化,相对于批次中每个查询图像的大小(不考虑可能的填充)。可以使用 post_process_object_detection() 获取未归一化的边界框。 - image_embeds (
torch.FloatTensor
形状为(batch_size, patch_size, patch_size, output_dim
) — Owlv2VisionModel 的池化输出。OWLv2 将图像表示为一组图像块,并计算每个块的图像嵌入。 - query_image_embeds (
torch.FloatTensor
形状为(batch_size, patch_size, patch_size, output_dim
) — Owlv2VisionModel 的池化输出。OWLv2 将图像表示为一组图像块,并计算每个块的图像嵌入。 - class_embeds (
torch.FloatTensor
形状为(batch_size, num_patches, hidden_size)
) — 所有图像块的类别嵌入。OWL-ViT 将图像表示为一组图像块,其中块的总数为 (image_size / patch_size)**2。 - text_model_output (Tuple
BaseModelOutputWithPooling
) — Owlv2TextModel 的输出。 - vision_model_output (
BaseModelOutputWithPooling
) — Owlv2VisionModel 的输出。
Owlv2ForObjectDetection 的前向方法覆盖了 __call__
特殊方法。
虽然前向传递的配方需要在此函数内定义,但之后应该调用 Module
实例,而不是此函数,因为前者负责运行预处理和后处理步骤,而后者则默默地忽略它们。
示例
>>> import requests
>>> from PIL import Image
>>> import torch
>>> from transformers import AutoProcessor, Owlv2ForObjectDetection
>>> processor = AutoProcessor.from_pretrained("google/owlv2-base-patch16-ensemble")
>>> model = Owlv2ForObjectDetection.from_pretrained("google/owlv2-base-patch16-ensemble")
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> query_url = "http://images.cocodataset.org/val2017/000000001675.jpg"
>>> query_image = Image.open(requests.get(query_url, stream=True).raw)
>>> inputs = processor(images=image, query_images=query_image, return_tensors="pt")
>>> # forward pass
>>> with torch.no_grad():
... outputs = model.image_guided_detection(**inputs)
>>> target_sizes = torch.Tensor([image.size[::-1]])
>>> # Convert outputs (bounding boxes and class logits) to Pascal VOC format (xmin, ymin, xmax, ymax)
>>> results = processor.post_process_image_guided_detection(
... outputs=outputs, threshold=0.9, nms_threshold=0.3, target_sizes=target_sizes
... )
>>> i = 0 # Retrieve predictions for the first image
>>> boxes, scores = results[i]["boxes"], results[i]["scores"]
>>> for box, score in zip(boxes, scores):
... box = [round(i, 2) for i in box.tolist()]
... print(f"Detected similar object with confidence {round(score.item(), 3)} at location {box}")
Detected similar object with confidence 0.938 at location [327.31, 54.94, 547.39, 268.06]
Detected similar object with confidence 0.959 at location [5.78, 360.65, 619.12, 366.39]
Detected similar object with confidence 0.902 at location [2.85, 360.01, 627.63, 380.8]
Detected similar object with confidence 0.985 at location [176.98, -29.45, 672.69, 182.83]
Detected similar object with confidence 1.0 at location [6.53, 14.35, 624.87, 470.82]
Detected similar object with confidence 0.998 at location [579.98, 29.14, 615.49, 489.05]
Detected similar object with confidence 0.985 at location [206.15, 10.53, 247.74, 466.01]
Detected similar object with confidence 0.947 at location [18.62, 429.72, 646.5, 457.72]
Detected similar object with confidence 0.996 at location [523.88, 20.69, 586.84, 483.18]
Detected similar object with confidence 0.998 at location [3.39, 360.59, 617.29, 499.21]
Detected similar object with confidence 0.969 at location [4.47, 449.05, 614.5, 474.76]
Detected similar object with confidence 0.966 at location [31.44, 463.65, 654.66, 471.07]
Detected similar object with confidence 0.924 at location [30.93, 468.07, 635.35, 475.39]