# OWLv2 ## 概述 OWLv2 由 Matthias Minderer、Alexey Gritsenko 和 Neil Houlsby 在 [Scaling Open-Vocabulary Object Detection](https://huggingface.co/papers/2306.09683) 中提出。OWLv2 通过自训练对 [OWL-ViT](owlvit) 进行扩展，该过程利用现有检测器在图文对上生成伪框标注。这使得零样本目标检测的性能相较于此前的最先进方法有了显著提升。 该论文的摘要如下： *开放词汇目标检测已从预训练的视觉-语言模型中受益匪浅，但仍受限于可用的检测训练数据量。虽然可以利用网络图像-文本对作为弱监督来扩充检测训练数据，但这一做法尚未达到与图像级预训练相当的数据规模。在此，我们通过自训练来扩展检测数据，该方法利用现有的检测器在图像-文本对上生成伪框标注。在扩展自训练过程中，主要挑战在于标签空间的选择、伪标注的过滤以及训练效率。我们提出了 OWLv2 模型和 OWL-ST 自训练方案，以应对这些挑战。在相当的训练规模（约 1000 万样本）下，OWLv2 的性能已超越了此前最先进的开放词汇检测器。然而，借助 OWL-ST，我们可以将数据规模扩展至超过 10 亿样本，从而带来进一步的显著提升：采用 L/14 架构时，OWL-ST 将 LVIS 稀有类别上的 AP 从 31.2% 提升至 44.6%（相对提升 43%），而模型在这些类别上从未见过任何人工框标注。OWL-ST 为开放世界定位解锁了网络规模的训练，这与图像分类和语言建模领域所观察到的趋势类似。* drawing OWLv2 的高层概述。摘自原始论文。 该模型由 [nielsr](https://huggingface.co/nielsr) 贡献。原始代码可在[此处](https://github.com/google-research/scenic/tree/main/scenic/projects/owl_vit)找到。 ## 使用示例 与它的前身 [OWL-ViT](owlvit) 一样，OWLv2 是一个零样本文本条件目标检测模型。OWL-ViT 使用 [CLIP](clip) 作为其多模态骨干网络，其中采用类 ViT 的 Transformer 提取视觉特征，并采用因果语言模型提取文本特征。为了将 CLIP 用于检测，OWL-ViT 移除了视觉模型最后的 token 池化层，并为每个 Transformer 输出 token 附加了一个轻量级的分类和边界框头。通过将固定的分类层权重替换为从文本模型获得的类别名称嵌入，实现了开放词汇分类。作者首先从头训练 CLIP，然后在标准检测数据集上，使用二部图匹配损失对分类头和边界框头进行端到端的微调。可以为每张图片使用一个或多个文本查询，以执行零样本文本条件目标检测。 [Owlv2ImageProcessor](/docs/transformers/main/zh/model_doc/owlv2#transformers.Owlv2ImageProcessor) 可用于对图像进行缩放（或重新缩放）和归一化，以适配模型，而 [CLIPTokenizer](/docs/transformers/main/zh/model_doc/clip#transformers.CLIPTokenizer) 用于对文本进行编码。[Owlv2Processor](/docs/transformers/main/zh/model_doc/owlv2#transformers.Owlv2Processor) 将 [Owlv2ImageProcessor](/docs/transformers/main/zh/model_doc/owlv2#transformers.Owlv2ImageProcessor) 和 [CLIPTokenizer](/docs/transformers/main/zh/model_doc/clip#transformers.CLIPTokenizer) 封装为单一实例，同时完成文本编码和图像预处理。以下示例展示了如何使用 [Owlv2Processor](/docs/transformers/main/zh/model_doc/owlv2#transformers.Owlv2Processor) 和 [Owlv2ForObjectDetection](/docs/transformers/main/zh/model_doc/owlv2#transformers.Owlv2ForObjectDetection) 执行目标检测。 ```python 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", device_map="auto") url = "http://images.cocodataset.org/val2017/000000039769.jpg" image = Image.open(requests.get(url, stream=True).raw) text_labels = [["a photo of a cat", "a photo of a dog"]] inputs = processor(text=text_labels, images=image, return_tensors="pt").to(model.device) outputs = model(**inputs) # Target image sizes (height, width) to rescale box predictions [batch_size, 2] target_sizes = torch.tensor([(image.height, image.width)]) # Convert outputs (bounding boxes and class logits) to Pascal VOC format (xmin, ymin, xmax, ymax) results = processor.post_process_grounded_object_detection( outputs=outputs, target_sizes=target_sizes, threshold=0.1, text_labels=text_labels ) # Retrieve predictions for the first image for the corresponding text queries result = results[0] boxes, scores, text_labels = result["boxes"], result["scores"], result["text_labels"] for box, score, text_label in zip(boxes, scores, text_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 进行零样本和单样本（图像引导）目标检测的演示笔记本可在[此处](https://github.com/NielsRogge/Transformers-Tutorials/tree/master/OWLv2)找到。 - [零样本目标检测任务指南](../tasks/zero_shot_object_detection) OWLv2 的架构与 [OWL-ViT](owlvit) 完全相同，但目标检测头现在还包含一个物体性分类器，用于预测预测框中包含物体（而非背景）的可能性（与查询无关）。物体性分数可用于独立于文本查询对预测结果进行排序或过滤。OWLv2 的用法与 [OWL-ViT](owlvit) 相同，但使用了一个新的、更新后的图像处理器（[Owlv2ImageProcessor](/docs/transformers/main/zh/model_doc/owlv2#transformers.Owlv2ImageProcessor)）。 ## Owlv2Config[[transformers.Owlv2Config]] #### transformers.Owlv2Config[[transformers.Owlv2Config]] ```python transformers.Owlv2Config(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, return_dict: bool = True, text_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, vision_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, projection_dim: int = 512, logit_scale_init_value: float = 2.6592, initializer_factor: float = 1.0) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/owlv2/configuration_owlv2.py#L104) **参数：** return_dict (`bool`，*可选*，默认为 `True`)：是否返回 `ModelOutput`（dataclass）而不是普通的元组。 text_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`，*可选*)：文本骨干网络的配置对象或字典。 vision_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`，*可选*)：视觉骨干网络的配置对象或字典。 projection_dim (`int`，*可选*，默认值为 `512`)：文本和视觉投影层的维度。 logit_scale_init_value (`float`，*可选*，默认值为 `2.6592`)：*logit_scale* 参数的初始值。 initializer_factor (`float`, *可选*，默认为 `1.0`)：用于初始化所有权重矩阵的系数（应保持为 1，内部用于初始化测试）。 这是用于存储 Owlv2Model 配置的类。它根据指定的参数实例化 Owlv2 模型，并定义模型架构。使用默认值实例化配置将生成与 [google/owlv2-base-patch16](https://huggingface.co/google/owlv2-base-patch16) 类似的配置。 配置对象继承自 [PreTrainedConfig](/docs/transformers/main/zh/main_classes/configuration#transformers.PreTrainedConfig)，可用于控制模型输出。有关更多信息，请参阅 [PreTrainedConfig](/docs/transformers/main/zh/main_classes/configuration#transformers.PreTrainedConfig) 的文档。 ## Owlv2TextConfig[[transformers.Owlv2TextConfig]] #### transformers.Owlv2TextConfig[[transformers.Owlv2TextConfig]] ```python transformers.Owlv2TextConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vocab_size: int = 49408, hidden_size: int = 512, intermediate_size: int = 2048, num_hidden_layers: int = 12, num_attention_heads: int = 8, max_position_embeddings: int = 16, hidden_act: str = 'quick_gelu', layer_norm_eps: float = 1e-05, attention_dropout: float | int = 0.0, initializer_range: float = 0.02, initializer_factor: float = 1.0, pad_token_id: int | None = 0, bos_token_id: int | None = 49406, eos_token_id: int | list[int] | None = 49407) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/owlv2/configuration_owlv2.py#L28) **参数：** vocab_size (`int`，*可选*，默认值为 `49408`)：模型的词汇表大小。定义了 `input_ids` 可以表示的不同 token 数量。 hidden_size (`int`，*可选*，默认为 `512`)：隐藏表示的维度。 intermediate_size (`int`，*可选*，默认为 `2048`)：MLP 表示的维度。 num_hidden_layers (`int`，*可选*，默认为 `12`)：Transformer 解码器中的隐藏层数。 num_attention_heads (`int`，*可选*，默认为 `8`)：Transformer 解码器中每个注意力层的注意力头数量。 max_position_embeddings (`int`，*可选*，默认为 `16`)：该模型可能使用的最大序列长度。 hidden_act (`str`，*可选*，默认为 `quick_gelu`)：解码器中的非线性激活函数（函数或字符串）。例如，`"gelu"`、`"relu"`、`"silu"` 等。 layer_norm_eps (`float`，*可选*，默认为 `1e-05`)：层归一化层所使用的 epsilon。 attention_dropout (`Union[float, int]`，*可选*，默认值为 `0.0`)：注意力概率的 dropout 比率。 initializer_range (`float`，*可选*，默认值为 `0.02`)：用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。 initializer_factor (`float`, *可选*，默认为 `1.0`)：用于初始化所有权重矩阵的系数（应保持为 1，内部用于初始化测试）。 pad_token_id (`int`，*可选*，默认为 `0`)：词表中用于填充的 Token ID。 bos_token_id (`int`，*可选*，默认为 `49406`)：词汇表中用于表示流开始的 Token ID。 eos_token_id (`Union[int, list[int]]`，*可选*，默认为 `49407`)：词汇表中用于表示流结束（end-of-stream）的 Token ID。 这是用于存储 Owlv2Model 配置的类。它根据指定的参数实例化 Owlv2 模型，并定义模型架构。使用默认值实例化配置将生成与 [google/owlv2-base-patch16](https://huggingface.co/google/owlv2-base-patch16) 类似的配置。 配置对象继承自 [PreTrainedConfig](/docs/transformers/main/zh/main_classes/configuration#transformers.PreTrainedConfig)，可用于控制模型输出。有关更多信息，请参阅 [PreTrainedConfig](/docs/transformers/main/zh/main_classes/configuration#transformers.PreTrainedConfig) 的文档。 示例： ```python >>> 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]] #### transformers.Owlv2VisionConfig[[transformers.Owlv2VisionConfig]] ```python transformers.Owlv2VisionConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, hidden_size: int = 768, intermediate_size: int = 3072, num_hidden_layers: int = 12, num_attention_heads: int = 12, num_channels: int = 3, image_size: int | list[int] | tuple[int, int] = 768, patch_size: int | list[int] | tuple[int, int] = 16, hidden_act: str = 'quick_gelu', layer_norm_eps: float = 1e-05, attention_dropout: float | int = 0.0, initializer_range: float = 0.02, initializer_factor: float = 1.0) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/owlv2/configuration_owlv2.py#L67) **参数：** hidden_size (`int`，*可选*，默认为 `768`)：隐藏表示的维度。 intermediate_size (`int`，*可选*，默认值为 `3072`)：MLP 表示的维度。 num_hidden_layers (`int`，*可选*，默认为 `12`)：Transformer 解码器中的隐藏层数。 num_attention_heads (`int`，*可选*，默认为 `12`)：Transformer 解码器中每个注意力层的注意力头数量。 num_channels (`int`，*可选*，默认为 `3`)：输入通道数。 image_size (`Union[int, list[int], tuple[int, int]]`，*可选*，默认为 `768`)：每张图片的尺寸（分辨率）。 patch_size (`Union[int, list[int], tuple[int, int]]`，*可选*，默认为 `16`)：每个 patch 的大小（分辨率）。 hidden_act (`str`，*可选*，默认为 `quick_gelu`)：解码器中的非线性激活函数（函数或字符串）。例如，`"gelu"`、`"relu"`、`"silu"` 等。 layer_norm_eps (`float`，*可选*，默认为 `1e-05`)：层归一化层所使用的 epsilon。 attention_dropout (`Union[float, int]`，*可选*，默认值为 `0.0`)：注意力概率的 dropout 比率。 initializer_range (`float`，*可选*，默认值为 `0.02`)：用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。 initializer_factor (`float`, *可选*，默认为 `1.0`)：用于初始化所有权重矩阵的系数（应保持为 1，内部用于初始化测试）。 这是用于存储 Owlv2Model 配置的类。它根据指定的参数实例化 Owlv2 模型，并定义模型架构。使用默认值实例化配置将生成与 [google/owlv2-base-patch16](https://huggingface.co/google/owlv2-base-patch16) 类似的配置。 配置对象继承自 [PreTrainedConfig](/docs/transformers/main/zh/main_classes/configuration#transformers.PreTrainedConfig)，可用于控制模型输出。有关更多信息，请参阅 [PreTrainedConfig](/docs/transformers/main/zh/main_classes/configuration#transformers.PreTrainedConfig) 的文档。 示例： ```python >>> 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]] #### transformers.Owlv2ImageProcessor[[transformers.Owlv2ImageProcessor]] ```python transformers.Owlv2ImageProcessor(**kwargs: *) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/owlv2/image_processing_owlv2.py#L110) **参数：** do_convert_rgb (`bool`，*kwargs*，*可选*，默认为 `True`)：是否将图像转换为 RGB。 do_resize (`bool`, *kwargs*, *可选*, 默认为 `True`) : 是否调整图像大小。 size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*，默认为 `{'height' : 960, 'width': 960}`)：描述输入到模型的最大尺寸。 default_to_square (`bool`，*kwargs*，*可选*，默认为 `True`)：当 size 为整数时，是否在调整大小时默认使用正方形图像。 crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*，默认为 `None`) : 应用 `center_crop` 后输出图像的尺寸。 resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*，默认为 `2`) : 如果调整图像大小，则使用的重采样滤波器。它可以是枚举 `PILImageResampling` 中的一个值。仅当 `do_resize` 设置为 `True` 时才会生效。 do_rescale (`bool`, *kwargs*, *可选*，默认为 `True`)：是否对图像进行重新缩放。 rescale_factor (`float`, *kwargs*, *可选*，默认为 `0.00392156862745098`) : 当 `do_rescale` 设置为 `True` 时，用于对图像进行缩放的缩放因子。 do_normalize (`bool`，*kwargs*，*可选*，默认为 `True`)：是否对图像进行归一化。 image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *可选*，默认为 `[0.48145466, 0.4578275, 0.40821073]`) : 用于归一化的图像均值。仅当 `do_normalize` 设置为 `True` 时生效。 image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *可选*，默认为 `[0.26862954, 0.26130258, 0.27577711]`) : 用于归一化的图像标准差。仅当 `do_normalize` 设置为 `True` 时生效。 do_pad (`bool`, *kwargs*, *可选*，默认为 `True`) : 是否对图像进行填充。填充操作会将图像填充至批次中的最大尺寸，或填充至每张图像的固定正方形尺寸。具体的填充策略取决于模型。 pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : 用于将图像填充到的尺寸，格式为 `{"height": int, "width" int}`。该尺寸必须大于预处理中提供的任何图像尺寸。如果未提供 `pad_size`，图像将被填充到批次中最大的高度和宽度。仅在 `do_pad=True.` 时应用。 do_center_crop (`bool`, *kwargs*, *可选*，默认为 `None`) : 是否对图像进行居中裁剪。 data_format (`Union[str, ~image_utils.ChannelDimension]`，*kwargs*，*可选*)：仅支持 `ChannelDimension.FIRST`。为兼容旧版处理器而添加。 input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *可选*) : 输入图像的通道维度格式。如果未设置，则从输入图像中推断通道维度格式。可以是以下之一： - `"channels_first"` 或 `ChannelDimension.FIRST`：图像为 (num_channels, height, width) 格式。 - `"channels_last"` 或 `ChannelDimension.LAST`：图像为 (height, width, num_channels) 格式。 - `"none"` 或 `ChannelDimension.NONE`：图像为 (height, width) 格式。 device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*)：用于处理视频的设备。如果未设置，则从输入视频中推断设备。 return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : 如果设置为 `'pt'`，则返回堆叠的张量，否则返回张量列表。 disable_grouping (`bool`, *kwargs*, *可选*) : 是否禁用按尺寸对图像进行分组，从而逐个处理图像而非批量处理。如果为 None，则当图像位于 CPU 上时设置为 True，否则设置为 False。此选择基于经验观察，详见此处：https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *可选*) : 输入中每张图片所使用的图像 token 数量。为向后兼容而添加，但在未来的模型中，应将其设置为处理器的属性。 构建一个 Owlv2ImageProcessor 图像处理器。 #### preprocess[[transformers.Owlv2ImageProcessor.preprocess]] ```python preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], *args, image_like_kwargs: dict[str, typing.Any] | None = None, **kwargs: *) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_utils.py#L382) **参数：** 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`。 image_like_kwargs (`dict[str, Any]`，*可选*)：用于额外图像类输入的开发者标志，这些输入也将被预处理。仅在以关键字参数传递输入不起作用时使用此标志。例如，`preprocess(images, masks=masks)` 是首选方式，但对于某些模型会导致参数优先级问题。在这种情况下，可以改用 `preprocess(images, image_like_inputs={"masks": masks})`。 do_convert_rgb (`bool`, *kwargs*, *可选*) : 是否将图像转换为 RGB。 do_resize (`bool`，*kwargs*，*可选*)：是否调整图像大小。 size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*)：描述模型的最大输入维度。 default_to_square (`bool`, *kwargs*, *可选*) : 当 size 为 int 时，是否在调整大小时默认使用正方形图像。 crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : 应用 `center_crop` 后输出图像的尺寸。 resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : 如果调整图像大小，则使用的重采样滤波器。它可以是枚举 `PILImageResampling` 中的一个值。仅当 `do_resize` 设置为 `True` 时才会生效。 do_rescale (`bool`, *kwargs*, *可选*) : 是否对图像进行重新缩放。 rescale_factor (`float`, *kwargs*, *可选*) : 当 `do_rescale` 设置为 `True` 时，用于对图像进行缩放的缩放因子。 do_normalize (`bool`, *kwargs*, *可选*) : 是否对图像进行归一化。 image_mean (`Union[float, list[float], tuple[float, ...]]`，*kwargs*，*可选*)：用于归一化的图像均值。仅当 `do_normalize` 设置为 `True` 时生效。 image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *可选*) : 用于归一化的图像标准差。仅当 `do_normalize` 设置为 `True` 时生效。 do_pad (`bool`, *kwargs*, *可选*) : 是否对图像进行填充。填充操作会将图像填充至批次中的最大尺寸，或填充至每张图像的固定正方形尺寸。具体的填充策略取决于模型。 pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : 用于将图像填充到的尺寸，格式为 `{"height": int, "width" int}`。该尺寸必须大于预处理中提供的任何图像尺寸。如果未提供 `pad_size`，图像将被填充到批次中最大的高度和宽度。仅在 `do_pad=True.` 时应用。 do_center_crop (`bool`, *kwargs*, *可选*) : 是否对图像进行居中裁剪。 data_format (`Union[str, ~image_utils.ChannelDimension]`，*kwargs*，*可选*)：仅支持 `ChannelDimension.FIRST`。为兼容旧版处理器而添加。 input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *可选*) : 输入图像的通道维度格式。如果未设置，则从输入图像中推断通道维度格式。可以是以下之一： - `"channels_first"` 或 `ChannelDimension.FIRST`：图像为 (num_channels, height, width) 格式。 - `"channels_last"` 或 `ChannelDimension.LAST`：图像为 (height, width, num_channels) 格式。 - `"none"` 或 `ChannelDimension.NONE`：图像为 (height, width) 格式。 device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*)：用于处理视频的设备。如果未设置，则从输入视频中推断设备。 return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : 如果设置为 `'pt'`，则返回堆叠的张量，否则返回张量列表。 disable_grouping (`bool`, *kwargs*, *可选*) : 是否禁用按尺寸对图像进行分组，从而逐个处理图像而非批量处理。如果为 None，则当图像位于 CPU 上时设置为 True，否则设置为 False。此选择基于经验观察，详见此处：https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *可选*) : 输入中每张图片所使用的图像 token 数量。为向后兼容而添加，但在未来的模型中，应将其设置为处理器的属性。 **返回：** `~image_processing_base.BatchFeature` - **data** (`dict`) -- 由 __call__ 方法返回的列表/数组/张量字典（例如 'pixel_values'）。 - **tensor_type** (`Union[None, str, TensorType]`，*可选*) -- 您可以在此处指定 tensor_type，以便在初始化时将 PyTorch/Numpy 张量中的整数列表进行转换。 预处理一张图像或一批图像。 #### post_process_object_detection[[transformers.Owlv2ImageProcessor.post_process_object_detection]] ```python post_process_object_detection(outputs: Owlv2ObjectDetectionOutput, threshold: float = 0.1, target_sizes: transformers.utils.generic.TensorType | list[tuple] | None = None) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/owlv2/image_processing_owlv2.py#L136) **参数：** outputs (`Owlv2ObjectDetectionOutput`)：模型的原始输出。 threshold (`float`, *可选*，默认为 0.1)：用于保留目标检测预测结果的分数阈值。 target_sizes (`torch.Tensor` 或 `list[tuple[int, int]]`，*可选*)：形状为 `(batch_size, 2)` 的张量，或包含元组（`tuple[int, int]`）的列表，其中包含批处理中每张图片的目标尺寸 `(height, width)`。如果未设置，预测结果将不会被调整大小。 **返回：** `list[Dict]` 一个字典列表，每个字典包含以下键： - ：图像上每个预测框的置信度分数。 - "labels": 模型在图像上预测的类别索引。 - "boxes": 图像边界框，格式为 (top_left_x, top_left_y, bottom_right_x, bottom_right_y)。 将 [Owlv2ForObjectDetection](/docs/transformers/main/zh/model_doc/owlv2#transformers.Owlv2ForObjectDetection) 的原始输出转换为 (top_left_x, top_left_y, bottom_right_x, bottom_right_y) 格式的最终边界框。 #### post_process_image_guided_detection[[transformers.Owlv2ImageProcessor.post_process_image_guided_detection]] ```python post_process_image_guided_detection(outputs, threshold = 0.0, nms_threshold = 0.3, target_sizes = None) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/owlv2/image_processing_owlv2.py#L189) **参数：** outputs (`Owlv2ImageGuidedObjectDetectionOutput`)：模型的原始输出。 threshold (`float`, *可选*，默认为 0.0)：用于过滤预测框的最小置信度阈值。 nms_threshold (`float`, *可选*, 默认值为 0.3) : 用于对重叠框进行非极大值抑制的 IoU 阈值。 target_sizes (`torch.Tensor`, *可选*) : 形状为 (batch_size, 2) 的张量，其中每个条目是对应批次中图像的 (height, width)。如果设置，预测的归一化边界框将重新缩放到目标尺寸。如果保持为 None，预测值将不会进行反归一化。 **返回：** `list[Dict]` 一个字典列表，每个字典包含模型对批次中某张图像预测的分数、标签和边界框。由于`Owlv2ForObjectDetection.image_guided_detection`执行单镜头目标检测，所有标签均被设置为 None。 将 [Owlv2ForObjectDetection.image_guided_detection()](/docs/transformers/main/zh/model_doc/owlv2#transformers.Owlv2ForObjectDetection.image_guided_detection) 的输出转换为 COCO api 所期望的格式。 ## Owlv2ImageProcessorPil[[transformers.Owlv2ImageProcessorPil]] #### transformers.Owlv2ImageProcessorPil[[transformers.Owlv2ImageProcessorPil]] ```python transformers.Owlv2ImageProcessorPil(**kwargs: *) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/owlv2/image_processing_pil_owlv2.py#L190) **参数：** do_convert_rgb (`bool`，*kwargs*，*可选*，默认为 `True`)：是否将图像转换为 RGB。 do_resize (`bool`, *kwargs*, *可选*, 默认为 `True`) : 是否调整图像大小。 size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*，默认为 `{'height' : 960, 'width': 960}`)：描述输入到模型的最大尺寸。 default_to_square (`bool`，*kwargs*，*可选*，默认为 `True`)：当 size 为整数时，是否在调整大小时默认使用正方形图像。 crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*，默认为 `None`) : 应用 `center_crop` 后输出图像的尺寸。 resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*，默认为 `2`) : 如果调整图像大小，则使用的重采样滤波器。它可以是枚举 `PILImageResampling` 中的一个值。仅当 `do_resize` 设置为 `True` 时才会生效。 do_rescale (`bool`, *kwargs*, *可选*，默认为 `True`)：是否对图像进行重新缩放。 rescale_factor (`float`, *kwargs*, *可选*，默认为 `0.00392156862745098`) : 当 `do_rescale` 设置为 `True` 时，用于对图像进行缩放的缩放因子。 do_normalize (`bool`，*kwargs*，*可选*，默认为 `True`)：是否对图像进行归一化。 image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *可选*，默认为 `[0.48145466, 0.4578275, 0.40821073]`) : 用于归一化的图像均值。仅当 `do_normalize` 设置为 `True` 时生效。 image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *可选*，默认为 `[0.26862954, 0.26130258, 0.27577711]`) : 用于归一化的图像标准差。仅当 `do_normalize` 设置为 `True` 时生效。 do_pad (`bool`, *kwargs*, *可选*，默认为 `True`) : 是否对图像进行填充。填充操作会将图像填充至批次中的最大尺寸，或填充至每张图像的固定正方形尺寸。具体的填充策略取决于模型。 pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : 用于将图像填充到的尺寸，格式为 `{"height": int, "width" int}`。该尺寸必须大于预处理中提供的任何图像尺寸。如果未提供 `pad_size`，图像将被填充到批次中最大的高度和宽度。仅在 `do_pad=True.` 时应用。 do_center_crop (`bool`, *kwargs*, *可选*，默认为 `None`) : 是否对图像进行居中裁剪。 data_format (`Union[str, ~image_utils.ChannelDimension]`，*kwargs*，*可选*)：仅支持 `ChannelDimension.FIRST`。为兼容旧版处理器而添加。 input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *可选*) : 输入图像的通道维度格式。如果未设置，则从输入图像中推断通道维度格式。可以是以下之一： - `"channels_first"` 或 `ChannelDimension.FIRST`：图像为 (num_channels, height, width) 格式。 - `"channels_last"` 或 `ChannelDimension.LAST`：图像为 (height, width, num_channels) 格式。 - `"none"` 或 `ChannelDimension.NONE`：图像为 (height, width) 格式。 device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*)：用于处理视频的设备。如果未设置，则从输入视频中推断设备。 return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : 如果设置为 `'pt'`，则返回堆叠的张量，否则返回张量列表。 disable_grouping (`bool`, *kwargs*, *可选*) : 是否禁用按尺寸对图像进行分组，从而逐个处理图像而非批量处理。如果为 None，则当图像位于 CPU 上时设置为 True，否则设置为 False。此选择基于经验观察，详见此处：https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *可选*) : 输入中每张图片所使用的图像 token 数量。为向后兼容而添加，但在未来的模型中，应将其设置为处理器的属性。 构建一个 Owlv2ImageProcessor 图像处理器。 #### preprocess[[transformers.Owlv2ImageProcessorPil.preprocess]] ```python preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], *args, image_like_kwargs: dict[str, typing.Any] | None = None, **kwargs: *) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_utils.py#L382) **参数：** 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`。 image_like_kwargs (`dict[str, Any]`，*可选*)：用于额外图像类输入的开发者标志，这些输入也将被预处理。仅在以关键字参数传递输入不起作用时使用此标志。例如，`preprocess(images, masks=masks)` 是首选方式，但对于某些模型会导致参数优先级问题。在这种情况下，可以改用 `preprocess(images, image_like_inputs={"masks": masks})`。 do_convert_rgb (`bool`, *kwargs*, *可选*) : 是否将图像转换为 RGB。 do_resize (`bool`，*kwargs*，*可选*)：是否调整图像大小。 size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*)：描述模型的最大输入维度。 default_to_square (`bool`, *kwargs*, *可选*) : 当 size 为 int 时，是否在调整大小时默认使用正方形图像。 crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : 应用 `center_crop` 后输出图像的尺寸。 resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : 如果调整图像大小，则使用的重采样滤波器。它可以是枚举 `PILImageResampling` 中的一个值。仅当 `do_resize` 设置为 `True` 时才会生效。 do_rescale (`bool`, *kwargs*, *可选*) : 是否对图像进行重新缩放。 rescale_factor (`float`, *kwargs*, *可选*) : 当 `do_rescale` 设置为 `True` 时，用于对图像进行缩放的缩放因子。 do_normalize (`bool`, *kwargs*, *可选*) : 是否对图像进行归一化。 image_mean (`Union[float, list[float], tuple[float, ...]]`，*kwargs*，*可选*)：用于归一化的图像均值。仅当 `do_normalize` 设置为 `True` 时生效。 image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *可选*) : 用于归一化的图像标准差。仅当 `do_normalize` 设置为 `True` 时生效。 do_pad (`bool`, *kwargs*, *可选*) : 是否对图像进行填充。填充操作会将图像填充至批次中的最大尺寸，或填充至每张图像的固定正方形尺寸。具体的填充策略取决于模型。 pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : 用于将图像填充到的尺寸，格式为 `{"height": int, "width" int}`。该尺寸必须大于预处理中提供的任何图像尺寸。如果未提供 `pad_size`，图像将被填充到批次中最大的高度和宽度。仅在 `do_pad=True.` 时应用。 do_center_crop (`bool`, *kwargs*, *可选*) : 是否对图像进行居中裁剪。 data_format (`Union[str, ~image_utils.ChannelDimension]`，*kwargs*，*可选*)：仅支持 `ChannelDimension.FIRST`。为兼容旧版处理器而添加。 input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *可选*) : 输入图像的通道维度格式。如果未设置，则从输入图像中推断通道维度格式。可以是以下之一： - `"channels_first"` 或 `ChannelDimension.FIRST`：图像为 (num_channels, height, width) 格式。 - `"channels_last"` 或 `ChannelDimension.LAST`：图像为 (height, width, num_channels) 格式。 - `"none"` 或 `ChannelDimension.NONE`：图像为 (height, width) 格式。 device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*)：用于处理视频的设备。如果未设置，则从输入视频中推断设备。 return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : 如果设置为 `'pt'`，则返回堆叠的张量，否则返回张量列表。 disable_grouping (`bool`, *kwargs*, *可选*) : 是否禁用按尺寸对图像进行分组，从而逐个处理图像而非批量处理。如果为 None，则当图像位于 CPU 上时设置为 True，否则设置为 False。此选择基于经验观察，详见此处：https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *可选*) : 输入中每张图片所使用的图像 token 数量。为向后兼容而添加，但在未来的模型中，应将其设置为处理器的属性。 **返回：** `~image_processing_base.BatchFeature` - **data** (`dict`) -- 由 __call__ 方法返回的列表/数组/张量字典（例如 'pixel_values'）。 - **tensor_type** (`Union[None, str, TensorType]`，*可选*) -- 您可以在此处指定 tensor_type，以便在初始化时将 PyTorch/Numpy 张量中的整数列表进行转换。 预处理一张图像或一批图像。 #### post_process_object_detection[[transformers.Owlv2ImageProcessorPil.post_process_object_detection]] ```python post_process_object_detection(outputs: Owlv2ObjectDetectionOutput, threshold: float = 0.1, target_sizes: transformers.utils.generic.TensorType | list[tuple] | None = None) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/owlv2/image_processing_pil_owlv2.py#L216) **参数：** outputs (`Owlv2ObjectDetectionOutput`)：模型的原始输出。 threshold (`float`, *可选*，默认为 0.1)：用于保留目标检测预测结果的分数阈值。 target_sizes (`torch.Tensor` 或 `list[tuple[int, int]]`，*可选*)：形状为 `(batch_size, 2)` 的张量，或包含元组（`tuple[int, int]`）的列表，其中包含批处理中每张图片的目标尺寸 `(height, width)`。如果未设置，预测结果将不会被调整大小。 **返回：** `list[Dict]` 一个字典列表，每个字典包含以下键： - ：图像上每个预测框的置信度分数。 - "labels": 模型在图像上预测的类别索引。 - "boxes": 图像边界框，格式为 (top_left_x, top_left_y, bottom_right_x, bottom_right_y)。 将 [Owlv2ForObjectDetection](/docs/transformers/main/zh/model_doc/owlv2#transformers.Owlv2ForObjectDetection) 的原始输出转换为 (top_left_x, top_left_y, bottom_right_x, bottom_right_y) 格式的最终边界框。 #### post_process_image_guided_detection[[transformers.Owlv2ImageProcessorPil.post_process_image_guided_detection]] ```python post_process_image_guided_detection(outputs, threshold = 0.0, nms_threshold = 0.3, target_sizes = None) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/owlv2/image_processing_pil_owlv2.py#L272) **参数：** outputs (`Owlv2ImageGuidedObjectDetectionOutput`)：模型的原始输出。 threshold (`float`, *可选*，默认为 0.0)：用于过滤预测框的最小置信度阈值。 nms_threshold (`float`, *可选*, 默认值为 0.3) : 用于对重叠框进行非极大值抑制的 IoU 阈值。 target_sizes (`torch.Tensor`, *可选*) : 形状为 (batch_size, 2) 的张量，其中每个条目是对应批次中图像的 (height, width)。如果设置，预测的归一化边界框将重新缩放到目标尺寸。如果保持为 None，预测值将不会进行反归一化。 **返回：** `list[Dict]` 一个字典列表，每个字典包含模型对批次中某张图像预测的分数、标签和边界框。由于`Owlv2ForObjectDetection.image_guided_detection`执行单镜头目标检测，所有标签均被设置为 None。 将 [Owlv2ForObjectDetection.image_guided_detection()](/docs/transformers/main/zh/model_doc/owlv2#transformers.Owlv2ForObjectDetection.image_guided_detection) 的输出转换为 COCO api 所期望的格式。 ## Owlv2Processor[[transformers.Owlv2Processor]] #### transformers.Owlv2Processor[[transformers.Owlv2Processor]] ```python transformers.Owlv2Processor(image_processor, tokenizer, **kwargs) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/owlv2/processing_owlv2.py#L62) **参数：** image_processor (`Owlv2ImageProcessor`)：图像处理器是必需的输入。 tokenizer (`CLIPTokenizer`)：分词器是必需的输入。 构造一个 Owlv2Processor，将图像处理器和分词器封装为单一处理器。 [Owlv2Processor](/docs/transformers/main/zh/model_doc/owlv2#transformers.Owlv2Processor) 提供了 [Owlv2ImageProcessor](/docs/transformers/main/zh/model_doc/owlv2#transformers.Owlv2ImageProcessor) 和 [CLIPTokenizer](/docs/transformers/main/zh/model_doc/clip#transformers.CLIPTokenizer) 的所有功能。有关更多信息，请参阅 [~Owlv2ImageProcessor](/docs/transformers/main/zh/model_doc/owlv2#transformers.Owlv2ImageProcessor) 和 [~CLIPTokenizer](/docs/transformers/main/zh/model_doc/clip#transformers.CLIPTokenizer)。 #### __调用__[[transformers.Owlv2Processor.__call__]] ```python __call__(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None, text: str | list[str] | list[list[str]] = None, **kwargs: *) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/owlv2/processing_owlv2.py#L68) **参数：** 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`。 text (`Union[str, list[str], list[list[str]]]`，*可选*)：要编码的序列或序列批次。每个序列可以是字符串或字符串列表（预分词字符串）。如果传入预分词输入，请设置 `is_split_into_words=True` 以避免与批量输入产生歧义。 query_images (`ImageInput`, *kwargs*, *可选*) : 用于图像引导目标检测的查询图像。提供时，这些图像将作为视觉查询，用于在主 `images` 中查找相似的对象。查询图像会覆盖任何文本提示，模型将执行图像到图像的匹配，而不是文本到图像的匹配。 return_tensors (`str` 或 [TensorType](/docs/transformers/main/zh/internal/file_utils#transformers.TensorType)，*可选*)：如果设置，将返回特定框架的张量。可接受的值为： - `'pt'`：返回 PyTorch `torch.Tensor` 对象。 - `'np'`：返回 NumPy `np.ndarray` 对象。 - ****kwargs** ([ProcessingKwargs](/docs/transformers/main/zh/main_classes/processors#transformers.ProcessingKwargs), *可选*) : 针对每种模态（文本、图像、视频、音频）的额外处理选项。模型特定参数已在上方列出；有关支持参数的完整列表，请参阅 TypedDict 类。 **返回：** [BatchFeature](/docs/transformers/main/zh/main_classes/feature_extractor#transformers.BatchFeature) 一个包含以下字段的 [BatchFeature](/docs/transformers/main/zh/main_classes/feature_extractor#transformers.BatchFeature)： - **input_ids** -- 要输入模型的 token id 列表。当 `text` 不为 `None` 时返回。 - **attention_mask** -- 指定模型应关注哪些 token 的索引列表（当 `return_attention_mask=True` 时，或当 *"attention_mask"* 位于 `self.model_input_names` 中且 `text` 不为 `None` 时）。 - **pixel_values** -- 输入模型的像素值。当 `images` 不为 `None` 时返回。 - **query_pixel_values** -- 输入模型的查询图像的像素值。当 `query_images` 不为 `None` 时返回。 #### post_process_grounded_object_detection[[transformers.Owlv2Processor.post_process_grounded_object_detection]] ```python post_process_grounded_object_detection(outputs: Owlv2ObjectDetectionOutput, threshold: float = 0.1, target_sizes: transformers.utils.generic.TensorType | list[tuple] | None = None, text_labels: list[list[str]] | None = None) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/owlv2/processing_owlv2.py#L146) **参数：** outputs (`Owlv2ObjectDetectionOutput`)：模型的原始输出。 threshold (`float`, *可选*，默认为 0.1)：用于保留目标检测预测结果的分数阈值。 target_sizes (`torch.Tensor` 或 `list[tuple[int, int]]`，*可选*)：形状为 `(batch_size, 2)` 的张量，或包含元组（`tuple[int, int]`）的列表，其中包含批处理中每张图片的目标尺寸 `(height, width)`。如果未设置，预测结果将不会被调整大小。 text_labels (`list[list[str]]`，*可选*)：批处理中每张图片的文本标签列表。如果未设置，输出中的 "text_labels" 将被设置为 `None`。 **返回：** `list[Dict]` 一个字典列表，每个字典包含以下键： - ：图像上每个预测框的置信度分数。 - "labels": 模型在图像上预测的类别索引。 - "boxes": 图像边界框，格式为 (top_left_x, top_left_y, bottom_right_x, bottom_right_y)。 - "text_labels"：图像上每个预测边界框的文本标签。 将 [Owlv2ForObjectDetection](/docs/transformers/main/zh/model_doc/owlv2#transformers.Owlv2ForObjectDetection) 的原始输出转换为 (top_left_x, top_left_y, bottom_right_x, bottom_right_y) 格式的最终边界框。 #### post_process_image_guided_detection[[transformers.Owlv2Processor.post_process_image_guided_detection]] ```python post_process_image_guided_detection(outputs: Owlv2ImageGuidedObjectDetectionOutput, threshold: float = 0.0, nms_threshold: float = 0.3, target_sizes: transformers.utils.generic.TensorType | list[tuple] | None = None) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/owlv2/processing_owlv2.py#L195) **参数：** outputs (`Owlv2ImageGuidedObjectDetectionOutput`)：模型的原始输出。 threshold (`float`, *可选*，默认为 0.0)：用于过滤预测框的最小置信度阈值。 nms_threshold (`float`, *可选*, 默认值为 0.3) : 用于对重叠框进行非极大值抑制的 IoU 阈值。 target_sizes (`torch.Tensor`, *可选*) : 形状为 (batch_size, 2) 的张量，其中每个条目是对应批次中图像的 (height, width)。如果设置，预测的归一化边界框将重新缩放到目标尺寸。如果保持为 None，预测值将不会进行反归一化。 **返回：** `list[Dict]` 一个字典列表，每个字典包含以下键： - ：图像上每个预测框的置信度分数。 - "boxes": 图像边界框，格式为 (top_left_x, top_left_y, bottom_right_x, bottom_right_y)。 - "labels"：设置为 `None`。 将 [Owlv2ForObjectDetection.image_guided_detection()](/docs/transformers/main/zh/model_doc/owlv2#transformers.Owlv2ForObjectDetection.image_guided_detection) 的输出转换为 COCO api 所期望的格式。 ## Owlv2Model[[transformers.Owlv2Model]] #### transformers.Owlv2Model[[transformers.Owlv2Model]] ```python transformers.Owlv2Model(config: Owlv2Config) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/owlv2/modeling_owlv2.py#L758) **参数：** config ([Owlv2Config](/docs/transformers/main/zh/model_doc/owlv2#transformers.Owlv2Config))：模型配置类，包含模型的所有参数。通过配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 [from_pretrained()](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel.from_pretrained) 方法以加载模型权重。 未添加任何特定头部的裸 Owlv2 模型，输出原始隐藏状态。 该模型继承自 [PreTrainedModel](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel)。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。 该模型也是 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) 的子类。请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。 #### forward[[transformers.Owlv2Model.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, pixel_values: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, return_loss: bool | None = None, interpolate_pos_encoding: bool = False, return_base_image_embeds: bool | None = None, **kwargs: *) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/owlv2/modeling_owlv2.py#L852) **参数：** input_ids (`torch.LongTensor`，形状为 `(batch_size, sequence_length)`，*可选*)：输入序列中 token 在词汇表中的索引。默认情况下，填充（padding）将被忽略。可以使用 [AutoTokenizer](/docs/transformers/main/zh/model_doc/auto#transformers.AutoTokenizer) 获取索引。有关详细信息，请参阅 [PreTrainedTokenizer.encode()](/docs/transformers/main/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 和 [PreTrainedTokenizer.__call__()](/docs/transformers/main/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)。[什么是输入 ID？](../glossary#input-ids) pixel_values (`torch.Tensor`，形状为 `(batch_size, num_channels, image_size, image_size)`，*可选*) : 与输入图像对应的张量。可以使用 [Owlv2ImageProcessor](/docs/transformers/main/zh/model_doc/owlv2#transformers.Owlv2ImageProcessor) 获取像素值。有关详细信息，请参阅 [Owlv2ImageProcessor.__call__()](/docs/transformers/main/zh/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__)（[Owlv2Processor](/docs/transformers/main/zh/model_doc/owlv2#transformers.Owlv2Processor) 使用 [Owlv2ImageProcessor](/docs/transformers/main/zh/model_doc/owlv2#transformers.Owlv2ImageProcessor) 处理图像）。 attention_mask (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值取自 `[0, 1]`： - 1 表示**未掩码**的标记， - 0 表示**已掩码**的标记。 [什么是注意力掩码？](../glossary#attention-mask) return_loss (`bool`, *可选*) : 是否返回对比损失。 interpolate_pos_encoding (`bool`，*可选*，默认为 `False`)：是否对预训练的位置编码进行插值。 return_base_image_embeds (`bool`, *可选*) : 是否返回基础图像嵌入。 **返回：** `Owlv2Output` 或 `tuple(torch.Tensor)` `Owlv2Output` 或 `torch.Tensor` 元组（如果传入 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[Owlv2Config](/docs/transformers/main/zh/model_doc/owlv2#transformers.Owlv2Config)）和输入。 [Owlv2Model](/docs/transformers/main/zh/model_doc/owlv2#transformers.Owlv2Model) 的 forward 方法会重写 `__call__` 特殊方法。 尽管前向传播的实现需要在此函数中定义，但之后应调用 `Module` 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者会静默地忽略这些步骤。 - **loss** (`torch.Tensor`，形状为 `(1,)`，*可选*，当 `return_loss` 为 `True` 时返回) -- 用于图像-文本相似度的对比损失。 - **logits_per_image**（形状为 `(image_batch_size, text_batch_size)` 的 `torch.Tensor`）-- `image_embeds` 与 `text_embeds` 之间的缩放点积分数。这表示图像-文本相似度分数。 - **logits_per_text**（形状为 `(text_batch_size, image_batch_size)` 的 `torch.Tensor`）-- `text_embeds` 与 `image_embeds` 之间的缩放点积分数。这表示文本-图像相似度分数。 - **text_embeds**（形状为 `(batch_size * num_max_text_queries, output_dim` 的 `torch.Tensor`）-- 通过对 [Owlv2TextModel](/docs/transformers/main/zh/model_doc/owlv2#transformers.Owlv2TextModel) 的池化输出应用投影层获得的文本嵌入。 - **image_embeds** (`torch.Tensor`，形状为 `(batch_size, output_dim`) -- 通过对 [Owlv2VisionModel](/docs/transformers/main/zh/model_doc/owlv2#transformers.Owlv2VisionModel) 的池化输出应用投影层得到的图像嵌入。 - **text_model_output** (`~modeling_outputs.BaseModelOutputWithPooling`，*可选*) -- [Owlv2TextModel](/docs/transformers/main/zh/model_doc/owlv2#transformers.Owlv2TextModel) 的输出。 - **vision_model_output**（`~modeling_outputs.BaseModelOutputWithPooling`，*可选*）—— [Owlv2VisionModel](/docs/transformers/main/zh/model_doc/owlv2#transformers.Owlv2VisionModel) 的输出。 示例： ```python >>> from PIL import Image >>> from huggingface_hub.utils import httpx >>> from io import BytesIO >>> 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" >>> with httpx.stream("GET", url) as response: ... image = Image.open(BytesIO(response.read())) >>> 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[[transformers.Owlv2Model.get_text_features]] ```python get_text_features(input_ids: Tensor, attention_mask: typing.Optional[torch.Tensor] = None, **kwargs: *) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/owlv2/modeling_owlv2.py#L781) **参数：** input_ids (`torch.LongTensor`，形状为 `(batch_size * num_max_text_queries, sequence_length)`) : 输入序列标记在词汇表中的索引。可以使用 [AutoTokenizer](/docs/transformers/main/zh/model_doc/auto#transformers.AutoTokenizer) 获取索引。有关详细信息，请参阅 [PreTrainedTokenizer.encode()](/docs/transformers/main/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 和 [PreTrainedTokenizer.__call__()](/docs/transformers/main/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)。[什么是输入 ID？](../glossary#input-ids) attention_mask (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值取自 `[0, 1]`： - 1 表示**未掩码**的标记， - 0 表示**已掩码**的标记。 [什么是注意力掩码？](../glossary#attention-mask) **返回：** [BaseModelOutputWithPooling](/docs/transformers/main/zh/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) 或 `tuple(torch.Tensor)` 一个 [BaseModelOutputWithPooling](/docs/transformers/main/zh/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) 或 `torch.Tensor` 元组（如果传入了 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[Owlv2Config](/docs/transformers/main/zh/model_doc/owlv2#transformers.Owlv2Config)）和输入。 - **last_hidden_state**（形状为 `(batch_size, sequence_length, hidden_size)` 的 `torch.Tensor`）-- 模型最后一层输出的隐藏状态序列。 - **pooler_output**（形状为 `(batch_size, hidden_size)` 的 `torch.Tensor`）-- 序列中第一个 token（分类 token）的最后一层隐藏状态，经过用于辅助预训练任务的层进一步处理后的结果。例如，对于 BERT 系列模型，这返回的是分类 token 经过线性层和 tanh 激活函数处理后的结果。线性层的权重是在预训练期间通过下一句预测（分类）目标训练得到的。 - **hidden_states** (`tuple(torch.Tensor)`，*可选*，在传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回) -- 一个 `torch.Tensor` 元组（如果模型具有嵌入层，则包含嵌入层的输出，以及每一层的输出），形状为 `(batch_size, sequence_length, hidden_size)`。 模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。 - **attentions** (`tuple(torch.Tensor)`，*可选*，当传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回) -- 一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。 经过注意力 softmax 后的注意力权重，用于在自注意力头中计算加权平均值。 示例： ```python >>> import torch >>> 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" ... ) >>> with torch.inference_mode(): ... text_features = model.get_text_features(**inputs) ``` #### get_image_features[[transformers.Owlv2Model.get_image_features]] ```python get_image_features(pixel_values: Tensor, interpolate_pos_encoding: bool = False, **kwargs: *) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/owlv2/modeling_owlv2.py#L818) **参数：** pixel_values (`torch.Tensor`，形状为 `(batch_size, num_channels, image_size, image_size)`)：与输入图像对应的张量。可以使用 [Owlv2ImageProcessor](/docs/transformers/main/zh/model_doc/owlv2#transformers.Owlv2ImageProcessor) 获取像素值。有关详细信息，请参阅 [Owlv2ImageProcessor.__call__()](/docs/transformers/main/zh/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__)（[Owlv2Processor](/docs/transformers/main/zh/model_doc/owlv2#transformers.Owlv2Processor) 使用 [Owlv2ImageProcessor](/docs/transformers/main/zh/model_doc/owlv2#transformers.Owlv2ImageProcessor) 处理图像）。 interpolate_pos_encoding (`bool`，*可选*，默认为 `False`)：是否对预训练的位置编码进行插值。 **返回：** [BaseModelOutputWithPooling](/docs/transformers/main/zh/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) 或 `tuple(torch.Tensor)` 一个 [BaseModelOutputWithPooling](/docs/transformers/main/zh/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) 或 `torch.Tensor` 元组（如果传入了 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[Owlv2Config](/docs/transformers/main/zh/model_doc/owlv2#transformers.Owlv2Config)）和输入。 - **last_hidden_state**（形状为 `(batch_size, sequence_length, hidden_size)` 的 `torch.Tensor`）-- 模型最后一层输出的隐藏状态序列。 - **pooler_output**（形状为 `(batch_size, hidden_size)` 的 `torch.Tensor`）-- 序列中第一个 token（分类 token）的最后一层隐藏状态，经过用于辅助预训练任务的层进一步处理后的结果。例如，对于 BERT 系列模型，这返回的是分类 token 经过线性层和 tanh 激活函数处理后的结果。线性层的权重是在预训练期间通过下一句预测（分类）目标训练得到的。 - **hidden_states** (`tuple(torch.Tensor)`，*可选*，在传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回) -- 一个 `torch.Tensor` 元组（如果模型具有嵌入层，则包含嵌入层的输出，以及每一层的输出），形状为 `(batch_size, sequence_length, hidden_size)`。 模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。 - **attentions** (`tuple(torch.Tensor)`，*可选*，当传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回) -- 一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。 经过注意力 softmax 后的注意力权重，用于在自注意力头中计算加权平均值。 示例： ```python >>> import torch >>> from transformers.image_utils import load_image >>> 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 = load_image(url) >>> inputs = processor(images=image, return_tensors="pt") >>> with torch.inference_mode(): ... image_features = model.get_image_features(**inputs) ``` ## Owlv2TextModel[[transformers.Owlv2TextModel]] #### transformers.Owlv2TextModel[[transformers.Owlv2TextModel]] ```python transformers.Owlv2TextModel(config: Owlv2TextConfig) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/owlv2/modeling_owlv2.py#L610) #### forward[[transformers.Owlv2TextModel.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, **kwargs: *) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/owlv2/modeling_owlv2.py#L626) **参数：** input_ids (`torch.LongTensor`，形状为 `(batch_size * num_max_text_queries, sequence_length)`) : 输入序列标记在词汇表中的索引。可以使用 [AutoTokenizer](/docs/transformers/main/zh/model_doc/auto#transformers.AutoTokenizer) 获取索引。有关详细信息，请参阅 [PreTrainedTokenizer.encode()](/docs/transformers/main/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 和 [PreTrainedTokenizer.__call__()](/docs/transformers/main/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)。[什么是输入 ID？](../glossary#input-ids) attention_mask (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值取自 `[0, 1]`： - 1 表示**未掩码**的标记， - 0 表示**已掩码**的标记。 [什么是注意力掩码？](../glossary#attention-mask) **返回：** [BaseModelOutputWithPooling](/docs/transformers/main/zh/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) 或 `tuple(torch.Tensor)` 一个 [BaseModelOutputWithPooling](/docs/transformers/main/zh/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) 或 `torch.Tensor` 元组（如果传入了 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[Owlv2Config](/docs/transformers/main/zh/model_doc/owlv2#transformers.Owlv2Config)）和输入。 [Owlv2TextModel](/docs/transformers/main/zh/model_doc/owlv2#transformers.Owlv2TextModel) 的 forward 方法重写了 `__call__` 特殊方法。 尽管前向传播的实现需要在此函数中定义，但之后应调用 `Module` 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者会静默地忽略这些步骤。 - **last_hidden_state**（形状为 `(batch_size, sequence_length, hidden_size)` 的 `torch.Tensor`）-- 模型最后一层输出的隐藏状态序列。 - **pooler_output**（形状为 `(batch_size, hidden_size)` 的 `torch.Tensor`）-- 序列中第一个 token（分类 token）的最后一层隐藏状态，经过用于辅助预训练任务的层进一步处理后的结果。例如，对于 BERT 系列模型，这返回的是分类 token 经过线性层和 tanh 激活函数处理后的结果。线性层的权重是在预训练期间通过下一句预测（分类）目标训练得到的。 - **hidden_states** (`tuple(torch.Tensor)`，*可选*，在传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回) -- 一个 `torch.Tensor` 元组（如果模型具有嵌入层，则包含嵌入层的输出，以及每一层的输出），形状为 `(batch_size, sequence_length, hidden_size)`。 模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。 - **attentions** (`tuple(torch.Tensor)`，*可选*，当传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回) -- 一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。 经过注意力 softmax 后的注意力权重，用于在自注意力头中计算加权平均值。 示例： ```python >>> 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[[transformers.Owlv2VisionModel]] #### transformers.Owlv2VisionModel[[transformers.Owlv2VisionModel]] ```python transformers.Owlv2VisionModel(config: Owlv2VisionConfig) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/owlv2/modeling_owlv2.py#L707) #### forward[[transformers.Owlv2VisionModel.forward]] ```python forward(pixel_values: typing.Optional[torch.Tensor] = None, interpolate_pos_encoding: bool = False, **kwargs: *) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/owlv2/modeling_owlv2.py#L721) **参数：** pixel_values (`torch.Tensor`，形状为 `(batch_size, num_channels, image_size, image_size)`，*可选*) : 与输入图像对应的张量。可以使用 [Owlv2ImageProcessor](/docs/transformers/main/zh/model_doc/owlv2#transformers.Owlv2ImageProcessor) 获取像素值。有关详细信息，请参阅 [Owlv2ImageProcessor.__call__()](/docs/transformers/main/zh/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__)（[Owlv2Processor](/docs/transformers/main/zh/model_doc/owlv2#transformers.Owlv2Processor) 使用 [Owlv2ImageProcessor](/docs/transformers/main/zh/model_doc/owlv2#transformers.Owlv2ImageProcessor) 处理图像）。 interpolate_pos_encoding (`bool`，*可选*，默认为 `False`)：是否对预训练的位置编码进行插值。 **返回：** [BaseModelOutputWithPooling](/docs/transformers/main/zh/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) 或 `tuple(torch.Tensor)` 一个 [BaseModelOutputWithPooling](/docs/transformers/main/zh/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) 或 `torch.Tensor` 元组（如果传入了 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[Owlv2Config](/docs/transformers/main/zh/model_doc/owlv2#transformers.Owlv2Config)）和输入。 [Owlv2VisionModel](/docs/transformers/main/zh/model_doc/owlv2#transformers.Owlv2VisionModel) 的 forward 方法重写了 `__call__` 特殊方法。 尽管前向传播的实现需要在此函数中定义，但之后应调用 `Module` 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者会静默地忽略这些步骤。 - **last_hidden_state**（形状为 `(batch_size, sequence_length, hidden_size)` 的 `torch.Tensor`）-- 模型最后一层输出的隐藏状态序列。 - **pooler_output**（形状为 `(batch_size, hidden_size)` 的 `torch.Tensor`）-- 序列中第一个 token（分类 token）的最后一层隐藏状态，经过用于辅助预训练任务的层进一步处理后的结果。例如，对于 BERT 系列模型，这返回的是分类 token 经过线性层和 tanh 激活函数处理后的结果。线性层的权重是在预训练期间通过下一句预测（分类）目标训练得到的。 - **hidden_states** (`tuple(torch.Tensor)`，*可选*，在传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回) -- 一个 `torch.Tensor` 元组（如果模型具有嵌入层，则包含嵌入层的输出，以及每一层的输出），形状为 `(batch_size, sequence_length, hidden_size)`。 模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。 - **attentions** (`tuple(torch.Tensor)`，*可选*，当传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回) -- 一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。 经过注意力 softmax 后的注意力权重，用于在自注意力头中计算加权平均值。 示例： ```python >>> from PIL import Image >>> from huggingface_hub.utils import httpx >>> from io import BytesIO >>> 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" >>> with httpx.stream("GET", url) as response: ... image = Image.open(BytesIO(response.read())) >>> 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[[transformers.Owlv2ForObjectDetection]] #### transformers.Owlv2ForObjectDetection[[transformers.Owlv2ForObjectDetection]] ```python transformers.Owlv2ForObjectDetection(config: Owlv2Config) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/owlv2/modeling_owlv2.py#L1001) #### forward[[transformers.Owlv2ForObjectDetection.forward]] ```python forward(input_ids: Tensor, pixel_values: Tensor, attention_mask: typing.Optional[torch.Tensor] = None, interpolate_pos_encoding: bool = False, **kwargs: *) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/owlv2/modeling_owlv2.py#L1324) **参数：** input_ids (`torch.LongTensor`，形状为 `(batch_size * num_max_text_queries, sequence_length)`，*可选*) : 输入序列标记在词汇表中的索引。可以使用 [AutoTokenizer](/docs/transformers/main/zh/model_doc/auto#transformers.AutoTokenizer) 获取索引。有关详细信息，请参阅 [PreTrainedTokenizer.encode()](/docs/transformers/main/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 和 [PreTrainedTokenizer.__call__()](/docs/transformers/main/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)。[什么是输入 ID？](../glossary#input-ids) pixel_values (`torch.Tensor`，形状为 `(batch_size, num_channels, image_size, image_size)`)：与输入图像对应的张量。可以使用 [Owlv2ImageProcessor](/docs/transformers/main/zh/model_doc/owlv2#transformers.Owlv2ImageProcessor) 获取像素值。有关详细信息，请参阅 [Owlv2ImageProcessor.__call__()](/docs/transformers/main/zh/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__)（[Owlv2Processor](/docs/transformers/main/zh/model_doc/owlv2#transformers.Owlv2Processor) 使用 [Owlv2ImageProcessor](/docs/transformers/main/zh/model_doc/owlv2#transformers.Owlv2ImageProcessor) 处理图像）。 attention_mask (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值取自 `[0, 1]`： - 1 表示**未掩码**的标记， - 0 表示**已掩码**的标记。 [什么是注意力掩码？](../glossary#attention-mask) interpolate_pos_encoding (`bool`，*可选*，默认为 `False`)：是否对预训练的位置编码进行插值。 **返回：** `Owlv2ObjectDetectionOutput` 或 `tuple(torch.Tensor)` `Owlv2ObjectDetectionOutput` 或 `torch.Tensor` 元组（如果传入 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[Owlv2Config](/docs/transformers/main/zh/model_doc/owlv2#transformers.Owlv2Config)）和输入。 [Owlv2ForObjectDetection](/docs/transformers/main/zh/model_doc/owlv2#transformers.Owlv2ForObjectDetection) 的 forward 方法重写了 `__call__` 特殊方法。 尽管前向传播的实现需要在此函数中定义，但之后应调用 `Module` 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者会静默地忽略这些步骤。 - **loss** (`torch.Tensor`，形状为 `(1,)`，*可选*，在提供 `labels` 时返回)) -- 总损失，是类别预测的负对数似然（交叉熵）与边界框损失的线性组合。后者定义为 L1 损失与广义尺度不变 IoU 损失的线性组合。 - **loss_dict** (`Dict`, *可选*) -- 包含各项单独损失的字典。适用于日志记录。 - **logits**（形状为 `(batch_size, num_patches, num_queries)` 的 `torch.Tensor`）-- 所有查询的分类 logits（包括无对象）。 - **objectness_logits** (`torch.Tensor`，形状为 `(batch_size, num_patches, 1)`) -- 所有图像块的对象性 logits。OWL-ViT 将图像表示为一组图像块，其中图像块的总数为 (image_size / patch_size)**2。 - **pred_boxes**（形状为 `(batch_size, num_patches, 4)` 的 `torch.Tensor`）-- 所有查询的归一化框坐标，表示为 (center_x, center_y, width, height)。这些值在 [0, 1] 范围内归一化，相对于批次中每张图片的单独尺寸（忽略可能的填充）。您可以使用 [post_process_object_detection()](/docs/transformers/main/zh/model_doc/owlv2#transformers.Owlv2ImageProcessor.post_process_object_detection) 来获取未归一化的边界框。 - **text_embeds**（形状为 `(batch_size, num_max_text_queries, output_dim` 的 `torch.Tensor`）-- 通过对 [Owlv2TextModel](/docs/transformers/main/zh/model_doc/owlv2#transformers.Owlv2TextModel) 的池化输出应用投影层获得的文本嵌入。 - **image_embeds** (`torch.Tensor`，形状为 `(batch_size, patch_size, patch_size, output_dim`) -- [Owlv2VisionModel](/docs/transformers/main/zh/model_doc/owlv2#transformers.Owlv2VisionModel) 的池化输出。OWLv2 将图像表示为一组图像块（image patches），并为每个图像块计算图像嵌入。 - **class_embeds** (`torch.Tensor`，形状为 `(batch_size, num_patches, hidden_size)`) -- 所有图像块的类别嵌入。OWLv2 将图像表示为一组图像块，其中图像块的总数为 (image_size / patch_size)**2。 - **text_model_output** (`~modeling_outputs.BaseModelOutputWithPooling`，*可选*) -- [Owlv2TextModel](/docs/transformers/main/zh/model_doc/owlv2#transformers.Owlv2TextModel) 的输出。 - **vision_model_output**（`~modeling_outputs.BaseModelOutputWithPooling`，*可选*）—— [Owlv2VisionModel](/docs/transformers/main/zh/model_doc/owlv2#transformers.Owlv2VisionModel) 的输出。 示例： ```python >>> from huggingface_hub.utils import httpx >>> from io import BytesIO >>> 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" >>> with httpx.stream("GET", url) as response: ... image = Image.open(BytesIO(response.read())) >>> text_labels = [["a photo of a cat", "a photo of a dog"]] >>> inputs = processor(text=text_labels, 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.height, image.width)]) >>> # Convert outputs (bounding boxes and class logits) to Pascal VOC format (xmin, ymin, xmax, ymax) >>> results = processor.post_process_grounded_object_detection( ... outputs=outputs, target_sizes=target_sizes, threshold=0.1, text_labels=text_labels ... ) >>> # Retrieve predictions for the first image for the corresponding text queries >>> result = results[0] >>> boxes, scores, text_labels = result["boxes"], result["scores"], result["text_labels"] >>> for box, score, text_label in zip(boxes, scores, text_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] ``` #### image_guided_detection[[transformers.Owlv2ForObjectDetection.image_guided_detection]] ```python image_guided_detection(pixel_values: Tensor, query_pixel_values: typing.Optional[torch.Tensor] = None, interpolate_pos_encoding: bool = False, **kwargs: *) ``` [来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/owlv2/modeling_owlv2.py#L1235) **参数：** pixel_values (`torch.Tensor`，形状为 `(batch_size, num_channels, image_size, image_size)`)：与输入图像对应的张量。可以使用 [Owlv2ImageProcessor](/docs/transformers/main/zh/model_doc/owlv2#transformers.Owlv2ImageProcessor) 获取像素值。有关详细信息，请参阅 [Owlv2ImageProcessor.__call__()](/docs/transformers/main/zh/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__)（[Owlv2Processor](/docs/transformers/main/zh/model_doc/owlv2#transformers.Owlv2Processor) 使用 [Owlv2ImageProcessor](/docs/transformers/main/zh/model_doc/owlv2#transformers.Owlv2ImageProcessor) 处理图像）。 query_pixel_values (`torch.Tensor`，形状为 `(batch_size, num_channels, height, width)`)：待检测查询图像的像素值。每个目标图像对应传入一张查询图像。 interpolate_pos_encoding (`bool`，*可选*，默认为 `False`)：是否对预训练的位置编码进行插值。 **返回：** `Owlv2ImageGuidedObjectDetectionOutput` 或 `tuple(torch.Tensor)` `Owlv2ImageGuidedObjectDetectionOutput` 或 `torch.Tensor` 元组（如果传入 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[Owlv2Config](/docs/transformers/main/zh/model_doc/owlv2#transformers.Owlv2Config)）和输入。 - **logits**（形状为 `(batch_size, num_patches, num_queries)` 的 `torch.Tensor`）-- 所有查询的分类 logits（包括无对象）。 - **image_embeds** (`torch.Tensor`，形状为 `(batch_size, patch_size, patch_size, output_dim`) -- [Owlv2VisionModel](/docs/transformers/main/zh/model_doc/owlv2#transformers.Owlv2VisionModel) 的池化输出。OWLv2 将图像表示为一组图像块（image patches），并为每个图像块计算图像嵌入。 - **query_image_embeds** (`torch.Tensor`，形状为 `(batch_size, patch_size, patch_size, output_dim`) -- [Owlv2VisionModel](/docs/transformers/main/zh/model_doc/owlv2#transformers.Owlv2VisionModel) 的池化输出。OWLv2 将图像表示为一组图像块（image patches），并为每个图像块计算图像嵌入。 - **target_pred_boxes**（形状为 `(batch_size, num_patches, 4)` 的 `torch.Tensor`）-- 所有查询的归一化框坐标，表示为 (center_x, center_y, width, height)。这些值在 [0, 1] 范围内归一化，相对于批次中每个目标图像的尺寸（忽略可能的填充）。您可以使用 [post_process_object_detection()](/docs/transformers/main/zh/model_doc/owlv2#transformers.Owlv2ImageProcessor.post_process_object_detection) 来获取未归一化的边界框。 - **query_pred_boxes**（形状为 `(batch_size, num_patches, 4)` 的 `torch.Tensor`）-- 所有查询的归一化框坐标，表示为 (center_x, center_y, width, height)。这些值在 [0, 1] 范围内归一化，相对于批次中每个单独查询图像的尺寸（忽略可能的填充）。您可以使用 [post_process_object_detection()](/docs/transformers/main/zh/model_doc/owlv2#transformers.Owlv2ImageProcessor.post_process_object_detection) 来获取未归一化的边界框。 - **class_embeds** (`torch.Tensor`，形状为 `(batch_size, num_patches, hidden_size)`) -- 所有图像块的类别嵌入。OWLv2 将图像表示为一组图像块，其中图像块的总数为 (image_size / patch_size)**2。 - **text_model_output** (`~modeling_outputs.BaseModelOutputWithPooling`，*可选*) -- [Owlv2TextModel](/docs/transformers/main/zh/model_doc/owlv2#transformers.Owlv2TextModel) 的输出。 - **vision_model_output**（`~modeling_outputs.BaseModelOutputWithPooling`，*可选*）—— [Owlv2VisionModel](/docs/transformers/main/zh/model_doc/owlv2#transformers.Owlv2VisionModel) 的输出。 示例： ```python >>> from huggingface_hub.utils import httpx >>> from io import BytesIO >>> 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" >>> with httpx.stream("GET", url) as response: ... image = Image.open(BytesIO(response.read())) >>> query_url = "http://images.cocodataset.org/val2017/000000001675.jpg" >>> with httpx.stream("GET", query_url) as response: ... query_image = Image.open(BytesIO(response.read())) >>> 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 1.0 at location [341.76, 22.77, 640.65, 370.25] Detected similar object with confidence 1.0 at location [6.59, 51.43, 329.05, 476.77] ```