# Detección de objetos sin ejemplos

Tradicionalmente, los modelos utilizados para [detección de objetos](object_detection) requieren conjuntos de datos de imágenes etiquetadas para su entrenamiento y están limitados a detectar el conjunto de clases de los datos de entrenamiento.

La detección de objetos en modo zero-shot es una tarea de visión por computadora para detectar objetos y sus clases en imágenes, sin ningún entrenamiento previo ni conocimiento de las clases. Los modelos de detección de objetos en modo zero-shot reciben una imagen como entrada, así como una lista de clases candidatas, y producen las cajas delimitadoras y las etiquetas donde se han detectado los objetos.

> [!NOTE]
> Hugging Face alberga muchos de estos [detectores de objetos de vocabulario abierto y cero disparos](https://huggingface.co/models?pipeline_tag=zero-shot-object-detection).

En esta guía aprenderás a utilizar este tipo de modelos:

- para detectar objetos basándose en indicaciones de texto
- para la detección de objetos por lotes
- para la detección de objetos guiada por imágenes

Antes de comenzar, asegúrate de tener instaladas todas las bibliotecas necesarias:

```bash
pip install -q transformers
```

## Pipeline de detección de objetos sin ejemplos

La forma más sencilla de probar la inferencia con modelos es utilizarla en un [pipeline()](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.pipeline). Crea una instancia de pipeline para la detección de objetos sin ejemplos de un [punto de control en el Hugging Face Hub](https://huggingface.co/models?pipeline_tag=zero-shot-object-detection):

```python
>>> from transformers import pipeline

>>> # Use any checkpoint from the hf.co/models?pipeline_tag=zero-shot-object-detection
>>> checkpoint = "iSEE-Laboratory/llmdet_large"
>>> detector = pipeline(model=checkpoint, task="zero-shot-object-detection")
```

A continuación, elija una imagen en la que desee detectar objetos. Aquí utilizaremos la imagen de la astronauta Eileen Collins, que forma parte del conjunto de datos Great Images de [NASA](https://www.nasa.gov/multimedia/imagegallery/index.html).

```py
>>> from transformers.image_utils import load_image

>>> url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/zero-sh-obj-detection_1.png"
>>> image = load_image(url)
>>> image
```

     

Pase la imagen y las etiquetas de objetos candidatos a buscar a la pipeline. Aquí pasamos la imagen directamente; otras opciones adecuadas incluyen una ruta local a una imagen o una URL de imagen. También pasamos descripciones de texto para todos los elementos que queremos consultar en la imagen.

```py
>>> predictions = detector(
...     image,
...     candidate_labels=["human face", "rocket", "nasa badge", "star-spangled banner"],
...     threshold=0.45,
... )
>>> predictions
[{'score': 0.8409242033958435,
  'label': 'human face',
  'box': {'xmin': 179, 'ymin': 74, 'xmax': 272, 'ymax': 179}},
 {'score': 0.7380027770996094,
  'label': 'rocket',
  'box': {'xmin': 353, 'ymin': 0, 'xmax': 466, 'ymax': 284}},
 {'score': 0.5850900411605835,
  'label': 'star-spangled banner',
  'box': {'xmin': 0, 'ymin': 0, 'xmax': 96, 'ymax': 511}},
 {'score': 0.5697067975997925,
  'label': 'human face',
  'box': {'xmin': 18, 'ymin': 15, 'xmax': 366, 'ymax': 511}},
 {'score': 0.47813931107521057,
  'label': 'star-spangled banner',
  'box': {'xmin': 353, 'ymin': 0, 'xmax': 459, 'ymax': 274}},
 {'score': 0.46597740054130554,
  'label': 'nasa badge',
  'box': {'xmin': 353, 'ymin': 0, 'xmax': 462, 'ymax': 279}},
 {'score': 0.4585932493209839,
  'label': 'nasa badge',
  'box': {'xmin': 132, 'ymin': 348, 'xmax': 208, 'ymax': 423}}]
```

Visualicemos las predicciones:

```py
>>> from PIL import ImageDraw

>>> draw = ImageDraw.Draw(image)

>>> for prediction in predictions:
...     box = prediction["box"]
...     label = prediction["label"]
...     score = prediction["score"]

...     xmin, ymin, xmax, ymax = box.values()
...     draw.rectangle((xmin, ymin, xmax, ymax), outline="red", width=1)
...     draw.text((xmin, ymin), f"{label}: {round(score,2)}", fill="white")

>>> image
```

     

## Detección de objetos sin ejemplos con texto como indicación, de forma manual

Ahora que has visto cómo usar la pipeline de detección de objetos sin ejemplos, vamos a replicar el mismo resultado manualmente.

Comience cargando el modelo y el procesador asociados desde un [punto de control en el Hugging Face Hub](https://hf.co/iSEE-Laboratory/llmdet_large). Aquí utilizaremos el mismo punto de control que antes:

```py
>>> from transformers import AutoProcessor, AutoModelForZeroShotObjectDetection

>>> model = AutoModelForZeroShotObjectDetection.from_pretrained(checkpoint, device_map="auto")
>>> processor = AutoProcessor.from_pretrained(checkpoint)
```

Tomemos una imagen diferente para variar.

```py
>>> url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/zero-sh-obj-detection_3.png"
>>> image = load_image(url)
>>> image
```

     

Use el procesador para preparar las entradas del modelo.

```py
>>> text_labels = ["hat", "book", "sunglasses", "camera"]
>>> inputs = processor(text=text_labels, images=image, return_tensors="pt").to(model.device)
```

Pasa las entradas por el modelo, realiza el posprocesado y visualiza los resultados. Dado que el procesador de imágenes redimensionó las imágenes antes de pasarlas al modelo, debes usar el método `post_process_object_detection` para asegurarte de que las cajas delimitadoras predichas tengan las coordenadas correctas en relación con la imagen original:

```py
>>> import torch

>>> with torch.inference_mode():
...     outputs = model(**inputs)

>>> results = processor.post_process_grounded_object_detection(
...    outputs, threshold=0.50, target_sizes=[(image.height, image.width)], text_labels=text_labels,
... )[0]

>>> draw = ImageDraw.Draw(image)

>>> scores = results["scores"]
>>> text_labels = results["text_labels"]
>>> boxes = results["boxes"]

>>> for box, score, text_label in zip(boxes, scores, text_labels):
...     xmin, ymin, xmax, ymax = box
...     draw.rectangle((xmin, ymin, xmax, ymax), outline="red", width=1)
...     draw.text((xmin, ymin), f"{text_label}: {round(score.item(),2)}", fill="white")

>>> image
```

     

## Procesamiento por lotes

Puedes pasar varios conjuntos de imágenes y consultas de texto para buscar objetos diferentes (o los mismos) en varias imágenes. Vamos a usar tanto la imagen del astronauta como la imagen de la playa. Para el procesamiento por lotes, debes pasar las consultas de texto como una lista anidada al procesador y las imágenes como listas de imágenes PIL, tensores de PyTorch o matrices de NumPy.

```py
>>> url1 = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/zero-sh-obj-detection_1.png"
>>> url2 = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/zero-sh-obj-detection_3.png"
>>> images = [load_image(url1), load_image(url2)]
>>> text_queries = [
...     ["human face", "rocket", "nasa badge", "star-spangled banner"],
...     ["hat", "book", "sunglasses", "camera", "can"],
... ]
>>> inputs = processor(text=text_queries, images=images, return_tensors="pt", padding=True)
```

Anteriormente, para el postprocesado, pasabas el tamaño de la imagen individual como un tensor, pero también puedes pasar una tupla o, en el caso de varias imágenes, una lista de tuplas. Creemos predicciones para los dos ejemplos y visualicemos el segundo (`image_idx = 1`).

```py
>>> with torch.no_grad():
>>>     outputs = model(**inputs)

>>> target_sizes = [(image.height, image.width) for image in images]
>>> results = processor.post_process_grounded_object_detection(
...     outputs, threshold=0.3, target_sizes=target_sizes, text_labels=text_labels,
... )
```

Visualicemos los resultados:

```py
>>> image_idx = 1
>>> draw = ImageDraw.Draw(images[image_idx])

>>> scores = results[image_idx]["scores"].tolist()
>>> text_labels = results[image_idx]["text_labels"]
>>> boxes = results[image_idx]["boxes"].tolist()

>>> for box, score, text_label in zip(boxes, scores, text_labels):
>>>     xmin, ymin, xmax, ymax = box
>>>     draw.rectangle((xmin, ymin, xmax, ymax), outline="red", width=1)
>>>     draw.text((xmin, ymin), f"{text_label}: {round(score,2)}", fill="white")

>>> images[image_idx]
```

     

## Detección de objetos guiada por imagen

Además de la detección de objetos sin ejemplos mediante consultas de texto, modelos como [OWL-ViT](https://huggingface.co/collections/ariG23498/owlvit-689b0d0872a7634a6ea17ae7) y [OWLv2](https://huggingface.co/collections/ariG23498/owlv2-689b0d27bd7d96ba3c7f7530) ofrecen detección de objetos guiada por imágenes. Esto significa que puedes utilizar una consulta de imagen para encontrar objetos similares en la imagen objetivo.

```py
>>> from transformers import AutoProcessor, AutoModelForZeroShotObjectDetection

>>> checkpoint = "google/owlv2-base-patch16-ensemble"
>>> model = AutoModelForZeroShotObjectDetection.from_pretrained(checkpoint, device_map="auto")
>>> processor = AutoProcessor.from_pretrained(checkpoint)
```

A diferencia de las consultas de texto, solo se permite una imagen de ejemplo.

Tomemos como imagen objetivo una imagen con dos gatos en un sofá, y como consulta, una imagen de un solo gato:

```py
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> image_target = Image.open(requests.get(url, stream=True).raw)

>>> query_url = "http://images.cocodataset.org/val2017/000000524280.jpg"
>>> query_image = Image.open(requests.get(query_url, stream=True).raw)
```

Echemos un vistazo rápido a las imágenes:

```py
>>> import matplotlib.pyplot as plt

>>> fig, ax = plt.subplots(1, 2)
>>> ax[0].imshow(image_target)
>>> ax[1].imshow(query_image)
>>> fig.show()
```

     

En el paso de preprocesamiento, en lugar de consultas de texto, ahora debe usar `query_images`:

```py
>>> inputs = processor(images=image_target, query_images=query_image, return_tensors="pt")
```

Para las predicciones, en lugar de pasar las entradas al modelo, pásalas a [image_guided_detection()](/docs/transformers/v5.23.0/es/model_doc/owlvit#transformers.OwlViTForObjectDetection.image_guided_detection). Dibuja las predicciones como antes, excepto que ahora no hay etiquetas.

```py
>>> with torch.no_grad():
...     outputs = model.image_guided_detection(**inputs)
...     target_sizes = torch.tensor([image_target.size[::-1]])
...     results = processor.post_process_image_guided_detection(outputs=outputs, target_sizes=target_sizes)[0]

>>> draw = ImageDraw.Draw(image_target)

>>> scores = results["scores"].tolist()
>>> boxes = results["boxes"].tolist()

>>> for box, score in zip(boxes, scores):
...     xmin, ymin, xmax, ymax = box
...     draw.rectangle((xmin, ymin, xmax, ymax), outline="white", width=4)

>>> image_target
```

     

