> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-es/modelos-de-vision/groundingdino.md).

# GroundingDINO

Detecta cualquier objeto usando descripciones de texto con GroundingDINO

Detecta cualquier objeto usando descripciones de texto con GroundingDINO.

{% hint style="success" %}
Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de [Marketplace de CLORE.AI](https://clore.ai/marketplace).
{% endhint %}

{% hint style="info" %}
Todos los ejemplos de esta guía se pueden ejecutar en servidores GPU alquilados a través de [Marketplace de CLORE.AI](https://clore.ai/marketplace) mercado.
{% endhint %}

## Alquilar en CLORE.AI

1. Visita [Marketplace de CLORE.AI](https://clore.ai/marketplace)
2. Filtra por tipo de GPU, VRAM y precio
3. Elige **Bajo demanda** (tarifa fija) o **Spot** (precio ofertado)
4. Configura tu pedido:
   * Selecciona la imagen de Docker
   * Configura los puertos (TCP para SSH, HTTP para interfaces web)
   * Añade variables de entorno si es necesario
   * Introduce el comando de inicio
5. Selecciona el método de pago: **CLORE**, **BTC**, o **USDT/USDC**
6. Crea el pedido y espera al despliegue

### Accede a tu servidor

* Encuentra los detalles de conexión en **Mis pedidos**
* Interfaces web: Usa la URL del puerto HTTP
* SSH: `ssh -p <port> root@<proxy-address>`

## ¿Qué es GroundingDINO?

GroundingDINO de IDEA-Research permite:

* Detección de objetos zero-shot con indicaciones de texto
* Detecta cualquier objeto sin entrenamiento
* Localización precisa de cajas delimitadoras de alta exactitud
* Combínalo con SAM para segmentación automática

## Recursos

* **GitHub:** [IDEA-Research/GroundingDINO](https://github.com/IDEA-Research/GroundingDINO)
* **Artículo:** [Documento técnico de GroundingDINO](https://arxiv.org/abs/2303.05499)
* **HuggingFace:** [IDEA-Research/grounding-dino](https://huggingface.co/IDEA-Research/grounding-dino-base)
* **Demo:** [Espacio de Hugging Face](https://huggingface.co/spaces/IDEA-Research/Grounding_DINO_Demo)

## Hardware recomendado

| Componente     | Mínimo        | Recomendado   | Óptimo        |
| -------------- | ------------- | ------------- | ------------- |
| GPU            | RTX 3060 12GB | RTX 4080 16GB | RTX 4090 24GB |
| VRAM           | 6GB           | 12GB          | 16GB          |
| CPU            | 4 núcleos     | 8 núcleos     | 16 núcleos    |
| RAM            | 16GB          | 32GB          | 64GB          |
| Almacenamiento | SSD de 20 GB  | 50GB NVMe     | 100GB NVMe    |
| Internet       | 100 Mbps      | 500 Mbps      | 1 Gbps        |

## Despliegue rápido en CLORE.AI

**Imagen de Docker:**

```
pytorch/pytorch:2.11.0-cuda12.8-cudnn9-devel
```

**Puertos:**

```
22/tcp
7860/http
```

**Comando:**

```bash
cd /workspace && \\
git clone https://github.com/IDEA-Research/GroundingDINO.git && \\
cd GroundingDINO && \\
pip install -e . && \\
python demo/gradio_demo.py
```

## Accediendo a tu servicio

Después del despliegue, encuentra tu `http_pub` URL en **Mis pedidos**:

1. Ve a **Mis pedidos** página
2. Haz clic en tu pedido
3. Encuentra la `http_pub` URL (p. ej., `abc123.clorecloud.net`)

Usa `https://YOUR_HTTP_PUB_URL` en lugar de `localhost` en los ejemplos a continuación.

## Instalación

```bash
git clone https://github.com/IDEA-Research/GroundingDINO.git
cd GroundingDINO
pip install -e .

# Descargar pesos
mkdir weights
cd weights
wget https://github.com/IDEA-Research/GroundingDINO/releases/download/v0.1.0-alpha/groundingdino_swint_ogc.pth
```

## Lo que puedes crear

### Etiquetado automatizado

* Anota automáticamente conjuntos de datos para entrenamiento de ML
* Genera cajas delimitadoras a partir de descripciones
* Acelera los flujos de etiquetado de datos

### Búsqueda visual

* Encuentra objetos específicos en bases de datos de imágenes
* Sistemas de moderación de contenido
* Reconocimiento de productos en el comercio minorista

### Robótica y automatización

* Localización de objetos para brazos robóticos
* Sistemas de gestión de inventario
* Inspección de control de calidad

### Aplicaciones creativas

* Recorta automáticamente los sujetos de las fotos
* Genera máscaras de objetos con SAM
* Edición de imágenes consciente del contenido

### Analítica

* Cuenta objetos en imágenes
* Rastrea el inventario a partir de fotos
* Monitoreo de fauna silvestre

## Uso básico

```python
from groundingdino.util.inference import load_model, load_image, predict, annotate
import cv2

# Cargar modelo
model = load_model(
    "groundingdino/config/GroundingDINO_SwinT_OGC.py",
    "weights/groundingdino_swint_ogc.pth"
)

# Cargar imagen
image_source, image = load_image("input.jpg")

# Detectar objetos
TEXT_PROMPT = "gato . perro . persona"
BOX_THRESHOLD = 0.35
TEXT_THRESHOLD = 0.25

boxes, logits, phrases = predict(
    model=model,
    image=image,
    caption=TEXT_PROMPT,
    box_threshold=BOX_THRESHOLD,
    text_threshold=TEXT_THRESHOLD
)

# Anotar imagen
annotated_frame = annotate(
    image_source=image_source,
    boxes=boxes,
    logits=logits,
    phrases=phrases
)

cv2.imwrite("output.jpg", annotated_frame)
```

## GroundingDINO + SAM (Grounded-SAM)

Combina la detección con la segmentación:

```python
import torch
import numpy as np
from groundingdino.util.inference import load_model, load_image, predict
from segment_anything import sam_model_registry, SamPredictor

# Cargar GroundingDINO
dino_model = load_model(
    "groundingdino/config/GroundingDINO_SwinT_OGC.py",
    "weights/groundingdino_swint_ogc.pth"
)

# Cargar SAM
sam = sam_model_registry["vit_h"](checkpoint="sam_vit_h_4b8939.pth")
sam.to(device="cuda")
sam_predictor = SamPredictor(sam)

# Cargar imagen
image_source, image = load_image("input.jpg")

# Detectar con GroundingDINO
boxes, logits, phrases = predict(
    model=dino_model,
    image=image,
    caption="persona . coche",
    box_threshold=0.35,
    text_threshold=0.25
)

# Segmentar con SAM
sam_predictor.set_image(image_source)

# Convertir las cajas al formato de SAM
H, W = image_source.shape[:2]
boxes_xyxy = boxes * torch.tensor([W, H, W, H])

masks = []
for box in boxes_xyxy:
    mask, _, _ = sam_predictor.predict(
        box=box.numpy(),
        multimask_output=False
    )
    masks.append(mask)
```

## Procesamiento por lotes

```python
import os
from groundingdino.util.inference import load_model, load_image, predict, annotate
import cv2

model = load_model(
    "groundingdino/config/GroundingDINO_SwinT_OGC.py",
    "weights/groundingdino_swint_ogc.pth"
)

input_dir = "./images"
output_dir = "./detected"
os.makedirs(output_dir, exist_ok=True)

TEXT_PROMPT = "producto . etiqueta de precio . código de barras"

for filename in os.listdir(input_dir):
    if not filename.endswith(('.jpg', '.png')):
        continue

    image_path = os.path.join(input_dir, filename)
    image_source, image = load_image(image_path)

    boxes, logits, phrases = predict(
        model=model,
        image=image,
        caption=TEXT_PROMPT,
        box_threshold=0.3,
        text_threshold=0.25
    )

    annotated = annotate(image_source, boxes, logits, phrases)
    cv2.imwrite(os.path.join(output_dir, filename), annotated)

    print(f"{filename}: Se encontraron {len(boxes)} objetos")
```

## Flujo de detección personalizado

```python
from groundingdino.util.inference import load_model, load_image, predict
import json

model = load_model(
    "groundingdino/config/GroundingDINO_SwinT_OGC.py",
    "weights/groundingdino_swint_ogc.pth"
)

def detect_and_export(image_path, prompt, output_json):
    image_source, image = load_image(image_path)
    H, W = image_source.shape[:2]

    boxes, logits, phrases = predict(
        model=model,
        image=image,
        caption=prompt,
        box_threshold=0.35,
        text_threshold=0.25
    )

    # Convertir a coordenadas absolutas
    detections = []
    for box, logit, phrase in zip(boxes, logits, phrases):
        x1, y1, x2, y2 = box * torch.tensor([W, H, W, H])
        detections.append({
            "label": phrase,
            "confidence": float(logit),
            "bbox": {
                "x1": int(x1),
                "y1": int(y1),
                "x2": int(x2),
                "y2": int(y2)
            }
        })

    with open(output_json, "w") as f:
        json.dump(detections, f, indent=2)

    return detections

# Detectar coches y personas
results = detect_and_export(
    "street.jpg",
    "coche . persona . bicicleta . semáforo",
    "detections.json"
)
```

## Interfaz de Gradio

```python
import gradio as gr
import cv2
from groundingdino.util.inference import load_model, load_image, predict, annotate
import tempfile
import numpy as np

model = load_model(
    "groundingdino/config/GroundingDINO_SwinT_OGC.py",
    "weights/groundingdino_swint_ogc.pth"
)

def detect_objects(image, text_prompt, box_threshold, text_threshold):
    # Guardar imagen temporal
    with tempfile.NamedTemporaryFile(suffix=".jpg", delete=False) as f:
        cv2.imwrite(f.name, cv2.cvtColor(np.array(image), cv2.COLOR_RGB2BGR))
        image_source, img = load_image(f.name)

    boxes, logits, phrases = predict(
        model=model,
        image=img,
        caption=text_prompt,
        box_threshold=box_threshold,
        text_threshold=text_threshold
    )

    annotated = annotate(image_source, boxes, logits, phrases)
    annotated_rgb = cv2.cvtColor(annotated, cv2.COLOR_BGR2RGB)

    return annotated_rgb, f"Se encontraron {len(boxes)} objetos: {', '.join(phrases)}"

demo = gr.Interface(
    fn=detect_objects,
    inputs=[
        gr.Image(type="pil", label="Imagen de entrada"),
        gr.Textbox(label="Objetos a detectar", value="persona . coche . perro", placeholder="objeto1 . objeto2 . objeto3"),
        gr.Slider(0.1, 0.9, value=0.35, label="Umbral de caja"),
        gr.Slider(0.1, 0.9, value=0.25, label="Umbral de texto")
    ],
    outputs=[
        gr.Image(label="Resultado de la detección"),
        gr.Textbox(label="Resumen")
    ],
    title="GroundingDINO - Detección de objetos de conjunto abierto",
    description="Detecta cualquier objeto describiéndolo en texto. Ejecutándose en los servidores GPU de CLORE.AI."
)

demo.launch(server_name="0.0.0.0", server_port=7860)
```

## Rendimiento

| Tarea              | Resolución | GPU      | Velocidad |
| ------------------ | ---------- | -------- | --------- |
| Imagen única       | 800x600    | RTX 3090 | 120 ms    |
| Imagen única       | 800x600    | RTX 4090 | 80ms      |
| Imagen única       | 1920x1080  | RTX 4090 | 150 ms    |
| Lote (10 imágenes) | 800x600    | RTX 4090 | 600ms     |

## Problemas comunes y soluciones

### Baja precisión de detección

**Problema:** Los objetos no se detectan

**Soluciones:**

* Reduce `box_threshold` a 0.2-0.3
* Reduce `text_threshold` a 0.15-0.2
* Usa descripciones de objetos más específicas
* Separa los objetos con " . " y no con comas

```python

# Buen formato de indicación
TEXT_PROMPT = "coche rojo . persona con sombrero . silla de madera"

# Mal formato de indicación
TEXT_PROMPT = "coche rojo, persona con sombrero, silla de madera"
```

### Sin memoria

**Problema:** Error de memoria CUDA OOM en imágenes grandes

**Soluciones:**

```python

# Redimensiona las imágenes grandes antes de la detección
from PIL import Image

def resize_if_needed(image_path, max_size=1280):
    img = Image.open(image_path)
    if max(img.size) > max_size:
        ratio = max_size / max(img.size)
        new_size = (int(img.width * ratio), int(img.height * ratio))
        img = img.resize(new_size, Image.LANCZOS)
        img.save(image_path)
```

### Inferencia lenta

**Problema:** La detección tarda demasiado

**Soluciones:**

* Usa imágenes de entrada más pequeñas
* Procesa varias imágenes por lotes
* Usa inferencia FP16
* Alquila una GPU más rápida (RTX 4090, A100)

### Falsos positivos

**Problema:** Detectando objetos incorrectos

**Soluciones:**

* Aumenta `box_threshold` a 0.4-0.5
* Sé más específico en las indicaciones
* Usa indicaciones negativas (filtra los resultados después de la detección)

```python

# Filtra las detecciones con baja confianza
filtered = [(b, l, p) for b, l, p in zip(boxes, logits, phrases) if l > 0.5]
```

## Solución de problemas

### Los objetos no se detectan

* Usa descripciones de texto más específicas
* Prueba distintas formulaciones
* Reduce el umbral de confianza

### Cajas delimitadoras incorrectas

* Sé más específico en la indicación de texto
* Usa "." para separar varios objetos
* Comprueba la calidad de las imágenes

{% hint style="danger" %}
**Sin memoria**
{% endhint %}

* Reduce la resolución de la imagen
* Procesa las imágenes de una en una
* Usa una variante de modelo más pequeña

### Inferencia lenta

* Usa TensorRT para acelerar
* Procesa por lotes imágenes de tamaño similar
* Habilita la inferencia FP16

## Estimación de costos

Tarifas típicas del marketplace de CLORE.AI (a partir de 2024):

| GPU       | Tarifa por hora | Tarifa diaria | Sesión de 4 horas |
| --------- | --------------- | ------------- | ----------------- |
| RTX 3060  | \~$0.03         | \~$0.70       | \~$0.12           |
| RTX 3090  | \~$0.06         | \~$1.50       | \~$0.25           |
| RTX 4090  | \~$0.10         | \~$2.30       | \~$0.40           |
| A100 40GB | \~$0.17         | \~$4.00       | \~$0.70           |
| A100 80GB | \~$0.25         | \~$6.00       | \~$1.00           |

*Los precios varían según el proveedor y la demanda. Consulta* [*Marketplace de CLORE.AI*](https://clore.ai/marketplace) *las tarifas actuales.*

**Ahorra dinero:**

* Usa el **Spot** mercado para trabajo interrumpible — alrededor de un tercio de los servidores fija el precio spot por debajo del precio bajo demanda (mediana de \~13% de descuento), el resto lo iguala
* Paga con **CLORE** tokens
* Compara precios entre distintos proveedores

## Siguientes pasos

* [SAM2](/guides/guides_v2-es/modelos-de-vision/sam2-video.md) - Segmentar objetos detectados
* [Florence-2](/guides/guides_v2-es/modelos-de-vision/florence2.md) - Más tareas de visión
* [YOLO](/guides/guides_v2-es/vision-por-computadora/yolov8-detection.md) - Detección más rápida para clases conocidas


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-es/modelos-de-vision/groundingdino.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.