# Grounding DINO ## Resumen El modelo Grounding DINO se propuso en [Grounding DINO: Marrying DINO with Grounded Pre-Training for Open-Set Object Detection](https://huggingface.co/papers/2303.05499) de Shilong Liu, Zhaoyang Zeng, Tianhe Ren, Feng Li, Hao Zhang, Jie Yang, Chunyuan Li, Jianwei Yang, Hang Su, Jun Zhu, Lei Zhang. Grounding DINO extiende un modelo de detección de objetos de conjunto cerrado con un codificador de texto, lo que permite la detección de objetos de conjunto abierto. El modelo logra resultados notables, como 52,5 AP en COCO zero-shot. El resumen del artículo es el siguiente: *En este artículo, presentamos un detector de objetos de conjunto abierto, llamado Grounding DINO, que combina el detector basado en Transformer DINO con el preentrenamiento con anclaje, lo que permite detectar objetos arbitrarios mediante entradas humanas como nombres de categorías o expresiones de referencia. La solución clave para la detección de objetos de conjunto abierto es introducir el lenguaje en un detector de conjunto cerrado para la generalización de conceptos de conjunto abierto. Para fusionar de manera efectiva las modalidades de lenguaje y visión, dividimos conceptualmente un detector de conjunto cerrado en tres fases y proponemos una solución de fusión estrecha, que incluye un mejorador de características, una selección de consultas guiada por el lenguaje y un decodificador de multimodalidad para la fusión entre modalidades. Si bien los trabajos anteriores evalúan principalmente la detección de objetos de conjunto abierto en categorías novedosas, proponemos realizar también evaluaciones en la comprensión de expresiones de referencia para objetos especificados con atributos. Grounding DINO rinde de manera notable en los tres escenarios, incluidos los puntos de referencia en COCO, LVIS, ODinW y RefCOCO/+/g. Grounding DINO alcanza un AP de 52.5 en el punto de referencia de transferencia sin ejemplos de detección de COCO, es decir, sin ningún dato de entrenamiento de COCO. Establece un nuevo récord en el punto de referencia sin ejemplos de ODinW con un AP medio de 26.1.* drawing Resumen de Grounding DINO. Tomado del artículo original. Este modelo fue aportado por [EduardoPacheco](https://huggingface.co/EduardoPacheco) y [nielsr](https://huggingface.co/nielsr). El código original se puede encontrar [aquí](https://github.com/IDEA-Research/GroundingDINO). ## Consejos de uso - Se puede usar [GroundingDinoProcessor](/docs/transformers/main/es/model_doc/grounding-dino#transformers.GroundingDinoProcessor) para preparar pares de imagen y texto para el modelo. - Para separar clases en el texto, use un punto, por ejemplo, "a cat. a dog." - Al usar múltiples clases (p. ej. `"a cat. a dog."`), use `post_process_grounded_object_detection` de [GroundingDinoProcessor](/docs/transformers/main/es/model_doc/grounding-dino#transformers.GroundingDinoProcessor) para postprocesar las salidas. Dado que las etiquetas devueltas por `post_process_object_detection` representan los índices de la dimensión del modelo donde prob > threshold. Así es como se utiliza el modelo para la detección de objetos en cero disparos: ```python import requests import torch from PIL import Image from transformers import AutoProcessor, AutoModelForZeroShotObjectDetection model_id = "IDEA-Research/grounding-dino-tiny" processor = AutoProcessor.from_pretrained(model_id) model = AutoModelForZeroShotObjectDetection.from_pretrained(model_id, device_map="auto") image_url = "http://images.cocodataset.org/val2017/000000039769.jpg" image = Image.open(requests.get(image_url, stream=True).raw) # Check for cats and remote controls text_labels = [["a cat", "a remote control"]] inputs = processor(images=image, text=text_labels, return_tensors="pt").to(model.device) with torch.no_grad(): outputs = model(**inputs) results = processor.post_process_grounded_object_detection( outputs, inputs.input_ids, threshold=0.4, text_threshold=0.3, target_sizes=[image.size[::-1]] ) # Retrieve the first image result result = results[0] for box, score, labels in zip(result["boxes"], result["scores"], result["labels"]): box = [round(x, 2) for x in box.tolist()] print(f"Detected {labels} with confidence {round(score.item(), 3)} at location {box}") Detected a cat with confidence 0.468 at location [344.78, 22.9, 637.3, 373.62] Detected a cat with confidence 0.426 at location [11.74, 51.55, 316.51, 473.22] ``` ## Grounded SAM Se puede combinar Grounding DINO con el modelo [Segment Anything](sam) para la generación de máscaras basadas en texto, tal como se introduce en [Grounded SAM: Assembling Open-World Models for Diverse Visual Tasks](https://huggingface.co/papers/2401.14159). Puede consultar este [cuaderno de demostración](https://github.com/NielsRogge/Transformers-Tutorials/blob/master/Grounding%20DINO/GroundingDINO_with_Segment_Anything.ipynb) 🌍 para más detalles. drawing Resumen de Grounded SAM. Tomado del repositorio original. ## Recursos Una lista de recursos oficiales de Hugging Face y de la comunidad (indicados con 🌎) para ayudarte a empezar con Grounding DINO. Si te interesa enviar un recurso para que se incluya aquí, no dudes en abrir una Pull Request y lo revisaremos. Lo ideal es que el recurso demuestre algo nuevo en lugar de duplicar un recurso existente. - Los cuadernos de demostración sobre inferencia con Grounding DINO, así como su combinación con [SAM](sam), se pueden encontrar [aquí](https://github.com/NielsRogge/Transformers-Tutorials/tree/master/Grounding%20DINO). 🌎 ## GroundingDinoImageProcessor[[transformers.GroundingDinoImageProcessor]] #### transformers.GroundingDinoImageProcessor[[transformers.GroundingDinoImageProcessor]] ```python transformers.GroundingDinoImageProcessor(**kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/grounding_dino/image_processing_grounding_dino.py#L308) **Parámetros:** do_convert_rgb (`bool`, *kwargs*, *opcional*) : Si se debe convertir la imagen a RGB. do_resize (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Si se debe redimensionar la imagen. size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, por defecto `{'shortest_edge' : 800, 'longest_edge': 1333}`): Describe las dimensiones máximas de entrada para el modelo. default_to_square (`bool`, *kwargs*, *opcional*, valor predeterminado `False`) : Si se debe usar una imagen cuadrada por defecto al redimensionar, cuando size es un int. crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Tamaño de la imagen de salida tras aplicar `center_crop`. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, por defecto `2`) : Filtro de remuestreo que se utilizará si se redimensiona la imagen. Puede ser uno de los valores de la enumeración `PILImageResampling`. Solo tiene efecto si `do_resize` está establecido en `True`. do_rescale (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Indica si se debe reescalar la imagen. rescale_factor (`float`, *kwargs*, *opcional*, valor predeterminado `0.00392156862745098`) : Factor de reescalado para reescalar la imagen si `do_rescale` está establecido en `True`. do_normalize (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Si se debe normalizar la imagen. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*, valor predeterminado `[0.485, 0.456, 0.406]`) : Media de la imagen a utilizar para la normalización. Solo tiene efecto si `do_normalize` está establecido en `True`. image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*, valor predeterminado `[0.229, 0.224, 0.225]`) : Desviación estándar de la imagen que se utilizará para la normalización. Solo tiene efecto si `do_normalize` está establecido en `True`. do_pad (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Indica si se debe aplicar relleno a la imagen. El relleno se realiza hasta el mayor tamaño del lote o hasta un tamaño cuadrado fijo por imagen. La estrategia exacta de relleno depende del modelo. pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : El tamaño en `{"height": int, "width" int}` al que se rellenan las imágenes. Debe ser mayor que el tamaño de cualquier imagen proporcionada para el preprocesamiento. Si no se proporciona `pad_size`, las imágenes se rellenarán hasta la mayor altura y anchura del lote. Se aplica solo cuando `do_pad=True.` do_center_crop (`bool`, *kwargs*, *opcional*) : Si se debe recortar la imagen centrada. data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : Solo se admite `ChannelDimension.FIRST`. Se añadió para garantizar la compatibilidad con los procesadores lentos. input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : El formato de la dimensión de canal para la imagen de entrada. Si no se establece, el formato de la dimensión de canal se infiere a partir de la imagen de entrada. Puede ser uno de: - `"channels_first"` o `ChannelDimension.FIRST`: imagen en formato (num_channels, height, width). - `"channels_last"` o `ChannelDimension.LAST`: imagen en formato (height, width, num_channels). - `"none"` o `ChannelDimension.NONE`: imagen en formato (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : El dispositivo en el que se procesarán los vídeos. Si no se establece, el dispositivo se infiere a partir de los vídeos de entrada. return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Devuelve tensores apilados si se establece en `'pt'`; en caso contrario, devuelve una lista de tensores. disable_grouping (`bool`, *kwargs*, *opcional*) : Si se debe deshabilitar el agrupamiento de imágenes por tamaño para procesarlas de forma individual y no en lotes. Si es None, se establecerá en True si las imágenes están en CPU, y en False en caso contrario. Esta elección se basa en observaciones empíricas, como se detalla aquí: https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *opcional*) : El número de tokens de imagen que se utilizarán para cada imagen en la entrada. Se añadió por compatibilidad con versiones anteriores, pero en los modelos futuros esto debería configurarse como un atributo del procesador. format (`str`, *kwargs*, *opcional*, por defecto `AnnotationFormat.COCO_DETECTION`) : Formato de datos de las anotaciones. Uno de "coco_detection" o "coco_panoptic". do_convert_annotations (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Controla si se convierten las anotaciones al formato esperado por el modelo GROUNDING_DINO. Convierte las cajas delimitadoras al formato `(center_x, center_y, width, height)` y en el rango `[0, 1]`. Se puede anular mediante el parámetro `do_convert_annotations` en el método `preprocess`. Construye un procesador de imágenes GroundingDinoImageProcessor. #### preprocess[[transformers.GroundingDinoImageProcessor.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']], annotations: dict[str, int | str | list[dict]] | list[dict[str, int | str | list[dict]]] | None = None, return_segmentation_masks: bool | None = None, masks_path: str | pathlib.Path | None = None, **kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/grounding_dino/image_processing_grounding_dino.py#L563) **Parámetros:** images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`) : Imagen a preprocesar. Espera una imagen única o un lote de imágenes con valores de píxeles que van de 0 a 255. Si se pasan imágenes con valores de píxeles entre 0 y 1, establezca `do_rescale=False`. annotations (`AnnotationType` o `list[AnnotationType]`, *opcional*) : Anotaciones que se transformarán según el relleno aplicado a las imágenes. return_segmentation_masks (`bool`, *opcional*, valor predeterminado `self.return_segmentation_masks`) : Si se deben devolver las máscaras de segmentación. masks_path (`str` o `pathlib.Path`, *opcional*) : Ruta al directorio que contiene las máscaras de segmentación. do_convert_rgb (`bool`, *kwargs*, *opcional*) : Si se debe convertir la imagen a RGB. do_resize (`bool`, *kwargs*, *opcional*) : Si se debe redimensionar la imagen. size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Describe las dimensiones máximas de entrada del modelo. default_to_square (`bool`, *kwargs*, *opcional*) : Si el tamaño es un entero, si se debe usar una imagen cuadrada por defecto al redimensionar. crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Tamaño de la imagen de salida tras aplicar `center_crop`. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : Filtro de remuestreo que se utilizará si se redimensiona la imagen. Puede ser uno de los valores de la enumeración `PILImageResampling`. Solo tiene efecto si `do_resize` está establecido en `True`. do_rescale (`bool`, *kwargs*, *opcional*) : Si se debe reescalar la imagen. rescale_factor (`float`, *kwargs*, *opcional*) : Factor de reescalado para reescalar la imagen si `do_rescale` está establecido en `True`. do_normalize (`bool`, *kwargs*, *opcional*) : Si se debe normalizar la imagen. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*) : Media de la imagen a utilizar para la normalización. Solo tiene efecto si `do_normalize` está establecido en `True`. image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*) : Desviación estándar de la imagen a utilizar para la normalización. Solo tiene efecto si `do_normalize` está establecido en `True`. do_pad (`bool`, *kwargs*, *opcional*) : Indica si se debe aplicar relleno a la imagen. El relleno se realiza hasta el tamaño más grande del lote o hasta un tamaño cuadrado fijo por imagen. La estrategia exacta de relleno depende del modelo. pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : El tamaño en `{"height": int, "width" int}` al que se rellenan las imágenes. Debe ser mayor que el tamaño de cualquier imagen proporcionada para el preprocesamiento. Si no se proporciona `pad_size`, las imágenes se rellenarán hasta la mayor altura y anchura del lote. Se aplica solo cuando `do_pad=True.` do_center_crop (`bool`, *kwargs*, *opcional*) : Si se debe recortar la imagen centrada. data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : Solo se admite `ChannelDimension.FIRST`. Se añadió para garantizar la compatibilidad con los procesadores lentos. input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : El formato de la dimensión de canal para la imagen de entrada. Si no se establece, el formato de la dimensión de canal se infiere a partir de la imagen de entrada. Puede ser uno de: - `"channels_first"` o `ChannelDimension.FIRST`: imagen en formato (num_channels, height, width). - `"channels_last"` o `ChannelDimension.LAST`: imagen en formato (height, width, num_channels). - `"none"` o `ChannelDimension.NONE`: imagen en formato (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : El dispositivo en el que se procesarán los vídeos. Si no se establece, el dispositivo se infiere a partir de los vídeos de entrada. return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Devuelve tensores apilados si se establece en `'pt'`; en caso contrario, devuelve una lista de tensores. disable_grouping (`bool`, *kwargs*, *opcional*) : Si se debe deshabilitar el agrupamiento de imágenes por tamaño para procesarlas de forma individual y no en lotes. Si es None, se establecerá en True si las imágenes están en CPU, y en False en caso contrario. Esta elección se basa en observaciones empíricas, como se detalla aquí: https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *opcional*) : El número de tokens de imagen que se utilizarán para cada imagen en la entrada. Se añadió por compatibilidad con versiones anteriores, pero en los modelos futuros esto debería configurarse como un atributo del procesador. format (`str`, *kwargs*, *opcional*, por defecto `AnnotationFormat.COCO_DETECTION`) : Formato de datos de las anotaciones. Uno de "coco_detection" o "coco_panoptic". do_convert_annotations (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Controla si se convierten las anotaciones al formato esperado por el modelo GROUNDING_DINO. Convierte las cajas delimitadoras al formato `(center_x, center_y, width, height)` y en el rango `[0, 1]`. Se puede anular mediante el parámetro `do_convert_annotations` en el método `preprocess`. **Devuelve:** `~image_processing_base.BatchFeature` - **data** (`dict`) -- Diccionario de listas/arrays/tensores devueltos por el método __call__ ('pixel_values', etc.). - **tensor_type** (`Union[None, str, TensorType]`, *opcional*) -- Puede especificar un tensor_type aquí para convertir las listas de enteros en Tensors de PyTorch/Numpy durante la inicialización. ## GroundingDinoImageProcessorPil[[transformers.GroundingDinoImageProcessorPil]] #### transformers.GroundingDinoImageProcessorPil[[transformers.GroundingDinoImageProcessorPil]] ```python transformers.GroundingDinoImageProcessorPil(**kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/grounding_dino/image_processing_pil_grounding_dino.py#L300) **Parámetros:** do_convert_rgb (`bool`, *kwargs*, *opcional*) : Si se debe convertir la imagen a RGB. do_resize (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Si se debe redimensionar la imagen. size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, por defecto `{'shortest_edge' : 800, 'longest_edge': 1333}`): Describe las dimensiones máximas de entrada para el modelo. default_to_square (`bool`, *kwargs*, *opcional*, valor predeterminado `False`) : Si se debe usar una imagen cuadrada por defecto al redimensionar, cuando size es un int. crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Tamaño de la imagen de salida tras aplicar `center_crop`. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, por defecto `2`) : Filtro de remuestreo que se utilizará si se redimensiona la imagen. Puede ser uno de los valores de la enumeración `PILImageResampling`. Solo tiene efecto si `do_resize` está establecido en `True`. do_rescale (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Indica si se debe reescalar la imagen. rescale_factor (`float`, *kwargs*, *opcional*, valor predeterminado `0.00392156862745098`) : Factor de reescalado para reescalar la imagen si `do_rescale` está establecido en `True`. do_normalize (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Si se debe normalizar la imagen. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*, valor predeterminado `[0.485, 0.456, 0.406]`) : Media de la imagen a utilizar para la normalización. Solo tiene efecto si `do_normalize` está establecido en `True`. image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*, valor predeterminado `[0.229, 0.224, 0.225]`) : Desviación estándar de la imagen que se utilizará para la normalización. Solo tiene efecto si `do_normalize` está establecido en `True`. do_pad (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Indica si se debe aplicar relleno a la imagen. El relleno se realiza hasta el mayor tamaño del lote o hasta un tamaño cuadrado fijo por imagen. La estrategia exacta de relleno depende del modelo. pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : El tamaño en `{"height": int, "width" int}` al que se rellenan las imágenes. Debe ser mayor que el tamaño de cualquier imagen proporcionada para el preprocesamiento. Si no se proporciona `pad_size`, las imágenes se rellenarán hasta la mayor altura y anchura del lote. Se aplica solo cuando `do_pad=True.` do_center_crop (`bool`, *kwargs*, *opcional*) : Si se debe recortar la imagen centrada. data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : Solo se admite `ChannelDimension.FIRST`. Se añadió para garantizar la compatibilidad con los procesadores lentos. input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : El formato de la dimensión de canal para la imagen de entrada. Si no se establece, el formato de la dimensión de canal se infiere a partir de la imagen de entrada. Puede ser uno de: - `"channels_first"` o `ChannelDimension.FIRST`: imagen en formato (num_channels, height, width). - `"channels_last"` o `ChannelDimension.LAST`: imagen en formato (height, width, num_channels). - `"none"` o `ChannelDimension.NONE`: imagen en formato (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : El dispositivo en el que se procesarán los vídeos. Si no se establece, el dispositivo se infiere a partir de los vídeos de entrada. return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Devuelve tensores apilados si se establece en `'pt'`; en caso contrario, devuelve una lista de tensores. disable_grouping (`bool`, *kwargs*, *opcional*) : Si se debe deshabilitar el agrupamiento de imágenes por tamaño para procesarlas de forma individual y no en lotes. Si es None, se establecerá en True si las imágenes están en CPU, y en False en caso contrario. Esta elección se basa en observaciones empíricas, como se detalla aquí: https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *opcional*) : El número de tokens de imagen que se utilizarán para cada imagen en la entrada. Se añadió por compatibilidad con versiones anteriores, pero en los modelos futuros esto debería configurarse como un atributo del procesador. format (`str`, *kwargs*, *opcional*, por defecto `AnnotationFormat.COCO_DETECTION`) : Formato de datos de las anotaciones. Uno de "coco_detection" o "coco_panoptic". do_convert_annotations (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Controla si se convierten las anotaciones al formato esperado por el modelo GROUNDING_DINO. Convierte las cajas delimitadoras al formato `(center_x, center_y, width, height)` y en el rango `[0, 1]`. Se puede anular mediante el parámetro `do_convert_annotations` en el método `preprocess`. Construye un procesador de imágenes GroundingDinoImageProcessor. #### preprocess[[transformers.GroundingDinoImageProcessorPil.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']], annotations: dict[str, int | str | list[dict]] | list[dict[str, int | str | list[dict]]] | None = None, return_segmentation_masks: bool | None = None, masks_path: str | pathlib.Path | None = None, **kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/grounding_dino/image_processing_pil_grounding_dino.py#L568) **Parámetros:** images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`) : Imagen a preprocesar. Espera una imagen única o un lote de imágenes con valores de píxeles que van de 0 a 255. Si se pasan imágenes con valores de píxeles entre 0 y 1, establezca `do_rescale=False`. annotations (`AnnotationType` o `list[AnnotationType]`, *opcional*) : Anotaciones que se transformarán según el relleno aplicado a las imágenes. return_segmentation_masks (`bool`, *opcional*, valor predeterminado `self.return_segmentation_masks`) : Si se deben devolver las máscaras de segmentación. masks_path (`str` o `pathlib.Path`, *opcional*) : Ruta al directorio que contiene las máscaras de segmentación. do_convert_rgb (`bool`, *kwargs*, *opcional*) : Si se debe convertir la imagen a RGB. do_resize (`bool`, *kwargs*, *opcional*) : Si se debe redimensionar la imagen. size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Describe las dimensiones máximas de entrada del modelo. default_to_square (`bool`, *kwargs*, *opcional*) : Si el tamaño es un entero, si se debe usar una imagen cuadrada por defecto al redimensionar. crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Tamaño de la imagen de salida tras aplicar `center_crop`. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : Filtro de remuestreo que se utilizará si se redimensiona la imagen. Puede ser uno de los valores de la enumeración `PILImageResampling`. Solo tiene efecto si `do_resize` está establecido en `True`. do_rescale (`bool`, *kwargs*, *opcional*) : Si se debe reescalar la imagen. rescale_factor (`float`, *kwargs*, *opcional*) : Factor de reescalado para reescalar la imagen si `do_rescale` está establecido en `True`. do_normalize (`bool`, *kwargs*, *opcional*) : Si se debe normalizar la imagen. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*) : Media de la imagen a utilizar para la normalización. Solo tiene efecto si `do_normalize` está establecido en `True`. image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*) : Desviación estándar de la imagen a utilizar para la normalización. Solo tiene efecto si `do_normalize` está establecido en `True`. do_pad (`bool`, *kwargs*, *opcional*) : Indica si se debe aplicar relleno a la imagen. El relleno se realiza hasta el tamaño más grande del lote o hasta un tamaño cuadrado fijo por imagen. La estrategia exacta de relleno depende del modelo. pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : El tamaño en `{"height": int, "width" int}` al que se rellenan las imágenes. Debe ser mayor que el tamaño de cualquier imagen proporcionada para el preprocesamiento. Si no se proporciona `pad_size`, las imágenes se rellenarán hasta la mayor altura y anchura del lote. Se aplica solo cuando `do_pad=True.` do_center_crop (`bool`, *kwargs*, *opcional*) : Si se debe recortar la imagen centrada. data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : Solo se admite `ChannelDimension.FIRST`. Se añadió para garantizar la compatibilidad con los procesadores lentos. input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : El formato de la dimensión de canal para la imagen de entrada. Si no se establece, el formato de la dimensión de canal se infiere a partir de la imagen de entrada. Puede ser uno de: - `"channels_first"` o `ChannelDimension.FIRST`: imagen en formato (num_channels, height, width). - `"channels_last"` o `ChannelDimension.LAST`: imagen en formato (height, width, num_channels). - `"none"` o `ChannelDimension.NONE`: imagen en formato (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : El dispositivo en el que se procesarán los vídeos. Si no se establece, el dispositivo se infiere a partir de los vídeos de entrada. return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Devuelve tensores apilados si se establece en `'pt'`; en caso contrario, devuelve una lista de tensores. disable_grouping (`bool`, *kwargs*, *opcional*) : Si se debe deshabilitar el agrupamiento de imágenes por tamaño para procesarlas de forma individual y no en lotes. Si es None, se establecerá en True si las imágenes están en CPU, y en False en caso contrario. Esta elección se basa en observaciones empíricas, como se detalla aquí: https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *opcional*) : El número de tokens de imagen que se utilizarán para cada imagen en la entrada. Se añadió por compatibilidad con versiones anteriores, pero en los modelos futuros esto debería configurarse como un atributo del procesador. format (`str`, *kwargs*, *opcional*, por defecto `AnnotationFormat.COCO_DETECTION`) : Formato de datos de las anotaciones. Uno de "coco_detection" o "coco_panoptic". do_convert_annotations (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Controla si se convierten las anotaciones al formato esperado por el modelo GROUNDING_DINO. Convierte las cajas delimitadoras al formato `(center_x, center_y, width, height)` y en el rango `[0, 1]`. Se puede anular mediante el parámetro `do_convert_annotations` en el método `preprocess`. **Devuelve:** `~image_processing_base.BatchFeature` - **data** (`dict`) -- Diccionario de listas/arrays/tensores devueltos por el método __call__ ('pixel_values', etc.). - **tensor_type** (`Union[None, str, TensorType]`, *opcional*) -- Puede especificar un tensor_type aquí para convertir las listas de enteros en Tensors de PyTorch/Numpy durante la inicialización. #### post_process_object_detection[[transformers.GroundingDinoImageProcessorPil.post_process_object_detection]] ```python post_process_object_detection(outputs: GroundingDinoObjectDetectionOutput, threshold: float = 0.1, target_sizes: transformers.utils.generic.TensorType | list[tuple] | None = None) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/grounding_dino/image_processing_pil_grounding_dino.py#L713) **Parámetros:** outputs (`GroundingDinoObjectDetectionOutput`) : Salidas crudas del modelo. threshold (`float`, *opcional*, valor predeterminado 0.1) : Umbral de puntuación para conservar las predicciones de detección de objetos. target_sizes (`torch.Tensor` o `list[tuple[int, int]]`, *opcional*) : Tensor de forma `(batch_size, 2)` o lista de tuplas (`tuple[int, int]`) que contiene el tamaño objetivo `(height, width)` de cada imagen del lote. Si no se establece, las predicciones no se redimensionarán. **Devuelve:** `list[Dict]` Una lista de diccionarios, donde cada diccionario contiene las siguientes claves: - "scores": Las puntuaciones de confianza para cada caja predicha en la imagen. - "labels": Índices de las clases predichas por el modelo en la imagen. - "boxes": cajas delimitadoras de la imagen en el formato (top_left_x, top_left_y, bottom_right_x, bottom_right_y). Convierte la salida cruda de [GroundingDinoForObjectDetection](/docs/transformers/main/es/model_doc/grounding-dino#transformers.GroundingDinoForObjectDetection) en cajas delimitadoras finales en el formato (top_left_x, top_left_y, bottom_right_x, bottom_right_y). ## GroundingDinoProcessor[[transformers.GroundingDinoProcessor]] #### transformers.GroundingDinoProcessor[[transformers.GroundingDinoProcessor]] ```python transformers.GroundingDinoProcessor(image_processor, tokenizer) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/grounding_dino/processing_grounding_dino.py#L115) **Parámetros:** image_processor (`GroundingDinoImageProcessor`) : El procesador de imágenes es una entrada obligatoria. tokenizer (`BertTokenizer`) : El tokenizador es una entrada obligatoria. Construye un GroundingDinoProcessor que envuelve un procesador de imágenes y un tokenizador en un único procesador. [GroundingDinoProcessor](/docs/transformers/main/es/model_doc/grounding-dino#transformers.GroundingDinoProcessor) ofrece todas las funcionalidades de [GroundingDinoImageProcessor](/docs/transformers/main/es/model_doc/grounding-dino#transformers.GroundingDinoImageProcessor) y [BertTokenizer](/docs/transformers/main/es/model_doc/lxmert#transformers.BertTokenizer). Consulte [~GroundingDinoImageProcessor](/docs/transformers/main/es/model_doc/grounding-dino#transformers.GroundingDinoImageProcessor) y [~BertTokenizer](/docs/transformers/main/es/model_doc/lxmert#transformers.BertTokenizer) para obtener más información. #### __llamada__[[transformers.GroundingDinoProcessor.__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 = None, videos: typing.Union[list['PIL.Image.Image'], numpy.ndarray, ForwardRef('torch.Tensor'), list[numpy.ndarray], list['torch.Tensor'], list[list['PIL.Image.Image']], list[list[numpy.ndarray]], list[list['torch.Tensor']], transformers.video_utils.URL, list[transformers.video_utils.URL], list[list[transformers.video_utils.URL]], transformers.video_utils.Path, list[transformers.video_utils.Path], list[list[transformers.video_utils.Path]], NoneType] = None, audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], NoneType] = None, **kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/processing_utils.py#L659) **Parámetros:** images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`, *opcional*) : Imagen para preprocesar. Espera una imagen única o un lote de imágenes con valores de píxeles que van de 0 a 255. Si se pasan imágenes con valores de píxeles entre 0 y 1, establezca `do_rescale=False`. text (`Union[str, list[str], list[list[str]]]`, *opcional*) : La secuencia o el lote de secuencias que se van a codificar. Cada secuencia puede ser una cadena de caracteres o una lista de cadenas (cadena pretokenizada). Si se pasa una entrada pretokenizada, establezca `is_split_into_words=True` para evitar ambigüedad con las entradas en lote. videos (`Union[list[PIL.Image.Image], numpy.ndarray, torch.Tensor, list[numpy.ndarray], list[torch.Tensor], list[list[PIL.Image.Image]], list[list[numpy.ndarray]], list[list[torch.Tensor]], ~video_utils.URL, list[~video_utils.URL], list[list[~video_utils.URL]], ~video_utils.Path, list[~video_utils.Path], list[list[~video_utils.Path]]]`, *opcional*) : Video a preprocesar. Se espera un único video o un lote de videos con valores de píxeles que van de 0 a 255. Si se pasan videos con valores de píxeles entre 0 y 1, establezca `do_rescale=False`. audio (`Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]]`, *opcional*) : El audio o lote de audios que se va a preparar. Cada audio puede ser un array de NumPy o un tensor de PyTorch. En el caso de un array de NumPy/tensor de PyTorch, cada audio debe tener la forma (C, T), donde C es el número de canales y T es la longitud de muestreo del audio. return_tensors (`str` o [TensorType](/docs/transformers/main/es/internal/file_utils#transformers.TensorType), *opcional*) : Si se establece, devolverá tensores de un marco de trabajo específico. Los valores aceptables son: - `'pt'`: Devuelve objetos `torch.Tensor` de PyTorch. - `'np'`: Devuelve objetos `np.ndarray` de NumPy. - ****kwargs** ([ProcessingKwargs](/docs/transformers/main/es/main_classes/processors#transformers.ProcessingKwargs), *opcional*) : Opciones de procesamiento adicionales para cada modalidad (texto, imágenes, vídeos, audio). Los parámetros específicos del modelo se enumeran arriba; consulte la clase TypedDict para obtener la lista completa de argumentos admitidos. #### post_process_grounded_object_detection[[transformers.GroundingDinoProcessor.post_process_grounded_object_detection]] ```python post_process_grounded_object_detection(outputs: GroundingDinoObjectDetectionOutput, input_ids: transformers.utils.generic.TensorType | None = None, threshold: float = 0.25, text_threshold: float = 0.25, target_sizes: transformers.utils.generic.TensorType | list[tuple] | None = None, text_labels: list[list[str]] | None = None) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/grounding_dino/processing_grounding_dino.py#L143) **Parámetros:** outputs (`GroundingDinoObjectDetectionOutput`) : Salidas crudas del modelo. input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Los ids de los tokens del texto de entrada. Si no se proporcionan, se tomarán de la salida del modelo. threshold (`float`, *opcional*, valor predeterminado 0.25) : Umbral para conservar las predicciones de detección de objetos en función de la puntuación de confianza. text_threshold (`float`, *opcional*, valor predeterminado 0.25) : Umbral de puntuación para conservar las predicciones de detección de texto. target_sizes (`torch.Tensor` o `list[tuple[int, int]]`, *opcional*) : Tensor de forma `(batch_size, 2)` o lista de tuplas (`tuple[int, int]`) que contiene el tamaño objetivo `(height, width)` de cada imagen del lote. Si no se establece, las predicciones no se redimensionarán. text_labels (`list[list[str]]`, *opcional*) : Lista de etiquetas candidatas a detectar en cada imagen. Por el momento *NO se utiliza*, pero es obligatoria en la firma de la pipeline de detección de objetos sin ejemplos. Las etiquetas de texto se extraen en su lugar del tensor `input_ids` proporcionado en `outputs`. **Devuelve:** `list[Dict]` Una lista de diccionarios, donde cada diccionario contiene - **scores**: tensor de puntuaciones de confianza para los objetos detectados - **boxes**: tensor de cajas delimitadoras en formato [x0, y0, x1, y1] - **labels**: lista de etiquetas de texto para cada objeto detectado (se reemplazarán con ids enteros en v4.51.0) - **text_labels**: lista de etiquetas de texto para los objetos detectados Convierte la salida cruda de [GroundingDinoForObjectDetection](/docs/transformers/main/es/model_doc/grounding-dino#transformers.GroundingDinoForObjectDetection) en cajas delimitadoras finales en el formato (top_left_x, top_left_y, bottom_right_x, bottom_right_y) y obtiene la etiqueta de texto asociada. ## GroundingDinoConfig[[transformers.GroundingDinoConfig]] #### transformers.GroundingDinoConfig[[transformers.GroundingDinoConfig]] ```python transformers.GroundingDinoConfig(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, 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, is_encoder_decoder: bool = True, backbone_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, text_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, num_queries: int = 900, encoder_layers: int = 6, encoder_ffn_dim: int = 2048, encoder_attention_heads: int = 8, decoder_layers: int = 6, decoder_ffn_dim: int = 2048, decoder_attention_heads: int = 8, activation_function: str = 'relu', d_model: int = 256, dropout: float | int = 0.1, attention_dropout: float | int = 0.0, activation_dropout: float | int = 0.0, auxiliary_loss: bool = False, position_embedding_type: str = 'sine', num_feature_levels: int = 4, encoder_n_points: int = 4, decoder_n_points: int = 4, two_stage: bool = True, class_cost: float = 1.0, bbox_cost: float = 5.0, giou_cost: float = 2.0, bbox_loss_coefficient: float = 5.0, giou_loss_coefficient: float = 2.0, focal_alpha: float = 0.25, disable_custom_kernels: bool = False, max_text_len: int = 256, text_enhancer_dropout: float | int = 0.0, fusion_droppath: float | int = 0.1, fusion_dropout: float | int = 0.0, embedding_init_target: bool = True, query_dim: int = 4, decoder_bbox_embed_share: bool = True, two_stage_bbox_embed_share: bool = False, positional_embedding_temperature: int = 20, init_std: float = 0.02, layer_norm_eps: float = 1e-05, tie_word_embeddings: bool = True) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/grounding_dino/configuration_grounding_dino.py#L28) **Parámetros:** is_encoder_decoder (`bool`, *opcional*, valor predeterminado `True`) : Indica si el modelo se utiliza como codificador/decodificador o no. backbone_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opcional*) : La configuración del modelo de base. text_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opcional*) : El objeto de configuración o el diccionario del backbone de texto. num_queries (`int`, *opcional*, valor predeterminado 900) : Número de consultas de objetos, es decir, ranuras de detección. Este es el número máximo de objetos que [GroundingDinoModel](/docs/transformers/main/es/model_doc/grounding-dino#transformers.GroundingDinoModel) puede detectar en una sola imagen. encoder_layers (`int`, *opcional*, valor predeterminado `6`) : Número de capas ocultas en el codificador Transformer. Usará el mismo valor que `num_layers` si no se establece. encoder_ffn_dim (`int`, *opcional*, valor predeterminado `2048`) : Dimensionalidad de la capa "intermedia" (a menudo denominada feed-forward) en el codificador. encoder_attention_heads (`int`, *opcional*, valor predeterminado `8`) : Número de cabezas de atención para cada capa de atención en el codificador Transformer. decoder_layers (`int`, *opcional*, valor predeterminado `6`) : Número de capas ocultas en el decodificador Transformer. Usará el mismo valor que `num_layers` si no se establece. decoder_ffn_dim (`int`, *opcional*, valor predeterminado `2048`) : Dimensionalidad de la capa "intermedia" (a menudo denominada feed-forward) en el decodificador. decoder_attention_heads (`int`, *opcional*, valor predeterminado `8`) : Número de cabezas de atención para cada capa de atención en el decodificador del Transformer. activation_function (`str`, *opcional*, valor predeterminado `relu`) : La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo, `"gelu"`, `"relu"`, `"silu"`, etc. d_model (`int`, *opcional*, valor predeterminado `256`) : Tamaño de las capas del codificador y de la capa pooler. dropout (`Union[float, int]`, *opcional*, valor predeterminado `0.1`) : La proporción para todas las capas de dropout. attention_dropout (`Union[float, int]`, *opcional*, valor predeterminado `0.0`) : La proporción de dropout para las probabilidades de atención. activation_dropout (`Union[float, int]`, *opcional*, valor predeterminado `0.0`) : La proporción de dropout para las activaciones dentro de la capa totalmente conectada. auxiliary_loss (`bool`, *opcional*, valor predeterminado `False`) : Si se deben utilizar las pérdidas de decodificación auxiliares (pérdidas en cada capa del decodificador). position_embedding_type (`str`, *opcional*, valor predeterminado `"sine"`) : Tipo de incrustaciones de posición que se utilizará sobre las características de la imagen. Uno de `"sine"` o `"learned"`. num_feature_levels (`int`, *opcional*, valor predeterminado 4) : El número de niveles de características de entrada. encoder_n_points (`int`, *opcional*, valor predeterminado: 4) : El número de claves muestreadas en cada nivel de características para cada cabeza de atención en el codificador. decoder_n_points (`int`, *opcional*, valor predeterminado: 4) : El número de claves muestreadas en cada nivel de características para cada cabeza de atención en el decodificador. two_stage (`bool`, *opcional*, valor predeterminado `True`) : Si se aplica un deformable DETR de dos etapas, en el que las propuestas de región también se generan mediante una variante de Grounding DINO, que luego se introducen en el decodificador para el refinamiento iterativo de las cajas delimitadoras. class_cost (`float`, *opcional*, valor predeterminado `1.0`) : Peso relativo del error de clasificación en el coste de correspondencia húngara. bbox_cost (`float`, *opcional*, valor predeterminado `5.0`) : Peso relativo del error de la caja delimitadora L1 en el costo de correspondencia húngara. giou_cost (`float`, *opcional*, valor predeterminado `2.0`) : Peso relativo de la pérdida de IoU generalizada en el coste de emparejamiento húngaro. bbox_loss_coefficient (`float`, *opcional*, valor predeterminado `5.0`) : Peso relativo de la pérdida de caja delimitadora L1 en la pérdida de segmentación panóptica. giou_loss_coefficient (`float`, *opcional*, valor predeterminado `2.0`) : Peso relativo de la pérdida de IoU generalizada en la pérdida de segmentación panóptica. focal_alpha (`float`, *opcional*, valor predeterminado `0.25`) : Parámetro alfa en la pérdida focal. disable_custom_kernels (`bool`, *opcional*, valor predeterminado `False`) : Desactiva el uso de kernels personalizados de CUDA y CPU. Esta opción es necesaria para la exportación a ONNX, ya que los kernels personalizados no son compatibles con la exportación ONNX de PyTorch. max_text_len (`int`, *opcional*, valor predeterminado 256) : La longitud máxima de la entrada de texto. text_enhancer_dropout (`float`, *opcional*, valor predeterminado 0.0) : La proporción de dropout para el mejorador de texto. fusion_droppath (`float`, *opcional*, valor predeterminado 0.1) : La proporción de droppath para el módulo de fusión. fusion_dropout (`float`, *opcional*, valor predeterminado 0.0) : La proporción de dropout para el módulo de fusión. embedding_init_target (`bool`, *opcional*, valor predeterminado `True`) : Si se debe inicializar el objetivo con pesos de Embedding. query_dim (`int`, *opcional*, valor predeterminado 4) : La dimensión del vector de consulta. decoder_bbox_embed_share (`bool`, *opcional*, valor predeterminado `True`) : Si se debe compartir la cabeza de regresión de bbox para todas las capas del decodificador. two_stage_bbox_embed_share (`bool`, *opcional*, valor predeterminado `False`) : Si se debe compartir el embedding de bbox entre el generador de bbox de dos etapas y la generación de propuestas de región. positional_embedding_temperature (`float`, *opcional*, valor predeterminado 20) : La temperatura para Sine Positional Embedding que se utiliza junto con el vision backbone. init_std (`float`, *opcional*, valor predeterminado `0.02`) : La desviación estándar de truncated_normal_initializer para inicializar todas las matrices de pesos. layer_norm_eps (`float`, *opcional*, valor predeterminado `1e-05`) : El epsilon utilizado por las capas de normalización de capas. tie_word_embeddings (`bool`, *opcional*, valor predeterminado `True`) : Indica si se deben vincular las incrustaciones de pesos según el mapeo `tied_weights_keys` del modelo. Esta es la clase de configuración para almacenar la configuración de un modelo Grounding Dino. Se utiliza para instanciar un modelo Grounding Dino según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de [IDEA-Research/grounding-dino-tiny](https://huggingface.co/IDEA-Research/grounding-dino-tiny) Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información. Ejemplos: ```python >>> from transformers import GroundingDinoConfig, GroundingDinoModel >>> # Initializing a Grounding DINO IDEA-Research/grounding-dino-tiny style configuration >>> configuration = GroundingDinoConfig() >>> # Initializing a model (with random weights) from the IDEA-Research/grounding-dino-tiny style configuration >>> model = GroundingDinoModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## GroundingDinoModel[[transformers.GroundingDinoModel]] #### transformers.GroundingDinoModel[[transformers.GroundingDinoModel]] ```python transformers.GroundingDinoModel(config: GroundingDinoConfig) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/grounding_dino/modeling_grounding_dino.py#L1866) **Parámetros:** config ([GroundingDinoConfig](/docs/transformers/main/es/model_doc/grounding-dino#transformers.GroundingDinoConfig)) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo. El modelo Grounding DINO básico (constituido por un backbone y un Transformer encoder-decoder) que genera estados ocultos sin ningún head específico en la parte superior. Este modelo hereda de [PreTrainedModel](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.). Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales. #### forward[[transformers.GroundingDinoModel.forward]] ```python forward(pixel_values: Tensor, input_ids: Tensor, token_type_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, pixel_mask: typing.Optional[torch.Tensor] = None, encoder_outputs = None, output_attentions = None, output_hidden_states = None, return_dict = None, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/grounding_dino/modeling_grounding_dino.py#L2008) **Parámetros:** pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`) : Los tensores correspondientes a las imágenes de entrada. Los valores de píxeles se pueden obtener mediante [GroundingDinoImageProcessor](/docs/transformers/main/es/model_doc/grounding-dino#transformers.GroundingDinoImageProcessor). Consulte [GroundingDinoImageProcessor.__call__()](/docs/transformers/main/es/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para obtener más detalles ([GroundingDinoProcessor](/docs/transformers/main/es/model_doc/grounding-dino#transformers.GroundingDinoProcessor) utiliza [GroundingDinoImageProcessor](/docs/transformers/main/es/model_doc/grounding-dino#transformers.GroundingDinoImageProcessor) para procesar las imágenes). input_ids (`torch.LongTensor` de forma `(batch_size, text_sequence_length)`) : Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada si se proporciona. Los índices se pueden obtener mediante [AutoTokenizer](/docs/transformers/main/es/model_doc/auto#transformers.AutoTokenizer). Consulte [BertTokenizer.__call__()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. token_type_ids (`torch.LongTensor` de forma `(batch_size, text_sequence_length)`, *opcional*) : Índices de tokens de segmento para indicar las primeras y segundas partes de las entradas. Los índices se seleccionan en `[0, 1]`: 0 corresponde a un token de `sentence A`, 1 corresponde a un token de `sentence B` [¿Qué son los token type IDs?](../glossary#token-type-ids) attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de la máscara seleccionados en `[0, 1]`: - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**. [¿Qué son las máscaras de atención?](../glossary#attention-mask) pixel_mask (`torch.Tensor` de forma `(batch_size, height, width)`, *opcional*) : Máscara para evitar realizar atención sobre los valores de píxeles de relleno. Valores de la máscara seleccionados en `[0, 1]`: - 1 para píxeles reales (es decir, **no enmascarados**), - 0 para píxeles de relleno (es decir, **enmascarados**). [¿Qué son las máscaras de atención?](../glossary#attention-mask) encoder_outputs (``) : Tuple consists of (`last_hidden_state`, *optional*: `hidden_states`, *optional*: `attentions`) `last_hidden_state` of shape `(batch_size, sequence_length, hidden_size)`, *optional*) es una secuencia de hidden-states en la salida de la última capa del encoder. Se utiliza en la cross-attention del decoder. output_attentions (``) : Whether or not to return the attentions tensors of all attention layers. See `attentions` under returned tensors for more detail. output_hidden_states (``) : Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for more detail. return_dict (``) : Indica si se debe devolver un [ModelOutput](/docs/transformers/main/es/main_classes/output#transformers.utils.ModelOutput) en lugar de una tupla simple. **Devuelve:** `GroundingDinoModelOutput` o `tuple(torch.Tensor)` Un `GroundingDinoModelOutput` o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([GroundingDinoConfig](/docs/transformers/main/es/model_doc/grounding-dino#transformers.GroundingDinoConfig)) y las entradas. El método forward de [GroundingDinoModel](/docs/transformers/main/es/model_doc/grounding-dino#transformers.GroundingDinoModel) sobrescribe el método especial `__call__`. Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente. - **last_hidden_state** (`torch.Tensor` de forma `(batch_size, num_queries, hidden_size)`) -- Secuencia de estados ocultos en la salida de la última capa del decodificador del modelo. - **init_reference_points** (`torch.Tensor` de forma `(batch_size, num_queries, 4)`) -- Puntos de referencia iniciales enviados a través del decodificador Transformer. - **intermediate_hidden_states** (`torch.Tensor` de forma `(batch_size, config.decoder_layers, num_queries, hidden_size)`) -- Estados ocultos intermedios apilados (salida de cada capa del decodificador). - **intermediate_reference_points** (`torch.Tensor` de forma `(batch_size, config.decoder_layers, num_queries, 4)`) -- Puntos de referencia intermedios apilados (puntos de referencia de cada capa del decodificador). - **decoder_hidden_states** (`tuple[torch.Tensor]`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings, si el modelo tiene una capa de embedding, + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos del decodificador en la salida de cada capa más las salidas de la incrustación inicial. - **decoder_attentions** (`tuple[tuple[torch.Tensor]]`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención. - **encoder_last_hidden_state_vision** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) -- Secuencia de estados ocultos en la salida de la última capa del codificador del modelo. - **encoder_last_hidden_state_text** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) -- Secuencia de estados ocultos en la salida de la última capa del codificador del modelo. - **encoder_vision_hidden_states** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings visuales + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos del codificador visual en la salida de cada capa más las salidas de los embeddings iniciales. - **encoder_text_hidden_states** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de las incrustaciones de texto + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos del codificador de texto en la salida de cada capa más las salidas de las incrustaciones iniciales. - **encoder_attentions** (`tuple(tuple(torch.Tensor))`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de tuplas de `torch.Tensor` (una para la atención de cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de atención texto-visión, visión-texto, text-enhancer (autoatención) y atención deformable multiescala. softmax de atención, utilizado para calcular la media ponderada en las cabezas de biatención. - **enc_outputs_class** (`torch.Tensor` de forma `(batch_size, sequence_length, config.num_labels)`, *opcional*, devuelto cuando `config.two_stage=True`) -- Puntuaciones de las cajas delimitadoras predichas, donde las `config.num_queries` cajas delimitadoras con mayor puntuación se seleccionan como propuestas de región en la primera etapa. Salida de la clasificación binaria de cajas delimitadoras (es decir, primer plano y fondo). - **enc_outputs_coord_logits** (`torch.Tensor` de forma `(batch_size, sequence_length, 4)`, *opcional*, devuelto cuando `config.two_stage=True`) -- Logits de las coordenadas de las cajas delimitadoras predichas en la primera etapa. - **encoder_logits** (`torch.Tensor` de forma `(batch_size, sequence_length, config.num_labels)`, *opcional*, se devuelve cuando `config.two_stage=True`) -- Logits de las `config.num_queries` cajas delimitadoras con mayor puntuación en la primera etapa. - **encoder_pred_boxes** (`torch.Tensor` de forma `(batch_size, sequence_length, 4)`, *opcional*, devuelto cuando `config.two_stage=True`) -- Coordenadas de las `config.num_queries` cajas delimitadoras con mayor puntuación en la primera etapa. Ejemplos: ```python >>> from transformers import AutoProcessor, AutoModel >>> from PIL import Image >>> from huggingface_hub.utils import httpx >>> from io import BytesIO >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg" >>> with httpx.stream("GET", url) as response: ... image = Image.open(BytesIO(response.read())) >>> text = "a cat." >>> processor = AutoProcessor.from_pretrained("IDEA-Research/grounding-dino-tiny") >>> model = AutoModel.from_pretrained("IDEA-Research/grounding-dino-tiny") >>> inputs = processor(images=image, text=text, return_tensors="pt") >>> outputs = model(**inputs) >>> last_hidden_states = outputs.last_hidden_state >>> list(last_hidden_states.shape) [1, 900, 256] ``` ## GroundingDinoForObjectDetection[[transformers.GroundingDinoForObjectDetection]] #### transformers.GroundingDinoForObjectDetection[[transformers.GroundingDinoForObjectDetection]] ```python transformers.GroundingDinoForObjectDetection(config: GroundingDinoConfig) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/grounding_dino/modeling_grounding_dino.py#L2376) **Parámetros:** config ([GroundingDinoConfig](/docs/transformers/main/es/model_doc/grounding-dino#transformers.GroundingDinoConfig)) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo. Modelo Grounding DINO (constituido por un backbone y un Transformer encoder-decoder) con cabezas de detección de objetos en la parte superior, para tareas como la detección COCO. Este modelo hereda de [PreTrainedModel](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.). Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales. #### forward[[transformers.GroundingDinoForObjectDetection.forward]] ```python forward(pixel_values: Tensor, input_ids: LongTensor, token_type_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.LongTensor] = None, pixel_mask: typing.Optional[torch.BoolTensor] = None, encoder_outputs: transformers.models.grounding_dino.modeling_grounding_dino.GroundingDinoEncoderOutput | tuple | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, labels: list[dict[str, typing.Union[torch.LongTensor, torch.Tensor]]] | None = None, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/grounding_dino/modeling_grounding_dino.py#L2417) **Parámetros:** pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`) : Los tensores correspondientes a las imágenes de entrada. Los valores de píxeles se pueden obtener mediante [GroundingDinoImageProcessor](/docs/transformers/main/es/model_doc/grounding-dino#transformers.GroundingDinoImageProcessor). Consulte [GroundingDinoImageProcessor.__call__()](/docs/transformers/main/es/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para obtener más detalles ([GroundingDinoProcessor](/docs/transformers/main/es/model_doc/grounding-dino#transformers.GroundingDinoProcessor) utiliza [GroundingDinoImageProcessor](/docs/transformers/main/es/model_doc/grounding-dino#transformers.GroundingDinoImageProcessor) para procesar las imágenes). input_ids (`torch.LongTensor` de forma `(batch_size, text_sequence_length)`) : Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada si se proporciona. Los índices se pueden obtener mediante [AutoTokenizer](/docs/transformers/main/es/model_doc/auto#transformers.AutoTokenizer). Consulte [BertTokenizer.__call__()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. token_type_ids (`torch.LongTensor` de forma `(batch_size, text_sequence_length)`, *opcional*) : Índices de tokens de segmento para indicar las primeras y segundas partes de las entradas. Los índices se seleccionan en `[0, 1]`: 0 corresponde a un token de `sentence A`, 1 corresponde a un token de `sentence B` [¿Qué son los token type IDs?](../glossary#token-type-ids) attention_mask (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de la máscara seleccionados en `[0, 1]`: - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**. [¿Qué son las máscaras de atención?](../glossary#attention-mask) pixel_mask (`torch.BoolTensor` de forma `(batch_size, height, width)`, *opcional*) : Máscara para evitar realizar atención sobre los valores de píxeles de relleno. Valores de la máscara seleccionados en `[0, 1]`: - 1 para píxeles reales (es decir, **no enmascarados**), - 0 para píxeles de relleno (es decir, **enmascarados**). [¿Qué son las máscaras de atención?](../glossary#attention-mask) encoder_outputs (`Union[~models.grounding_dino.modeling_grounding_dino.GroundingDinoEncoderOutput, tuple]`, *opcional*) : La tupla consiste en (`last_hidden_state`, *opcional*: `hidden_states`, *opcional*: `attentions`) `last_hidden_state` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) es una secuencia de hidden-states en la salida de la última capa del encoder. Se utiliza en la cross-attention del decoder. output_attentions (`bool`, *opcional*) : Indica si se deben devolver los tensores de atención de todas las capas de atención. Consulte `attentions` en los tensores devueltos para obtener más detalles. output_hidden_states (`bool`, *opcional*) : Indica si se deben devolver los estados ocultos de todas las capas. Consulte `hidden_states` en los tensores devueltos para obtener más detalles. return_dict (`bool`, *opcional*) : Indica si se debe devolver un [ModelOutput](/docs/transformers/main/es/main_classes/output#transformers.utils.ModelOutput) en lugar de una tupla simple. labels (`list[Dict]` de longitud `(batch_size,)`, *opcional*) : Etiquetas para calcular la pérdida de bipartite matching. Lista de diccionarios, donde cada diccionario contiene al menos las siguientes 2 claves: 'class_labels' y 'boxes' (las etiquetas de clase y las cajas delimitadoras de una imagen en el lote, respectivamente). Las propias etiquetas de clase deben ser un `torch.LongTensor` de longitud `(number of bounding boxes in the image,)` y las cajas un `torch.Tensor` de forma `(number of bounding boxes in the image, 4)`. El método forward de [GroundingDinoForObjectDetection](/docs/transformers/main/es/model_doc/grounding-dino#transformers.GroundingDinoForObjectDetection) sobrescribe el método especial `__call__`. Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente. Ejemplos: ```python >>> from huggingface_hub.utils import httpx >>> from io import BytesIO >>> import torch >>> from PIL import Image >>> from transformers import AutoProcessor, AutoModelForZeroShotObjectDetection >>> model_id = "IDEA-Research/grounding-dino-tiny" >>> device = "cuda" >>> processor = AutoProcessor.from_pretrained(model_id) >>> model = AutoModelForZeroShotObjectDetection.from_pretrained(model_id).to(device) >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg" >>> with httpx.stream("GET", url) as response: ... image = Image.open(BytesIO(response.read())) >>> # Check for cats and remote controls >>> text_labels = [["a cat", "a remote control"]] >>> inputs = processor(images=image, text=text_labels, return_tensors="pt").to(device) >>> with torch.no_grad(): ... outputs = model(**inputs) >>> results = processor.post_process_grounded_object_detection( ... outputs, ... threshold=0.4, ... text_threshold=0.3, ... target_sizes=[(image.height, image.width)] ... ) >>> # Retrieve the first image result >>> result = results[0] >>> for box, score, text_label in zip(result["boxes"], result["scores"], result["text_labels"]): ... box = [round(x, 2) for x in box.tolist()] ... print(f"Detected {text_label} with confidence {round(score.item(), 3)} at location {box}") Detected a cat with confidence 0.479 at location [344.7, 23.11, 637.18, 374.28] Detected a cat with confidence 0.438 at location [12.27, 51.91, 316.86, 472.44] Detected a remote control with confidence 0.478 at location [38.57, 70.0, 176.78, 118.18] ```